From eefe4e2254d5b981b0accf28d4c37950184ba713 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 12:38:48 -0400 Subject: [PATCH 01/40] Create __init__.py --- catalogbuilder/__init__.py | 1 + 1 file changed, 1 insertion(+) create mode 100644 catalogbuilder/__init__.py diff --git a/catalogbuilder/__init__.py b/catalogbuilder/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/catalogbuilder/__init__.py @@ -0,0 +1 @@ + From f6799f398e8c3b048b92d14a9e14dbbd2db9d975 Mon Sep 17 00:00:00 2001 From: AR from AOS Date: Fri, 19 Jul 2024 12:46:57 -0400 Subject: [PATCH 02/40] rearranging dirs since the landscape has evolved --- {cats => catalogbuilder/cats}/__init__.py | 0 .../cats}/gfdl_autotest.csv | 0 .../cats}/gfdl_template.json | 0 catalogbuilder/intakebuilder/CSVwriter.py | 98 +++++++++ catalogbuilder/intakebuilder/__init__.py | 0 catalogbuilder/intakebuilder/builderconfig.py | 50 +++++ catalogbuilder/intakebuilder/catalogcols.py | 4 + catalogbuilder/intakebuilder/config.yaml | 41 ++++ catalogbuilder/intakebuilder/configparser.py | 33 +++ catalogbuilder/intakebuilder/getinfo.py | 206 ++++++++++++++++++ catalogbuilder/intakebuilder/gfdlcrawler.py | 78 +++++++ catalogbuilder/intakebuilder/localcrawler.py | 57 +++++ catalogbuilder/intakebuilder/s3crawler.py | 59 +++++ catalogbuilder/intakebuilder/table.yaml | 9 + 14 files changed, 635 insertions(+) rename {cats => catalogbuilder/cats}/__init__.py (100%) rename {cats => catalogbuilder/cats}/gfdl_autotest.csv (100%) rename {cats => catalogbuilder/cats}/gfdl_template.json (100%) create mode 100644 catalogbuilder/intakebuilder/CSVwriter.py create mode 100644 catalogbuilder/intakebuilder/__init__.py create mode 100644 catalogbuilder/intakebuilder/builderconfig.py create mode 100644 catalogbuilder/intakebuilder/catalogcols.py create mode 100644 catalogbuilder/intakebuilder/config.yaml create mode 100644 catalogbuilder/intakebuilder/configparser.py create mode 100644 catalogbuilder/intakebuilder/getinfo.py create mode 100644 catalogbuilder/intakebuilder/gfdlcrawler.py create mode 100644 catalogbuilder/intakebuilder/localcrawler.py create mode 100644 catalogbuilder/intakebuilder/s3crawler.py create mode 100644 catalogbuilder/intakebuilder/table.yaml diff --git a/cats/__init__.py b/catalogbuilder/cats/__init__.py similarity index 100% rename from cats/__init__.py rename to catalogbuilder/cats/__init__.py diff --git a/cats/gfdl_autotest.csv b/catalogbuilder/cats/gfdl_autotest.csv similarity index 100% rename from cats/gfdl_autotest.csv rename to catalogbuilder/cats/gfdl_autotest.csv diff --git a/cats/gfdl_template.json b/catalogbuilder/cats/gfdl_template.json similarity index 100% rename from cats/gfdl_template.json rename to catalogbuilder/cats/gfdl_template.json diff --git a/catalogbuilder/intakebuilder/CSVwriter.py b/catalogbuilder/intakebuilder/CSVwriter.py new file mode 100644 index 0000000..9a6a33f --- /dev/null +++ b/catalogbuilder/intakebuilder/CSVwriter.py @@ -0,0 +1,98 @@ +import os.path +import csv +from csv import writer +from intakebuilder import builderconfig, configparser + +def getHeader(configyaml): + ''' + returns header that is the first line in the csv file, refers builderconfig.py + :return: headerlist with all columns + ''' + if configyaml: + return configyaml.headerlist + else: + return builderconfig.headerlist + +def writeHeader(csvfile): + ''' + writing header for the csv + :param csvfile: pass csvfile absolute path + :return: csv writer object + ''' + # list containing header values + # inputting these headers into a csv + with open(csvfile, "w+", newline="") as f: + writerobject = csv.writer(f) + writerobject.writerow(builderconfig.headerlist) + +def file_appender(dictinputs, csvfile): + ''' + creating function that puts values in dictionary into the csv + :param dictinputs: + :param csvfile: + :return: + ''' + # opening file in append mode + with open(csvfile, 'a', newline='') as write_obj: + # Create a writer object from csv module + csv_writer = writer(write_obj) + # add contents of list as last row in the csv file + csv_writer.writerow(dictinputs) + +def listdict_to_csv(dict_info,headerlist, csvfile, overwrite, append): + try: + #Open the CSV file in write mode and add any data with atleast 3 values associated with it + if overwrite: + with open(csvfile, 'w') as csvfile: + writer = csv.DictWriter(csvfile, fieldnames=headerlist) + print("writing..") + writer.writeheader() + for data in dict_info: + if len(data.keys()) > 2: + writer.writerow(data) + #Open the CSV file in append mode and add any data with atleast 3 values associated with it + if append: + with open(csvfile, 'a') as csvfile: + writer = csv.DictWriter(csvfile, fieldnames=headerlist) + print("writing (without header)..") + for data in dict_info: + if len(data.keys()) > 2: + writer.writerow(data) + #If neither overwrite nor append flags are found, check if a csv file already exists. If so, prompt user on what to do. If not, write to the file. + if not any((overwrite, append)): + if os.path.isfile(csvfile): + user_input = '' + while True: + user_input = input('Found existing file! Overwrite? (y/n)') + + if user_input.lower() == 'y': + with open(csvfile, 'w') as csvfile: + writer = csv.DictWriter(csvfile, fieldnames=headerlist) + print("writing..") + writer.writeheader() + for data in dict_info: + if len(data.keys()) > 2: + writer.writerow(data) + break + + elif user_input.lower() == 'n': + with open(csvfile, 'a') as csvfile: + writer = csv.DictWriter(csvfile, fieldnames=headerlist) + print("appending (without header) to existing file...") + for data in dict_info: + if len(data.keys()) > 2: + writer.writerow(data) + break + #If the user types anything besides y/n, keep asking + else: + print('Type y/n') + else: + with open(csvfile, 'w') as csvfile: + writer = csv.DictWriter(csvfile, fieldnames=headerlist) + print("writing..") + writer.writeheader() + for data in dict_info: + if len(data.keys()) > 2: + writer.writerow(data) + except IOError: + print("I/O error") diff --git a/catalogbuilder/intakebuilder/__init__.py b/catalogbuilder/intakebuilder/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/catalogbuilder/intakebuilder/builderconfig.py b/catalogbuilder/intakebuilder/builderconfig.py new file mode 100644 index 0000000..2eb95ef --- /dev/null +++ b/catalogbuilder/intakebuilder/builderconfig.py @@ -0,0 +1,50 @@ +#what kind of directory structure to expect? +#For a directory structure like /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp +# the output_path_template is set as follows. +#We have NA in those values that do not match up with any of the expected headerlist (CSV columns), otherwise we +#simply specify the associated header name in the appropriate place. E.g. The third directory in the PP path example +#above is the model (source_id), so the third list value in output_path_template is set to 'source_id'. We make sure +#this is a valid value in headerlist as well. +#The fourth directory is am5f3b1r0 which does not map to an existing header value. So we simply NA in output_path_template +#for the fourth value. + +#catalog headers +#The headerlist is expected column names in your catalog/csv file. This is usually determined by the users in conjuction +#with the ESM collection specification standards and the appropriate workflows. + +headerlist = ["activity_id", "institution_id", "source_id", "experiment_id", + "frequency", "realm", "table_id", + "member_id", "grid_label", "variable_id", + "temporal_subset", "chunk_freq","grid_label","platform","dimensions","cell_methods","path"] + +#what kind of directory structure to expect? +#For a directory structure like /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp +# the output_path_template is set as follows. +#We have NA in those values that do not match up with any of the expected headerlist (CSV columns), otherwise we +#simply specify the associated header name in the appropriate place. E.g. The third directory in the PP path example +#above is the model (source_id), so the third list value in output_path_template is set to 'source_id'. We make sure +#this is a valid value in headerlist as well. +#The fourth directory is am5f3b1r0 which does not map to an existing header value. So we simply NA in output_path_template +#for the fourth value. + + +output_path_template = ['NA','NA','source_id','NA','experiment_id','platform','custom_pp','realm','cell_methods','frequency','chunk_freq'] +output_file_template = ['realm','temporal_subset','variable_id'] + +#OUTPUT FILE INFO is currently passed as command-line argument. +#We will revisit adding a csvfile, jsonfile and logfile configuration to the builder configuration file in the future. +#csvfile = #jsonfile = #logfile = + +####################################################### + +input_path = "" # ENTER INPUT PATH HERE" #Example: /Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" +output_path = "" # ENTER NAME OF THE CSV AND JSON, THE SUFFIX ALONE. e.g catalog (the builder then generates catalog.csv and catalog.json. This can also be an absolute path) + +######### ADDITIONAL SEARCH FILTERS ########################### + +dictFilter = {} +dictFilterIgnore = {} +dictFilter["realm"]= 'atmos_cmip' +dictFilter["frequency"] = "monthly" +dictFilter["chunk_freq"] = "5yr" +dictFilterIgnore["remove"]= 'DO_NOT_USE' diff --git a/catalogbuilder/intakebuilder/catalogcols.py b/catalogbuilder/intakebuilder/catalogcols.py new file mode 100644 index 0000000..6064a4c --- /dev/null +++ b/catalogbuilder/intakebuilder/catalogcols.py @@ -0,0 +1,4 @@ +headerlist = ["activity_id", "institution_id", "source_id", "experiment_id", + "frequency", "realm", "table_id", + "member_id", "grid_label", "variable_id", + "temporal_subset", "chunk_freq","grid_label","platform","dimensions","cell_methods","path"] diff --git a/catalogbuilder/intakebuilder/config.yaml b/catalogbuilder/intakebuilder/config.yaml new file mode 100644 index 0000000..a964aca --- /dev/null +++ b/catalogbuilder/intakebuilder/config.yaml @@ -0,0 +1,41 @@ +#what kind of directory structure to expect? +#For a directory structure like /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp +# the output_path_template is set as follows. +#We have NA in those values that do not match up with any of the expected headerlist (CSV columns), otherwise we +#simply specify the associated header name in the appropriate place. E.g. The third directory in the PP path example +#above is the model (source_id), so the third list value in output_path_template is set to 'source_id'. We make sure +#this is a valid value in headerlist as well. +#The fourth directory is am5f3b1r0 which does not map to an existing header value. So we simply NA in output_path_template +#for the fourth value. + +#catalog headers +#The headerlist is expected column names in your catalog/csv file. This is usually determined by the users in conjuction +#with the ESM collection specification standards and the appropriate workflows. + +headerlist: ["activity_id", "institution_id", "source_id", "experiment_id", + "frequency", "realm", "table_id", + "member_id", "grid_label", "variable_id", + "temporal_subset", "chunk_freq","grid_label","platform","dimensions","cell_methods","path"] + +#what kind of directory structure to expect? +#For a directory structure like /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp +# the output_path_template is set as follows. +#We have NA in those values that do not match up with any of the expected headerlist (CSV columns), otherwise we +#simply specify the associated header name in the appropriate place. E.g. The third directory in the PP path example +#above is the model (source_id), so the third list value in output_path_template is set to 'source_id'. We make sure +#this is a valid value in headerlist as well. +#The fourth directory is am5f3b1r0 which does not map to an existing header value. So we simply NA in output_path_template +#for the fourth value. + +output_path_template: ['NA','NA','source_id','NA','experiment_id','platform','custom_pp','realm','cell_methods','frequency','chunk_freq'] + +output_file_template: ['realm','temporal_subset','variable_id'] + +#OUTPUT FILE INFO is currently passed as command-line argument. +#We will revisit adding a csvfile, jsonfile and logfile configuration to the builder configuration file in the future. +#csvfile = #jsonfile = #logfile = + +####################################################### + +input_path: "/Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" #"ENTER INPUT PATH HERE" #Example: /Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" +output_path: "catalog" # ENTER NAME OF THE CSV AND JSON, THE SUFFIX ALONE. e.g catalog (the builder then generates catalog.csv and catalog.json. This can also be an absolute path) diff --git a/catalogbuilder/intakebuilder/configparser.py b/catalogbuilder/intakebuilder/configparser.py new file mode 100644 index 0000000..e64bedc --- /dev/null +++ b/catalogbuilder/intakebuilder/configparser.py @@ -0,0 +1,33 @@ +import yaml +import os +class Config: + def __init__(self, config): + self.config = config + with open(self.config, 'r') as file: + configfile = yaml.safe_load(file) + try: + self.input_path = configfile['input_path'] + print("input_path :",self.input_path) + except: + raise KeyError("input_path does not exist in config") + try: + self.output_path = configfile['output_path'] + print("output_path :",self.output_path) + except: + raise KeyError("output_path does not exist in config") + try: + self.headerlist = configfile['headerlist'] + print("headerlist :",self.headerlist) + except: + raise KeyError("headerlist does not exist in config") + try: + self.output_path_template = configfile['output_path_template'] + print("output_path_template :",self.output_path_template) + except: + raise KeyError("output_path_template does not exist in config") + try: + self.output_file_template = configfile['output_file_template'] + print("output_file_template :", self.output_file_template) + except: + raise KeyError("output_file_template does not exist in config") + diff --git a/catalogbuilder/intakebuilder/getinfo.py b/catalogbuilder/intakebuilder/getinfo.py new file mode 100644 index 0000000..d974c29 --- /dev/null +++ b/catalogbuilder/intakebuilder/getinfo.py @@ -0,0 +1,206 @@ +import sys +import pandas as pd +import csv +from csv import writer +import os +import xarray as xr +from intakebuilder import builderconfig, configparser + + +''' +getinfo.py provides helper functions to get information (from filename, DRS, file/global attributes) needed to populate the catalog +''' +def getProject(projectdir,dictInfo): + ''' + return Project name from the project directory input + :type dictInfo: object + :param drsstructure: + :return: dictionary with project key + ''' + if ("archive" in projectdir or "pp" in projectdir): + project = "dev" + dictInfo["activity_id"]=project + return dictInfo + +def getinfoFromYAML(dictInfo,yamlfile,miptable=None): + import yaml + with open(yamlfile) as f: + mappings = yaml.load(f, Loader=yaml.FullLoader) + #print(mappings) + #for k, v in mappings.items(): + #print(k, "->", v) + if(miptable): + try: + dictInfo["frequency"] = mappings[miptable]["frequency"] + except KeyError: + dictInfo["frequency"] = "NA" + try: + dictInfo["realm"] = mappings[miptable]["realm"] + except KeyError: + dictInfo["realm"] = "NA" + return(dictInfo) + +def getStem(dirpath,projectdir): + ''' + return stem from the project directory passed and the files crawled within + :param dirpath: + :param projectdir: + :param stem directory: + :return: + ''' + stemdir = dirpath.split(projectdir)[1].split("/") # drsstructure is the root + return stemdir + + +def getInfoFromFilename(filename,dictInfo,logger): + # 5 AR: WE need to rework this, not being used in gfdl set up get the following from the netCDF filename e.g.rlut_Amon_GFDL-ESM4_histSST_r1i1p1f1_gr1_195001-201412.nc + #print(filename) + if(filename.endswith(".nc")): + ncfilename = filename.split(".")[0].split("_") + varname = ncfilename[0] + dictInfo["variable"] = varname + miptable = ncfilename[1] + dictInfo["mip_table"] = miptable + modelname = ncfilename[2] + dictInfo["model"] = modelname + expname = ncfilename[3] + dictInfo["experiment_id"] = expname + ens = ncfilename[4] + dictInfo["ensemble_member"] = ens + grid = ncfilename[5] + dictInfo["grid_label"] = grid + try: + tsubset = ncfilename[6] + except IndexError: + tsubset = "null" #For fx fields + dictInfo["temporal_subset"] = tsubset + else: + logger.debug("Filename not compatible with this version of the builder:"+filename) + return dictInfo + +#adding this back to trace back some old errors +def getInfoFromGFDLFilename(filename,dictInfo,logger): + # 5 AR: get the following from the netCDF filename e.g. atmos.200501-200912.t_ref.nc + if(filename.endswith(".nc")): #and not filename.startswith(".")): + ncfilename = filename.split(".") + varname = ncfilename[-2] + dictInfo["variable_id"] = varname + #miptable = "" #ncfilename[1] + #dictInfo["mip_table"] = miptable + #modelname = ncfilename[2] + #dictInfo["model"] = modelname + #expname = ncfilename[3] + #dictInfo["experiment_id"] = expname + #ens = ncfilename[4] + #dictInfo["ensemble_member"] = ens + #grid = ncfilename[5] + #dictInfo["grid_label"] = grid + try: + tsubset = ncfilename[1] + except IndexError: + tsubset = "null" #For fx fields + dictInfo["temporal_subset"] = tsubset + else: + logger.debug("Filename not compatible with this version of the builder:"+filename) + return dictInfo + +def getInfoFromGFDLDRS(dirpath,projectdir,dictInfo,configyaml): + ''' + Returns info from project directory and the DRS path to the file + :param dirpath: + :param drsstructure: + :return: + ''' + # we need thise dict keys "project", "institute", "model", "experiment_id", + # "frequency", "realm", "mip_table", + # "ensemble_member", "grid_label", "variable", + # "temporal subset", "version", "path"] + + #Grab values based on their expected position in path + stemdir = dirpath.split("/") + # adding back older versions to ensure we get info from builderconfig + stemdir = dirpath.split("/") + + #lets go backwards and match given input directory to the template, add things to dictInfo + j = -1 + cnt = 1 + if configyaml: + output_path_template = configyaml.output_path_template + else: + try: + output_path_template = builderconfig.output_path_template + except: + sys.exit("No output_path_template found in builderconfig.py. Check configuration.") + + nlen = len(output_path_template) + for i in range(nlen-1,0,-1): + try: + if(output_path_template[i] != "NA"): + try: + dictInfo[output_path_template[i]] = stemdir[(j)] + except IndexError: + print("Check configuration. Is output path template set correctly?") + exit() + except IndexError: + sys.exit("oops in getInfoFromGFDLDRS"+str(i)+str(j)+output_path_template[i]+stemdir[j]) + j = j - 1 + cnt = cnt + 1 + # WE do not want to work with anythi:1 + # ng that's not time series + #TODO have verbose option to print message + if "cell_methods" in dictInfo.keys(): + if (dictInfo["cell_methods"] != "ts"): + #print("Skipping non-timeseries data") + return {} + return dictInfo + +def getInfoFromDRS(dirpath,projectdir,dictInfo): + ''' + Returns info from project directory and the DRS path to the file + :param dirpath: + :param drsstructure: + :return: + ''' + #stemdir = getStem(dirpath, projectdir) + stemdir = dirpath.split(projectdir)[1].split("/") # drsstructure is the root + try: + institute = stemdir[2] + except: + institute = "NA" + try: + version = stemdir[9] + except: + version = "NA" + dictInfo["institute"] = institute + dictInfo["version"] = version + return dictInfo +def return_xr(fname): + filexr = (xr.open_dataset(fname)) + filexra = filexr.attrs + return filexra +def getInfoFromGlobalAtts(fname,dictInfo,filexra=None): + ''' + Returns info from the filename and xarray dataset object + :param fname: DRS compliant filename + :param filexr: Xarray dataset object + :return: dictInfo with institution_id version realm frequency and product + ''' + filexra = return_xr(fname) + if dictInfo["institute"] == "NA": + try: + institute = filexra["institution_id"] + except KeyError: + institute = "NA" + dictInfo["institute"] = institute + if dictInfo["version"] == "NA": + try: + version = filexra["version"] + except KeyError: + version = "NA" + dictInfo["version"] = version + realm = filexra["realm"] + dictInfo["realm"] = realm + frequency = filexra["frequency"] + dictInfo["frequency"] = frequency + return dictInfo + diff --git a/catalogbuilder/intakebuilder/gfdlcrawler.py b/catalogbuilder/intakebuilder/gfdlcrawler.py new file mode 100644 index 0000000..dd81c04 --- /dev/null +++ b/catalogbuilder/intakebuilder/gfdlcrawler.py @@ -0,0 +1,78 @@ +import os +from intakebuilder import getinfo, builderconfig +import sys +import re +import operator as op +''' +localcrawler crawls through the local file path, then calls helper functions in the package to getinfo. +It finally returns a list of dict. eg {'project': 'CMIP6', 'path': '/uda/CMIP6/CDRMIP/NCC/NorESM2-LM/esm-pi-cdr-pulse/r1i1p1f1/Emon/zg/gn/v20191108/zg_Emon_NorESM2-LM_esm-pi-cdr-pulse_r1i1p1f1_gn_192001-192912.nc', 'variable': 'zg', 'mip_table': 'Emon', 'model': 'NorESM2-LM', 'experiment_id': 'esm-pi-cdr-pulse', 'ensemble_member': 'r1i1p1f1', 'grid_label': 'gn', 'temporal subset': '192001-192912', 'institute': 'NCC', 'version': 'v20191108'} + +''' +def crawlLocal(projectdir, dictFilter,dictFilterIgnore,logger,configyaml): + ''' + Craw through the local directory and run through the getInfo.. functions + :param projectdir: + :return:listfiles which has a dictionary of all key/value pairs for each file to be added to the csv + ''' + listfiles = [] + pat = None + if("realm" in dictFilter.keys()) & (("frequency") in dictFilter.keys()): + pat = re.compile('({}/{}/{}/{})'.format(dictFilter["realm"],"ts",dictFilter["frequency"],dictFilter["chunk_freq"])) + + orig_pat = pat + + #TODO INCLUDE filter in traversing through directories at the top + for dirpath, dirs, files in os.walk(projectdir): + searchpath = dirpath + if (orig_pat is None): + pat = dirpath #we assume matching entire path + if(pat is not None): + m = re.search(pat, searchpath) + for filename in files: + # get info from filename + filepath = os.path.join(dirpath,filename) # 1 AR: Bugfix: this needs to join dirpath and filename to get the full path to the file + + #if filename.startswith("."): + # logger.debug("Skipping hidden file", filepath) + # continue + if not filename.endswith(".nc"): + logger.debug("FILE does not end with .nc. Skipping", filepath) + continue + logger.info(dirpath+"/"+filename) + dictInfo = {} + dictInfo = getinfo.getProject(projectdir, dictInfo) + # get info from filename + #filepath = os.path.join(dirpath,filename) # 1 AR: Bugfix: this needs to join dirpath and filename to get the full path to the file + dictInfo["path"]=filepath + if (op.countOf(filename,".") == 1): + dictInfo = getinfo.getInfoFromFilename(filename,dictInfo, logger) + else: + dictInfo = getinfo.getInfoFromGFDLFilename(filename,dictInfo, logger) + dictInfo = getinfo.getInfoFromGFDLDRS(dirpath, projectdir, dictInfo,configyaml) + list_bad_modellabel = ["","piControl","land-hist","piClim-SO2","abrupt-4xCO2","hist-piAer","hist-piNTCF","piClim-ghg","piClim-OC","hist-GHG","piClim-BC","1pctCO2"] + list_bad_chunklabel = ['DO_NOT_USE'] + if "source_id" in dictInfo: + if(dictInfo["source_id"] in list_bad_modellabel): + logger.debug("Found experiment name in model column, skipping this possibly bad DRS filename",filepath) + # continue + if "chunk_freq" in dictInfo: + if(dictInfo["chunk_freq"] in list_bad_chunklabel): + logger.debug("Found bad chunk, skipping this possibly bad DRS filename",filepath) + continue + + if configyaml: + headerlist = configyaml.headerlist + else: + headerlist = builderconfig.headerlist + # remove those keys that are not CSV headers + # move it so its one time + rmkeys = [] + for dkeys in dictInfo.keys(): + if dkeys not in headerlist: + rmkeys.append(dkeys) + rmkeys = list(set(rmkeys)) + + for k in rmkeys: dictInfo.pop(k,None) + + listfiles.append(dictInfo) + return listfiles diff --git a/catalogbuilder/intakebuilder/localcrawler.py b/catalogbuilder/intakebuilder/localcrawler.py new file mode 100644 index 0000000..ac43810 --- /dev/null +++ b/catalogbuilder/intakebuilder/localcrawler.py @@ -0,0 +1,57 @@ +import os +from intakebuilder import getinfo +import re +''' +localcrawler crawls through the local file path, then calls helper functions in the package to getinfo. +It finally returns a list of dict +''' +def crawlLocal(projectdir, dictFilter,logger): + ''' + Craw through the local directory and run through the getInfo.. functions + :param projectdir: + :return:listfiles which has a dictionary of all key/value pairs for each file to be added to the csv + ''' + listfiles = [] + pat = None + if("miptable" in dictFilter.keys()) & (("varname") in dictFilter.keys()): + pat = re.compile('({}/{}/)'.format(dictFilter["miptable"],dictFilter["varname"])) + elif("miptable" in dictFilter.keys()): + pat = re.compile('({}/)'.format(dictFilter["miptable"])) + elif(("varname") in dictFilter.keys()): + pat = re.compile('({}/)'.format(dictFilter["varname"])) + orig_pat = pat + #TODO INCLUDE filter in traversing through directories at the top + for dirpath, dirs, files in os.walk(projectdir): + #print(dirpath, dictFilter["source_prefix"]) + if dictFilter["source_prefix"] in dirpath: #TODO improved filtering + searchpath = dirpath + if (orig_pat is None): + pat = dirpath #we assume matching entire path + # print("Search filters applied", dictFilter["source_prefix"], "and", pat) + if(pat is not None): + m = re.search(pat, searchpath) + for filename in files: + logger.info(dirpath+"/"+filename) + dictInfo = {} + dictInfo = getinfo.getProject(projectdir, dictInfo) + # get info from filename + #print(filename) + filepath = os.path.join(dirpath,filename) # 1 AR: Bugfix: this needs to join dirpath and filename to get the full path to the file + if not filename.endswith(".nc"): + logger.debug("FILE does not end with .nc. Skipping", filepath) + continue + dictInfo["path"]=filepath +# print("Callin:g getinfo.getInfoFromFilename(filename, dictInfo)..") + dictInfo = getinfo.getInfoFromFilename(filename, dictInfo,logger) +# print("Calling getinfo.getInfoFromDRS(dirpath, projectdir, dictInfo)") + dictInfo = getinfo.getInfoFromDRS(dirpath, projectdir, dictInfo) +# print("Calling getinfo.getInfoFromGlobalAtts(filepath, dictInfo)") +# dictInfo = getinfo.getInfoFromGlobalAtts(filepath, dictInfo) + #eliminate bad DRS filenames spotted + list_bad_modellabel = ["","piControl","land-hist","piClim-SO2","abrupt-4xCO2","hist-piAer","hist-piNTCF","piClim-ghg","piClim-OC","hist-GHG","piClim-BC","1pctCO2"] + if(dictInfo["model"] in list_bad_modellabel): + logger.debug("Found experiment name in model column, skipping this possibly bad DRS filename", dictInfo["experiment"],filepath) + continue + listfiles.append(dictInfo) + #print(listfiles) + return listfiles diff --git a/catalogbuilder/intakebuilder/s3crawler.py b/catalogbuilder/intakebuilder/s3crawler.py new file mode 100644 index 0000000..e55d676 --- /dev/null +++ b/catalogbuilder/intakebuilder/s3crawler.py @@ -0,0 +1,59 @@ +import re +import boto3 +import botocore +from intakebuilder import getinfo + +''' +s3 crawler crawls through the S3 bucket, passes the bucket path to the helper functions to getinfo. +Finally it returns a list of dictionaries. +''' +def sss_crawler(projectdir,dictFilter,project_root, logger): + region = 'us-west-2' + s3client = boto3.client('s3', region_name=region, + config=botocore.client.Config(signature_version=botocore.UNSIGNED)) + + s3prefix = "s3:/" + filetype = ".nc" + project_bucket = projectdir.split("/")[2] + ####################################################### + listfiles = [] + pat = None + logger.debug(dictFilter.keys()) + if("miptable" in dictFilter.keys()) & (("varname") in dictFilter.keys()): + pat = re.compile('({}/{}/)'.format(dictFilter["miptable"],dictFilter["varname"])) + elif("miptable" in dictFilter.keys()): + pat = re.compile('({}/)'.format(dictFilter["miptable"])) + elif(("varname") in dictFilter.keys()): + pat = re.compile('({}/)'.format(dictFilter["varname"])) + orig_pat = pat + paginator = s3client.get_paginator('list_objects') + for result in paginator.paginate(Bucket=project_bucket, Prefix=dictFilter["source_prefix"], Delimiter=filetype): + for prefixes in result.get('CommonPrefixes'): + dictInfo = {} + dictInfo = getinfo.getProject(project_root, dictInfo) + commonprefix = prefixes.get('Prefix') + searchpath = commonprefix + if (orig_pat is None): + pat = commonprefix #we assume matching entire path + #filepath = '{}/{}/{}'.format(s3prefix,project_bucket,commonprefix) + # print("Search filters applied", dictFilter["source_prefix"], "and", pat) + if(pat is not None): + m = re.search(pat, searchpath) + if m is not None: + #print(commonprefix) + #print('{}/{}/{}'.format(s3prefix,project_bucket,commonprefix)) + filepath = '{}/{}/{}'.format(s3prefix,project_bucket,commonprefix) + #TODO if filepath already exists in csv we skip + dictInfo["path"]=filepath + logger.debug(filepath) + filename = filepath.split("/")[-1] + dirpath = "/".join(filepath.split("/")[0:-1]) + #projectdird passed to sss_crawler should be s3://bucket/project + dictInfo = getinfo.getInfoFromFilename(filename, dictInfo,logger) + dictInfo = getinfo.getInfoFromDRS(dirpath, projectdir, dictInfo) + #Using YAML instead of this to get frequency and modeling_realm dictInfo = getinfo.getInfoFromGlobalAtts(filepath, dictInfo) + #TODO YAML for all mip_tables + dictInfo = getinfo.getinfoFromYAML(dictInfo,"table.yaml",miptable=dictInfo["mip_table"]) + listfiles.append(dictInfo) + logger.debug(dictInfo) + return listfiles diff --git a/catalogbuilder/intakebuilder/table.yaml b/catalogbuilder/intakebuilder/table.yaml new file mode 100644 index 0000000..bdae363 --- /dev/null +++ b/catalogbuilder/intakebuilder/table.yaml @@ -0,0 +1,9 @@ +Amon: + frequency: mon + realm: atmos +Omon: + frequency: mon + realm: ocean +3hr: + frequency: 3hr + realm: na From 3f6c8a918cd64d98e17c1076abdc4db589e2e6ca Mon Sep 17 00:00:00 2001 From: AR from AOS Date: Fri, 19 Jul 2024 12:48:24 -0400 Subject: [PATCH 03/40] meta yml test updated --- meta.yaml | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/meta.yaml b/meta.yaml index 2fad1d6..eb3e8d1 100644 --- a/meta.yaml +++ b/meta.yaml @@ -1,5 +1,5 @@ package: - name: intakebuilder + name: catalogbuilder version: 2.0.1 source: @@ -24,8 +24,6 @@ requirements: - jsondiff test: imports: - - intakebuilder - - scripts.gen_intake_gfdl - + - catalogbuilder about: home: From 81a575740c215998a290ac37d952188ddedef9b8 Mon Sep 17 00:00:00 2001 From: AR from AOS Date: Fri, 19 Jul 2024 13:00:58 -0400 Subject: [PATCH 04/40] moving scripts --- catalogbuilder/scripts/__init__.py | 0 .../scripts/configs/config-example.yml | 2 + .../scripts/configs/config-template.yaml | 41 + catalogbuilder/scripts/gen_intake_gfdl.py | 112 + .../scripts/gen_intake_gfdl_notebook.ipynb | 4829 +++++++++++++++++ .../scripts/gen_intake_gfdl_runner.py | 11 + .../scripts/gen_intake_gfdl_runner_config.py | 9 + catalogbuilder/scripts/gen_intake_local.py | 36 + catalogbuilder/scripts/gen_intake_s3.py | 38 + catalogbuilder/scripts/test_catalog.py | 70 + 10 files changed, 5148 insertions(+) create mode 100644 catalogbuilder/scripts/__init__.py create mode 100644 catalogbuilder/scripts/configs/config-example.yml create mode 100644 catalogbuilder/scripts/configs/config-template.yaml create mode 100755 catalogbuilder/scripts/gen_intake_gfdl.py create mode 100644 catalogbuilder/scripts/gen_intake_gfdl_notebook.ipynb create mode 100755 catalogbuilder/scripts/gen_intake_gfdl_runner.py create mode 100755 catalogbuilder/scripts/gen_intake_gfdl_runner_config.py create mode 100755 catalogbuilder/scripts/gen_intake_local.py create mode 100755 catalogbuilder/scripts/gen_intake_s3.py create mode 100755 catalogbuilder/scripts/test_catalog.py diff --git a/catalogbuilder/scripts/__init__.py b/catalogbuilder/scripts/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/catalogbuilder/scripts/configs/config-example.yml b/catalogbuilder/scripts/configs/config-example.yml new file mode 100644 index 0000000..2013e59 --- /dev/null +++ b/catalogbuilder/scripts/configs/config-example.yml @@ -0,0 +1,2 @@ +input_path: "/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" #"ENTER INPUT PATH HERE" #Example: /Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" +output_path: "catalog" # ENTER NAME OF THE CSV AND JSON, THE SUFFIX ALONE. e.g catalog (the builder then generates catalog.csv and catalog.json. This can also be an absolute path) diff --git a/catalogbuilder/scripts/configs/config-template.yaml b/catalogbuilder/scripts/configs/config-template.yaml new file mode 100644 index 0000000..8d04a20 --- /dev/null +++ b/catalogbuilder/scripts/configs/config-template.yaml @@ -0,0 +1,41 @@ +#what kind of directory structure to expect? +#For a directory structure like /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp +# the output_path_template is set as follows. +#We have NA in those values that do not match up with any of the expected headerlist (CSV columns), otherwise we +#simply specify the associated header name in the appropriate place. E.g. The third directory in the PP path example +#above is the model (source_id), so the third list value in output_path_template is set to 'source_id'. We make sure +#this is a valid value in headerlist as well. +#The fourth directory is am5f3b1r0 which does not map to an existing header value. So we simply NA in output_path_template +#for the fourth value. + +#catalog headers +#The headerlist is expected column names in your catalog/csv file. This is usually determined by the users in conjuction +#with the ESM collection specification standards and the appropriate workflows. + +headerlist: ["activity_id", "institution_id", "source_id", "experiment_id", + "frequency", "modeling_realm", "table_id", + "member_id", "grid_label", "variable_id", + "temporal_subset", "chunk_freq","grid_label","platform","dimensions","cell_methods","path"] + +#what kind of directory structure to expect? +#For a directory structure like /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp +# the output_path_template is set as follows. +#We have NA in those values that do not match up with any of the expected headerlist (CSV columns), otherwise we +#simply specify the associated header name in the appropriate place. E.g. The third directory in the PP path example +#above is the model (source_id), so the third list value in output_path_template is set to 'source_id'. We make sure +#this is a valid value in headerlist as well. +#The fourth directory is am5f3b1r0 which does not map to an existing header value. So we simply NA in output_path_template +#for the fourth value. + +output_path_template: ['NA','NA','source_id','NA','experiment_id','platform','custom_pp','modeling_realm','cell_methods','frequency','chunk_freq'] + +output_file_template: ['modeling_realm','temporal_subset','variable_id'] + +#OUTPUT FILE INFO is currently passed as command-line argument. +#We will revisit adding a csvfile, jsonfile and logfile configuration to the builder configuration file in the future. +#csvfile = #jsonfile = #logfile = + +####################################################### + +input_path: "/Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" #"ENTER INPUT PATH HERE" #Example: /Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" +output_path: "catalog" # ENTER NAME OF THE CSV AND JSON, THE SUFFIX ALONE. e.g catalog (the builder then generates catalog.csv and catalog.json. This can also be an absolute path) diff --git a/catalogbuilder/scripts/gen_intake_gfdl.py b/catalogbuilder/scripts/gen_intake_gfdl.py new file mode 100755 index 0000000..a99b667 --- /dev/null +++ b/catalogbuilder/scripts/gen_intake_gfdl.py @@ -0,0 +1,112 @@ +#!/usr/bin/env python + +import json +import sys +import click +import os +from pathlib import Path +import logging + +logger = logging.getLogger('local') +logger.setLevel(logging.INFO) + +try: + from intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser +except ModuleNotFoundError: + print("The module intakebuilder is not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") + print("Attempting again with adjusted sys.path ") + try: + sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + except: + print("Unable to adjust sys.path") + #print(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + try: + from intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser + except ModuleNotFoundError: + sys.exit("The module 'intakebuilder' is still not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") + +package_dir = os.path.dirname(os.path.abspath(__file__)) +template_path = os.path.join(package_dir, '../cats/gfdl_template.json') + +#Setting up argument parsing/flags +@click.command() +#TODO arguments dont have help message. So consider changing arguments to options? +@click.argument('input_path',required=False,nargs=1) +#,help='The directory path with the datasets to be cataloged. E.g a GFDL PP path till /pp') +@click.argument('output_path',required=False,nargs=1) +#,help='Specify output filename suffix only. e.g. catalog') +@click.option('--config',required=False,type=click.Path(exists=True),nargs=1,help='Path to your yaml config, Use the config_template in intakebuilder repo') +@click.option('--filter_realm', nargs=1) +@click.option('--filter_freq', nargs=1) +@click.option('--filter_chunk', nargs=1) +@click.option('--overwrite', is_flag=True, default=False) +@click.option('--append', is_flag=True, default=False) +def main(input_path=None, output_path=None, config=None, filter_realm=None, filter_freq=None, filter_chunk=None, + overwrite=False, append=False): + + configyaml = None + # TODO error catching + #print("input path: ",input_path, " output path: ", output_path) + if input_path is None or output_path is None: + print("No paths given, using yaml configuration") + configyaml = configparser.Config(config) + if configyaml.input_path is None or not configyaml.input_path : + sys.exit("Can't find paths, is yaml configured?") + + input_path = configyaml.input_path + output_path = configyaml.output_path + + if not os.path.exists(input_path): + sys.exit("Input path does not exist. Adjust configuration.") + if not os.path.exists(Path(output_path).parent.absolute()): + sys.exit("Output path parent directory does not exist. Adjust configuration.") + project_dir = input_path + csv_path = "{0}.csv".format(output_path) + json_path = "{0}.json".format(output_path) + + ######### SEARCH FILTERS ########################### + + dictFilter = {} + dictFilterIgnore = {} + if filter_realm: + dictFilter["modeling_realm"] = filter_realm + if filter_freq: + dictFilter["frequency"] = filter_freq + if filter_chunk: + dictFilter["chunk_freq"] = filter_chunk + + ''' Override config file if necessary for dev + project_dir = "/archive/oar.gfdl.cmip6/ESM4/DECK/ESM4_1pctCO2_D1/gfdl.ncrc4-intel16-prod-openmp/pp/" + #for dev csvfile = "/nbhome/$USER/intakebuilder_cats/intake_gfdl2.csv" + dictFilterIgnore = {} + dictFilter["modeling_realm"]= 'atmos_cmip' + dictFilter["frequency"] = "monthly" + dictFilter["chunk_freq"] = "5yr" + dictFilterIgnore["remove"]= 'DO_NOT_USE' + ''' + ######################################################### + dictInfo = {} + project_dir = project_dir.rstrip("/") + logger.info("Calling gfdlcrawler.crawlLocal") + list_files = gfdlcrawler.crawlLocal(project_dir, dictFilter, dictFilterIgnore, logger, configyaml) + #Grabbing data from template JSON, changing CSV path to match output path, and dumping data in new JSON + with open(template_path, "r") as jsonTemplate: + data = json.load(jsonTemplate) + data["catalog_file"] = os.path.abspath(csv_path) + jsonFile = open(json_path, "w") + json.dump(data, jsonFile, indent=2) + jsonFile.close() + headers = CSVwriter.getHeader(configyaml) + + # When we pass relative path or just the filename the following still needs to not choke + # so we check if it's a directory first + if os.path.isdir(os.path.dirname(csv_path)): + os.makedirs(os.path.dirname(csv_path), exist_ok=True) + CSVwriter.listdict_to_csv(list_files, headers, csv_path, overwrite, append) + print("JSON generated at:", os.path.abspath(json_path)) + print("CSV generated at:", os.path.abspath(csv_path)) + logger.info("CSV generated at" + os.path.abspath(csv_path)) + + +if __name__ == '__main__': + main() diff --git a/catalogbuilder/scripts/gen_intake_gfdl_notebook.ipynb b/catalogbuilder/scripts/gen_intake_gfdl_notebook.ipynb new file mode 100644 index 0000000..5ec2ff2 --- /dev/null +++ b/catalogbuilder/scripts/gen_intake_gfdl_notebook.ipynb @@ -0,0 +1,4829 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f39f9409-ee87-4431-9953-55607daba427", + "metadata": {}, + "source": [ + "This notebook was tested from a GFDL workstation.\n", + "This notebook is an example of using catalog builder from a notebook to generate data catalogs, a.k.a intake-esm catalogs.\n", + "\n", + "How to get here? \n", + "\n", + "Login to your workstation at GFDL.\n", + "module load python/3.9\n", + "conda activate intakebuilder \n", + "(For the above: Note that you can either install your own environment using the following or use an existing environment such as this: conda activate /nbhome/Aparna.Radhakrishnan/conda/envs/intakebuilder )\n", + "\n", + "conda create -n intakebuilder \n", + "conda install intakebuilder -c noaa-gfdl -n intakebuilder\n", + "\n", + "Now, we do a couple of things to make sure your environment is available to jupyter-lab as a kernel.\n", + "\n", + "pip install ipykernel \n", + "python -m ipykernel install --user --name=intakebuilder\n", + "\n", + "Now, start a jupyter-lab session from GFDL workstation: \n", + "\n", + "jupyter-lab \n", + "\n", + "This will give you the URL to the jupyter-lab session running on your localhost. Paste the URL in your web-browser (or via TigerVNC). Paste the notebook cells from this notebook, or locate the notebook from the path where you have downloaded or cloned it via git. Go to Kernel->Change Kernel-> Choose intakebuilder.\n", + "\n", + "Run the notebook and see the results! Extend it and share it with us via a github issue. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "fb3010b8-170f-4462-ad2a-457d1d5415f7", + "metadata": {}, + "outputs": [ + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Found existing file! Overwrite? (y/n) y\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "writing..\n", + "JSON generated at: /home/a1r/mycatalog.json\n", + "CSV generated at: /home/a1r/mycatalog.csv\n" + ] + } + ], + "source": [ + "from scripts import gen_intake_gfdl\n", + "import sys,os\n", + "\n", + "######USER input begins########\n", + "\n", + "#User provides the input directory for which a data catalog needs to be generated.\n", + "#Note that depending on the date and version of the tool, only time-series data are catalogued.\n", + "\n", + "input_path = \"/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/\"\n", + "\n", + "#USER inputs the output path. Based on the following setting, user can expect to see /home/a1r/mycatalog.csv and /home/a1r/mycatalog.json generated as output.\n", + "\n", + "output_path = \"/home/a1r/mycatalog\"\n", + "\n", + "####END OF user input ##########\n", + "sys.argv = ['--INPUT_PATH', input_path, output_path]\n", + "\n", + "try:\n", + " gen_intake_gfdl.main()\n", + "except SystemExit as e:\n", + " if e.code != 0:\n", + " raise" + ] + }, + { + "cell_type": "markdown", + "id": "626eaa1f-d801-4a7d-8fad-2851c9e81070", + "metadata": {}, + "source": [ + "Let's begin our analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "181913cc-4776-4b16-95d6-c6ea1b2cbdad", + "metadata": {}, + "outputs": [], + "source": [ + "import intake_esm, intake\n", + "import matplotlib #do a pip install of tools needed in your env or from the notebook\n", + "from matplotlib import pyplot as plt\n", + "%matplotlib inline\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6665a48b-a335-4fc2-8130-1a4902a428b0", + "metadata": {}, + "outputs": [], + "source": [ + "pip install matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "0f83dbc3-3dda-4a43-82e9-fb8726b2cda8", + "metadata": {}, + "outputs": [], + "source": [ + "col_url = \"/home/a1r/mycatalog.json\"\n", + "col = intake.open_esm_datastore(col_url)" + ] + }, + { + "cell_type": "markdown", + "id": "344ada01-6716-4fbd-9cee-878ff815d7dd", + "metadata": {}, + "source": [ + "Explore the catalog" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "1ce0716e-6667-4aeb-8c4b-50a05643b87f", + "metadata": {}, + "outputs": [ + { + "data": { + "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", + "
activity_idinstitution_idsource_idexperiment_idfrequencymodeling_realmtable_idmember_idgrid_labelvariable_idtemporal_subsetchunk_freqgrid_label.1platformdimensionscell_methodspath
0devNaNam5c96L65_am5f3b1r0_pdclim1850F3hratmos_cmipNaNNaNNaNpr0002010100-00021231231yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
1devNaNam5c96L65_am5f3b1r0_pdclim1850F3hratmos_cmipNaNNaNNaNrlut0002010100-00021231231yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
2devNaNam5c96L65_am5f3b1r0_pdclim1850F3hratmos_cmipNaNNaNNaNpr0003010100-00031231231yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
3devNaNam5c96L65_am5f3b1r0_pdclim1850F3hratmos_cmipNaNNaNNaNrlut0003010100-00031231231yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
4devNaNam5c96L65_am5f3b1r0_pdclim1850F3hratmos_cmipNaNNaNNaNpr0004010100-00041231231yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
......................................................
6405devNaNam5c96L65_am5f3b1r0_pdclim1850Fmonthlyland_cmipNaNNaNNaNtreeFracNdlDcd001001-0010121yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
6406devNaNam5c96L65_am5f3b1r0_pdclim1850Fmonthlyland_cmipNaNNaNNaNtreeFracNdlEvg001001-0010121yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
6407devNaNam5c96L65_am5f3b1r0_pdclim1850Fmonthlyland_cmipNaNNaNNaNtsl001001-0010121yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
6408devNaNam5c96L65_am5f3b1r0_pdclim1850Fmonthlyland_cmipNaNNaNNaNvegFrac001001-0010121yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
6409devNaNam5c96L65_am5f3b1r0_pdclim1850Fmonthlyland_cmipNaNNaNNaNvegHeight001001-0010121yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
\n", + "

6410 rows × 17 columns

\n", + "
" + ], + "text/plain": [ + " activity_id institution_id source_id experiment_id \\\n", + "0 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", + "1 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", + "2 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", + "3 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", + "4 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", + "... ... ... ... ... \n", + "6405 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", + "6406 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", + "6407 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", + "6408 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", + "6409 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", + "\n", + " frequency modeling_realm table_id member_id grid_label \\\n", + "0 3hr atmos_cmip NaN NaN NaN \n", + "1 3hr atmos_cmip NaN NaN NaN \n", + "2 3hr atmos_cmip NaN NaN NaN \n", + "3 3hr atmos_cmip NaN NaN NaN \n", + "4 3hr atmos_cmip NaN NaN NaN \n", + "... ... ... ... ... ... \n", + "6405 monthly land_cmip NaN NaN NaN \n", + "6406 monthly land_cmip NaN NaN NaN \n", + "6407 monthly land_cmip NaN NaN NaN \n", + "6408 monthly land_cmip NaN NaN NaN \n", + "6409 monthly land_cmip NaN NaN NaN \n", + "\n", + " variable_id temporal_subset chunk_freq grid_label.1 \\\n", + "0 pr 0002010100-0002123123 1yr NaN \n", + "1 rlut 0002010100-0002123123 1yr NaN \n", + "2 pr 0003010100-0003123123 1yr NaN \n", + "3 rlut 0003010100-0003123123 1yr NaN \n", + "4 pr 0004010100-0004123123 1yr NaN \n", + "... ... ... ... ... \n", + "6405 treeFracNdlDcd 001001-001012 1yr NaN \n", + "6406 treeFracNdlEvg 001001-001012 1yr NaN \n", + "6407 tsl 001001-001012 1yr NaN \n", + "6408 vegFrac 001001-001012 1yr NaN \n", + "6409 vegHeight 001001-001012 1yr NaN \n", + "\n", + " platform dimensions cell_methods \\\n", + "0 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", + "1 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", + "2 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", + "3 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", + "4 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", + "... ... ... ... \n", + "6405 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", + "6406 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", + "6407 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", + "6408 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", + "6409 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", + "\n", + " path \n", + "0 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", + "1 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", + "2 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", + "3 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", + "4 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", + "... ... \n", + "6405 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", + "6406 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", + "6407 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", + "6408 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", + "6409 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", + "\n", + "[6410 rows x 17 columns]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "col.df" + ] + }, + { + "cell_type": "markdown", + "id": "613f8259-a92f-4be5-8268-dfbe225f0670", + "metadata": {}, + "source": [ + "Let's narrow down the search" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "62acbaec-573c-47f9-83bc-015790fd7983", + "metadata": {}, + "outputs": [], + "source": [ + "expname_filter = ['c96L65_am5f3b1r0_pdclim1850F']\n", + "modeling_realm = \"land_cmip\"\n", + "frequency = \"daily\"" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "7fa86782-3f7b-4dbf-80af-0f035003d57f", + "metadata": {}, + "outputs": [], + "source": [ + "cat = col.search(experiment_id=expname_filter,frequency=frequency,modeling_realm=modeling_realm)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "6fe2cf2f-e74a-4b50-a099-47c28541878d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'hflsLut', 'mrso', 'mrsos'}" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "set(cat.df[\"variable_id\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "aa216969-e335-4448-977c-d623a62a697e", + "metadata": {}, + "outputs": [], + "source": [ + "cat = cat.search(variable_id=\"mrso\") #Total Soil Moisture Content" + ] + }, + { + "cell_type": "markdown", + "id": "8542c4e8-07eb-48ba-b466-8e07d3405415", + "metadata": {}, + "source": [ + "dmget the files" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "5227091c-5d83-4b73-a340-22e92124e1f7", + "metadata": {}, + "outputs": [], + "source": [ + "#for simple dmget usage, just use this !dmget {file}\n", + "#use following to wrap the dmget call for each path in the catalog\n", + "def dmgetmagic(x):\n", + " cmd = 'dmget %s'% str(x) \n", + " return os.system(cmd)\n", + "\n", + "#OR refer to importing dmget , https://github.com/aradhakrishnanGFDL/canopy-cats/tree/main/notebooks/dmget.py" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "5eb6b01e-4d68-48ee-904f-dd285be7dee5", + "metadata": {}, + "outputs": [], + "source": [ + "dmstatus = cat.df[\"path\"].apply(dmgetmagic)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "8b50305d-aac1-4df5-add1-fbc9af7773ab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--> The keys in the returned dictionary of datasets are constructed as follows:\n", + "\t'source_id.experiment_id.frequency.modeling_realm.variable_id.chunk_freq'\n", + " |████████████████████████████████████████| 100.00% [1/1 00:00<00:00]\r" + ] + } + ], + "source": [ + "dset_dict = cat.to_dataset_dict(cdf_kwargs={'chunks': {'time':5}, 'decode_times': True})" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "f1c27413-e9a7-4855-b9be-1c0b9cf7f4ac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "am5.c96L65_am5f3b1r0_pdclim1850F.daily.land_cmip.mrso.1yr\n" + ] + } + ], + "source": [ + "for k in dset_dict.keys(): \n", + " print(k)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "9aae260f-87c8-4d2a-9b55-b9587c1f2309", + "metadata": {}, + "outputs": [], + "source": [ + "ds = dset_dict[\"am5.c96L65_am5f3b1r0_pdclim1850F.daily.land_cmip.mrso.1yr\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "c650221c-714e-4f2e-a53f-ca937c6c38ae", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 757MB\n",
+       "Dimensions:     (time: 3650, bnds: 2, lat: 180, lon: 288)\n",
+       "Coordinates:\n",
+       "    average_DT  (time) timedelta64[ns] 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
+       "    average_T1  (time) object 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
+       "    average_T2  (time) object 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
+       "  * bnds        (bnds) float64 16B 1.0 2.0\n",
+       "  * lat         (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n",
+       "    lat_bnds    (lat, bnds) float64 3kB dask.array<chunksize=(180, 2), meta=np.ndarray>\n",
+       "  * lon         (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n",
+       "    lon_bnds    (lon, bnds) float64 5kB dask.array<chunksize=(288, 2), meta=np.ndarray>\n",
+       "  * time        (time) object 29kB 0002-01-01 12:00:00 ... 0011-12-31 12:00:00\n",
+       "    time_bnds   (time, bnds) object 58kB dask.array<chunksize=(5, 2), meta=np.ndarray>\n",
+       "Data variables:\n",
+       "    mrso        (time, lat, lon) float32 757MB dask.array<chunksize=(5, 180, 288), meta=np.ndarray>\n",
+       "Attributes: (12/18)\n",
+       "    title:                            c96L65_am5f3b1r0_pdclim1850F\n",
+       "    grid_type:                        regular\n",
+       "    grid_tile:                        N/A\n",
+       "    code_release_version:             2023.01\n",
+       "    git_hash:                         unknown githash\n",
+       "    external_variables:               land_area\n",
+       "    ...                               ...\n",
+       "    intake_esm_attrs:variable_id:     mrso\n",
+       "    intake_esm_attrs:chunk_freq:      1yr\n",
+       "    intake_esm_attrs:platform:        gfdl.ncrc5-deploy-prod-openmp\n",
+       "    intake_esm_attrs:cell_methods:    ts\n",
+       "    intake_esm_attrs:_data_format_:   netcdf\n",
+       "    intake_esm_dataset_key:           am5.c96L65_am5f3b1r0_pdclim1850F.daily....
" + ], + "text/plain": [ + " Size: 757MB\n", + "Dimensions: (time: 3650, bnds: 2, lat: 180, lon: 288)\n", + "Coordinates:\n", + " average_DT (time) timedelta64[ns] 29kB dask.array\n", + " average_T1 (time) object 29kB dask.array\n", + " average_T2 (time) object 29kB dask.array\n", + " * bnds (bnds) float64 16B 1.0 2.0\n", + " * lat (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n", + " lat_bnds (lat, bnds) float64 3kB dask.array\n", + " * lon (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n", + " lon_bnds (lon, bnds) float64 5kB dask.array\n", + " * time (time) object 29kB 0002-01-01 12:00:00 ... 0011-12-31 12:00:00\n", + " time_bnds (time, bnds) object 58kB dask.array\n", + "Data variables:\n", + " mrso (time, lat, lon) float32 757MB dask.array\n", + "Attributes: (12/18)\n", + " title: c96L65_am5f3b1r0_pdclim1850F\n", + " grid_type: regular\n", + " grid_tile: N/A\n", + " code_release_version: 2023.01\n", + " git_hash: unknown githash\n", + " external_variables: land_area\n", + " ... ...\n", + " intake_esm_attrs:variable_id: mrso\n", + " intake_esm_attrs:chunk_freq: 1yr\n", + " intake_esm_attrs:platform: gfdl.ncrc5-deploy-prod-openmp\n", + " intake_esm_attrs:cell_methods: ts\n", + " intake_esm_attrs:_data_format_: netcdf\n", + " intake_esm_dataset_key: am5.c96L65_am5f3b1r0_pdclim1850F.daily...." + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "84071a21-5f29-4554-99cb-7c02bda9d1f7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'mrso' (time: 3650, lat: 180, lon: 288)> Size: 757MB\n",
+       "dask.array<concatenate, shape=(3650, 180, 288), dtype=float32, chunksize=(5, 180, 288), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "    average_DT  (time) timedelta64[ns] 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
+       "    average_T1  (time) object 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
+       "    average_T2  (time) object 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
+       "  * lat         (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n",
+       "  * lon         (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n",
+       "  * time        (time) object 29kB 0002-01-01 12:00:00 ... 0011-12-31 12:00:00\n",
+       "Attributes:\n",
+       "    units:            kg m-2\n",
+       "    long_name:        Total Soil Moisture Content\n",
+       "    cell_methods:     area: mean time: mean\n",
+       "    ocean_fillvalue:  0.0\n",
+       "    cell_measures:    area: land_area\n",
+       "    time_avg_info:    average_T1,average_T2,average_DT\n",
+       "    standard_name:    soil_moisture_content\n",
+       "    interp_method:    conserve_order1
" + ], + "text/plain": [ + " Size: 757MB\n", + "dask.array\n", + "Coordinates:\n", + " average_DT (time) timedelta64[ns] 29kB dask.array\n", + " average_T1 (time) object 29kB dask.array\n", + " average_T2 (time) object 29kB dask.array\n", + " * lat (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n", + " * lon (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n", + " * time (time) object 29kB 0002-01-01 12:00:00 ... 0011-12-31 12:00:00\n", + "Attributes:\n", + " units: kg m-2\n", + " long_name: Total Soil Moisture Content\n", + " cell_methods: area: mean time: mean\n", + " ocean_fillvalue: 0.0\n", + " cell_measures: area: land_area\n", + " time_avg_info: average_T1,average_T2,average_DT\n", + " standard_name: soil_moisture_content\n", + " interp_method: conserve_order1" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds[\"mrso\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "d8e8cd0c-5502-4564-bb12-a269781415ad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mrso = ds.mrso.isel(time=1).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "68b4a24c-0720-476b-8061-c42c84608e5d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAGxCAYAAABoYBJuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9eZgcZ3nu/au1956efdNIM5JGu2TL+wY2xuA4NhgwEHMIhxAC57AkwZwEAp+B4MMSOElwCFsgCQl7gATCZoyx8b7JtmxZsvZtRjOaRTPTMz291fr98VRXz1iSLVuyLEHd16VL3V1Vb7311ls19dx1P/ej+L7vEyFChAgRIkSIEAEA9cXuQIQIESJEiBAhwqmE6OEoQoQIESJEiBBhDqKHowgRIkSIECFChDmIHo4iRIgQIUKECBHmIHo4ihAhQoQIESJEmIPo4ShChAgRIkSIEGEOooejCBEiRIgQIUKEOYgejiJEiBAhQoQIEeZAf7E7cKrB8zyGh4fJZDIoivJidydChAgRIpyi8H2fQqFAV1cXqvrCcQ2VSgXLsk5IW6ZpEo/HT0hbv82IHo6ehuHhYXp6el7sbkSIECFChNMEg4ODLFiw4AVpu1Kp0LcozciYe0La6+joYO/evdED0rMgejh6GjKZDACX8PvoGC9ybyJEiBAhwqkKB5t7+UX4d+OFgGVZjIy57H10EdnM8bFTMwWPvrP3Y1lW9HD0LIgejp6G2qs0HQNdiR6OIkSIECHCURBUJj0ZEoxsRj3uh6MIx47o4ShChAgRIkQ4xeH6Hu5xlol3fe/EdOZ3ANHDUYQIESJEiHCKw8PH4/iejo53+98lRBxdhAgRIkSIECHCHETMUYQIESJEiHCKw8PjeF+KHX8LvzuIHo4iRIgQIUKEUxyu7+P6x/da7Hi3/11C9FotQoQIESJEiBBhDiLmKEKECBEiRDjFEQmyTy6ih6MIESJE+C3Gh/Zses7bfHrxuhegJ8+Owv+48JjW8xWYXqrwpbd+5ZjbfrGO6UTBw8eNHo5OGqLXahEiRIgQIUKECHMQMUcRIkSIcJrg2qcmnnWdL217KQDxXzbgq3DD5y4CwFfB18A1ZT0nBdV2B4A1ywaxPA3PD5yebz+83aRuA3B24wBLYqPzln1j+ZHrUebubZn3PW/FmSwncb0jx+VVq0BpIglAbEwnu0eYjuSYi1bx0CrSX9VyyW12+X/fuhYAuyuH/9eH5Lg1Wcfjaa7Vd8zZ5+UHjrj/UxnRa7WTi+jhKEKECBEiRDjFEWWrnVxED0cR+J/bB8PPtv/MU+K7Kzpf6O48K3Z9/oJjWm/pnz34AvckQoSTg4mfLQfg63uP/MdNDRgB49+aaZ8S5sSNO/iagqcLg+IZoNqQ3jMDgLL/IO7kFACOaaIlEugpYW3cnlZGz08zs1R8cZTmKp0t09IXK01fbJxdlXYAbh1aydi/NqAdqteidHJSQT4+UmZh0xRZswrAvvFm/H1JEgelT/Epn8RksO5YBW2yCLPCAHnTM3jlStimos5ngnzA8eS4lT37Mf6wDYCDr1rM5Pk2tUoZiquAp4Ab1M2cVfFuXvAMow1L3nfq3Tu84N/xthHh2BBpjiJEiBAhQoQIEebgtGGOXNflr//6r/nWt77FyMgIXV1d/NEf/RE33nhjWBHZ930+9rGP8bWvfY18Ps/FF1/Ml7/8Zfr7+1+wfr13185537+wtL6vT+3b8Kzb77ObAfB8lX9e1nvY8qO18eHec4/4+7Pt0/ZVJtw0AHk3edjyuGpjKBJ5ptQqWhBrqPhoisfH9w4DYCjeUfvwib2PPGMfngnu03UCc/Cxvdeyc28n4B5xue+DUtae974jRHgx8a6du4667K82SqaVVTJAAUWplYMHRfXR9iUAaNE87LRcA1rVQy+7xA4I4+OPjONOTx+ZPdB1lIYM1mJhX4qdJuaMT+OWIH72EzjFOABPzLSwZXYtninLjLRGa0bBNQJmpuoTF0KK2ISGPhGnNCXM0VJ/COZWsHc9fDe4nl0Xz7LxqnW2aC78p132im6gt+bki2HIP6D9N6NkBpqotMifN8UDfJ9wyFyPSk76Pr38aUzcKfzWyT0B2WrHu/3vEk4b5ugzn/kMX/7yl/nCF77A1q1b+cxnPsNnP/tZ/vEf/zFc57Of/Syf//zn+cpXvsJDDz1EKpXiyiuvpFI58sUWIUKECBEinA5w/RPzL8Kx4bRhju6//36uvfZarr76agB6e3v57ne/y8MPPwwIa3TzzTdz4403cu21ksHwjW98g/b2dn784x9z/fXXn7C+7PnOetLpMgDfH8/xxtY6W5P/eT/jYw0AvOE356BoHqouM1LTXZzBFAvXCfvytoX3E1fscNs/2bEv/BxXbbr0/FH7cCysVA2er2D5Ek16qKTUan0ZKupR3kQbuGRVebBUlcOvqk/t23BU9ui5YsJLAcxjqmp4xy/+BID4uIppgheQQ77u48VkPd/00MoanlETGsDOL54/bx/973nohPQ1QoTng1uGNz7j8q9OHznja0+ljepMTL4El4UfZJUpjoJiKdgNQqscfCmgBfebaZ3FPy7j7t4ftqXoBooRMCpLFzG7VO5Vnq6g2j6aLdvGJxziwwWUsUnZn2WjaMGFFzNBVYWqBeLlMt7MLL5Tv5ehSNytaBqeplETAPmuW2eKjhO+Y0NC2KzSqo6QyaqxRPEJYcCtBg0nrlBLxPNVJaQFFEfBM+bc25TgX4TfeZw2zNFFF13E7bffzo4dOwB44oknuPfee7nqqqsA2Lt3LyMjI1xxxRXhNg0NDZx//vk88MADL0qfI0SIECFChBMB7wT9i3BsOG2Yo7/6q79iZmaGFStWoGkaruvyyU9+kje/+c0AjIyMANDe3j5vu/b29nDZkVCtVqlW60zKzMzMC9D7CBEiRIgQ4fnDQ3lGTeaxthHh2HDaPBx9//vf59vf/jbf+c53WL16NY8//jjve9/76Orq4q1vfevzbvfTn/40H//4x495/YEfrgULCgURQD4w08d9jy6n+zcy6ZJFl+6U0M9OQqHcrFBcILRtao9CcszDu1Me4L5qvI6ZXll33Rue4veansRUhHKuiaKPhqe/znqm12yq4jMZiLBd/wgXR0CB116vVXwj/D/v1UXbX+1f/Ix9quHGvnOOab25OJoY1fZ1ctuC/tWGJGDBqzmFcleQylvWwAfVCUSh3SVevXTz/FeGwVuNmOrw8dYt4c9Xdp3xnPsbIQLANwfvO+qyiu/Pi9QHHDCe4W9TjyEGj97TCP1NswtY2icBnuupOL5KyRInx8mBHPgKajV4zeZCw0753H7rAP50AT94HaaYBvb6pQy9TO5dvgq124yvQ7XVJd4mcoFsssKMpzLzpCSYLPleHn/nPlk3n8f3/PBV2RFRe43mePNft51gOPvFhiR2YBgtuD95SRNcH8WTPsRHVEYuyVHNBRvNeXWmWmAuiwLiCIfjtHmt9pd/+Zf81V/9Fddffz1r167lLW95CzfccAOf/vSnAejo6ABgdHS+c+vo6Gi47Ej40Ic+xPT0dPhvcHDwqOtGiBAhQoQILwY8/8T8i3BsOG2Yo1KphKrOf5bTNA0viA76+vro6Ojg9ttv58wzzwTkFdlDDz3Eu971rqO2G4vFiMViz7r/OjMzn6G5YccbOWA3M36mRHLmtIpRlGVOHGZ7vTBKmVrlM3W+TVubRCpv7n2YnFYCwPVVSl6MUtBu3k3yuZUrn7VfNTwbkzTXYuCZ8M6de8LPx8oUHS+eSaj67UIbb3vPzwGxO7B9jfOTuwHmidkBxtxMGHUnlSoV36DgSZRccOOsig0BkFWrbLF9VhvCit06/ETEHkU4Zly5pc40fHdmDcvjkmCxwpiY99rD8xUerYrIuuIZ2L5Gjyns0Crj8DIgq83xI+6v0mBwYVbmvOureCj8ZmoFAPtNC8fVcD3Z78RUmmJJ5vzgGxeiVcAoBcLpKQ87pZIelO+VJgX1JZJzv7btICo+paC2yOMPLKXnNpv2zXulE7aNH6TK+3NkCKcKfNfF2Sa2KmosjtK/CN+UP2++odGw1+HAm+R+oZsumip/NxKGw2Xdu3jq7Gdm6k8FuCfgtdrxbv+7hNPm4ehVr3oVn/zkJ1m4cCGrV69m48aN/P3f/z1//Md/DICiKLzvfe/jE5/4BP39/fT19fGRj3yErq4uXvOa17y4nY8QIUKECBEinDY4bR6O/vEf/5GPfOQjvPvd72ZsbIyuri7+1//6X3z0ox8N1/nABz5AsVjkne98J/l8nksuuYRf/vKXxOPx497/XGbmo3s28kRlIQCOq9HcNoPaJtGYh8LkpOh7fFvFd1S0lEQs1616glc1bKQSlOiY8RJUPInG4qpNr3Hoeel1nq2/zwVPZ4uG/mv1vO+6JhHXX6/6KdrT0vuPlZ16OtQjvN0dcAoAXJ7cixZEOyrQqMYp+zKelTmucC1aEtefxQkMIm3fQ0VBU8QAz/V9qsGyoudhKgoTXjHc/l8H72XEPZxBPFFWBUdC14PZ8PPwBcJGfGH/0TUsRjDe7Zp52LLXdJ93gnsXAeAz+w63fxh0mgDYZ7VgKC7jjpzHlGKRVK2weKuLEtpmZNQypuJgBJpCTSGc1zVUjlL36qz40Lzvtq+ELKjdruOihAxpqzaDcUmgHfR03nr/H9N4pyyr5FQUr67d6756Py1xuQYqrsET9/STCFQJuVmwGnTiTcEc3TeEWwx47WfSGp0C8KoVNEVh7HyxKajJLM0dct/9izf9V2gVoikeTdosT7H8Renrc0HEHJ1cnDYPR5lMhptvvpmbb775qOsoisJNN93ETTfddPI6FiFChAgRIrzA8HwlfPA+njYiHBtOm4ejUw1nxAfk/+UDeKjcPPSKcNnCbH7euh/u+fm870ksAHJq+YXt5LOg44GGw35rjxfmZXgtsvcBsGGkB89Tw7IFv8qv4arGJ+dtWyul8mwM0q3DTzzjcg+PTi1x2O+aoqKiYigybbNPW64qKkYwpRNKvS2AWb9KoyptNquHM1UeHk2qMFJP2SfuBvL0Y91pzwLwhfGXMePAoYqYX+788kpee/4jDLmZcF0tiG47NNmmRRWWseQ7JJXo0n2hsOChdPj5H0dfzqLEJMOVHABF18QJXEgbzSJvb72HnCrXs4ZP0deYDDI8VTw6NGEulxsOhlKfdxVfo/S0ehgFb/45/eLY5QA8Or6AuC50j+crlG2DbFzMWRtjZZK6Fc6jnFnB1GTdB/f2waEY00ulPWNWITEGzV+9X9r6BpyxeTbc35LfG+eHT60HwN6eoPnxIgxKlpxvWegtwph5XW0ovo8yMR0cTBVncuqUYpTcJ7fRkhId4dDlKXxVsvMAbjm0lqtbNgGiBdtqd79Y3XxOiJijk4vTJlstQoQIESJEiBDhZCAKP58Hblq8/gi/jh11/Q/zwulWjgeDszliusOukVYA3JKB74FiyTNz0+MasRmJBlMemO88yDVddbZoZ7WdS1Pbj9r+0b2X5mtmvCP4tmrK4c/tR9ImzcXjVoWiJ21n1SpdusegI1H+kNMYZrKtMMbo1ePhPlzfw8MnoYjm6MO9L1zmWr8hrMRnO+/nZZuuZ+IxKfRpevDTX51P76sPAXBuop41OOA08B8T52N7hxfVrWmVIpw4/GbDaszA72d15wgL4nkWBJVUZ9wEqxKi91lijtGhVYmHc1Uh6XukFNHLzY3SSz7MLfPs4R9W5+qH06I31BQPFZ9bnxC9X3zYYDZYV3XEm2gi+D7pgpMgzIgdsqD7btEGLa1YeKbH7CJhTLW3j6IrHvYbFgFgvGI/t62R+fiKzbO0GLO4ZfmT4CRhz+szQF1z2PlAnemy0iqz3Y1ynDGITUHHfXkZhf0H8aZlXp6oUiHPCw8Ka6tdeBHVi2bDDLW9+SZu2n0NAKrmoZsui9j0onXzWOGi4h4nn/Eino3TDtHDUYQIESJEiHCKwz8BmiM/0hwdMxTfP0qKxO8oZmZmaGho4DKuRVeM42rr43sfPeLvH+s7+7jaPV7Yt0nkqCg+C1LTtMREd/Dw+CJGJrPEYqK9sSydlv+WqNOc9Yj99OHD2orfdbjBpuVpeL4SFqv9i4W3ktPq+qrUHH8iDT9kU44HVd9m1K1QCArsavgsMxLz2CbbFy1GjTGqBllvd5Qb+FV+LUuTkqqzIjYcZrNk1QpnmvNvKGNeOcw0atOS85bZvsuru4UB+If9989bllE9OjXRhoy5JSY8lXtK/cGyMn/96Kv5k3X3AnBpatu8bXdbbfx6qh7FR4zRC4OdXwiKFc895UkXAh8h3wMtIfPouxd/jSZtThFnfz5bVPE17GA+Wr7GdycvoOzKPcXydGbt+dmRr2oTpsP1hSG4Z0rmRsU1mLWFEd35VHc9/QqITapoVahdUsUlDolWYY6cbVmMAlTPkO+K4tPVPE3KEI3U3OLO1mUHn8swzfN6+vnBNcx8bwG5HXKNmwem8Cfzciz5/HNq94RAUdG7OvBacgDMLs3SdcMunEB0ZLkakxW5bu9b91/A83fJd3ybO/lvpqenyWafroI8Maj9Tbr9yYWkMsfHHBULHi9fO/CC9ve3BRFzFCFChAgRIpziiATZJxcRc/Q0vNDM0YvNGr1tx8Bhv82tt5ZSq/QYU4etU/P7uXiTNe/33UXRK83YdS+puOawMlOPRBeaE8TVOlv02tR8fZah1LU0B5wi416MeFD0Ka54pILuxRSVpGIQm3NexlxhvTzAUBSa1VS4bK6WaS6DNOLOogKZIPsrocTw8EImady1sIObSJ+eREUN26oxPnMRV2RZl2Ycpot6dfc53LB7KwCDVnPoT6MF22SCTCcTj6Kv883JiwBoMWbntXPn2sOz9yK8MNj5xfPnM0c+oMltsrN3gqa4MDHnNu3n7Y11NnWbleODW68L3aoLMwnUoeC68BWcDotkVtgV5Qh/o9a0SWaYqnjoikdCs8Pv03ZQy3HHYkDBD2oI1sgfYyKYyyOEfS8scSHhUbvDazM6XsxDbZA5t7B9MmSRnitzBHX2KK7Y/PMXXkXjjiBrr+Jg7JVr3B0df0Frq9WgZTK4a4LaajGNoZfGueQaYeKqrs6BYgODGxYctl3fh+4/7LfngpPJHN2yqe+EMEdXrdsbMUfHgChbLUKECBEiRIgQYQ6i12ovIJ6NJaoxCnPxuSXHXk/tuWBu5pgdvHvX8FEVHzPIYcioDhNeXQfxdHfosZ+s4Ef75PP1ix8lo1ZoaZDMnHumlmEF2VSer7Cz2BaKBw/ojehKPU+i3xxFm8PqGHM0SHvsdkbsuv9SXLVxg/7GVZucVgy3XWvmaVSlv1XfYdJzAHH8TSo6BxybGT+oeYeLhRYcfxwNn+WGsFMJRTLWxl2JfCc9I8wK2WRZ5FSbBlW2bVbjNKsw68u6h1yPfJAhN+kqWL5GxZcofthp5A+3D4UOyt8fPpu394g/zQGriYNWQ6hBKbsmFdcgqYuGZUXiIMnAXdlUXJbugH9e1huOi35n17xz41w2zInGwA/Xhp9ftmgnzUbdUVxVfG5sqXs4XdP9/BnRA/+5Jvy84LrNz7udE4HR/15JlrqepliK4VY1klk5b13pGZ4abQdgy74uvmmeTyoly3xfIW7YLGoU/59kq8UDSh8Anq2ixdzDGKO5vP2ufHP4OWVa9KTzsq2vsG9GPIa0mEs8blMpy5zzXAUj7nDlejkXKb3KPaNLZFkpgecp2HZt3oNa1vCKMuf2DbSBKh1o/XkaU69fo8kr69mSR8Or0vXM1b+74BXM9ghL1rzFoHFKdITqTAGvzAvOHrmFApU22f+CD+6gS/HYPNEJwNhEBlX3+MOr7wTgvnWHO8yfDvBQwozb599G9KLoWBE9HEWIECFChAinOCLN0clF9HD0AuMvdm95xuW1jBEvmLRPX/9vl6w+bJvjhaHUWZte3Z6n01mIx5grmop/H6zX+Xprz8UoCpiaRJfbZjs5K7ufalAbrjk2y0S1nnU2N+VU2JG6TmifXY+Qe40JcopNMcjqeaK0EE3xWBqTzLGcVmcr4oqD5WuhXmfc1Sh4wq5YqFT8GFssYWkW6lOsMOpeRrOeS8GXdSddnR12G1uqieB7Cg2fdkMi/pJncsCSSL1RL1LyTMaCdh1P441ND3FxXLJdGtV6FtxBt8x3Z9azvyzH1xWbZn1yX8gkXde1kZ8ekqwYU3XJGaVQS+J4GmuzQ6wMPHSm3STVYLtafa5FD8t5mqim8AJ3ZVUR9s+7p23euKvK4RHi7EuO7sX1dKzfCEucnXgBa/fShh1UPIOSd2Ki7lWPyq3H9jWylVE2j0jW4/7vrwvXMQyXpGkxXZQx0nWX7pycI1315mVb1fB8tDNzWdWsch//MX0O33hKatW5lka2scRfrvgVICzeD5FsxLX9QyyNj/KjsbMA2D7Riu1pXN8uOqSKb4TnY8eUaPMcV8azdi29c/E9gNwH/mHHy8J+JHQ7dOJ2fJXRp+T8Kg5UFih0NMs4eL7Cwb0t/HRE+kDGJtVQCduxbQ1dl+ulfeEEScOiFGS+WY4WsrK2pzG1sZX4uGyX5NmZo9+7+0/Dz8qkiZuU/UysVZhe0gJAeqCZxq0llA3CCJ5w36Pg+tZbm0lvED3lhrtXcvFlm1mSE8+w/7P0Vywxxhl35f50H89+Tz2SR9sLWWcxwqmH6OEoQoQIESJEOMXh+mr4MPv824heqx0rooejE4S5jE+N7blh99bDHE3nTu5hu5GuIDMspVaZcNNhpJ7RysQV+4RlvNUi2Bv7zgmjIg2PEVeheU4XVVTesfv1AIwUM9iBw7T1Q52Yb7OySRidlF7lkele8lYibD9t1DPZdMUL2QvPV7Dm1I2aqzfSgrfohYCRmHVj2L4WVi+vGAbnxvcD0KebjLoF3rHrekCy4i5vEYfuBeYEFc/gW8MXADBTjfOO3nv5o6ywJVk1EdZi69agXTvIXWWpqXTIyfDj4bWMTskavi+sBYDjaGiah6ZJn1e0jqEpHuU5mW2ZQI+0QE/xtobHGQ8ySpbpJlXf4aGqMD6m4fKGVhl7F5WUWg3nwx6rjbhiszXo085iW+g/9arcRprVEu9uuwOAbVZnOH63TKxlxo7jBBl0NWbvc4vEv6VVM0Mt1ScevpJ7f3YGsclwc658ez1bZ66eoTs2wfWNO6j4ct4yqoWGH9Z769Xr2YnPhrlR+Id7z2XRwymqXp35yhpllrUKZTFtxanYwpi1pwroqkdbqpaROP+VwNzvaqCfq/luHcksb259soqrowcM5L3FZVyeEv2fhcqEnUINtDhG3OFfzvhG6M1l+yorMpJVtnW2g+/sOIdKQXRvmSdNXA8+OPRGAJoWTB/WB12b7wb/jcELwj7N1SPNVOPMWtKuqTm0rZTxsVyNiqWTL8l1V5xM4ms+WkbO8dUrtlANrrX9xUbGi2kKRTlXvdlJ2mIFfrRRWKbEHoNqq/THTbnEq+AE5O/Qf62mKV0K+5N45d7DjmXpWx4DYNc3zyLdNx3WXXzH0vto0oXx/ebwBWzd3EP7EmHiGv/7SdzZ2cPaet6YU8+tcP5CAJo3+9zZtIJUi/Rhf6GRKzqO7uR/ukA0R8dZeDZ6rXbMiB6OIkSIECFChFMc3gkoHxIJso8dkc/R0/B8fI5u2L11HhvydBhzMrUKXoLtlSCLws5iBxF/WquS1iuckZD35pfGJQtsuy2npxbB16Dhc2OfaB+eXvl9yqtHfHFFY7M1/4KqJWsYiobre9w0fiYA1zc+zD67if2W6AV2V9po0MWXZaE5QUYrY8/px7iT4RejkmmkKj5JvZ6RYqpOGJl7KFhufbu3dd4Tfr67sIKya9ARCzJ8VIutxU4eONgLQEx3+Z+9DwLQZUwRV20qgc4po1bo1iWzaLfdzH9NnB3qNJakxlmXGKAYZN9Nu0n6YxLxLzemWKCnuLsi635w63WMj2fx7WCcfIVQlqUApocWF9bhzJ4hLmzczSJT9Ay9xgT9QZZPWo0x5ZUZcSU6s32VvFf3J9LwWWzIee3UUti+y64gi2fEyaApHt2aLB9x0wzYQRV0VHqMiZBlGnez4RjsrrRx+8Hl6AFjtKbxIFm9whsaha052zQZcKTNDdUuNDw69OmwP+1aXZ+yx8mG+qiCK/3u0oXZvDh+9Jvy0dyFx3+6AoCebJ6PLvpp+PtT1S72VkWD06gXOSu+j0FHdFq7Ku3sLIq+JqHZrE4PMVSVGl55O0l7TM73hJ3i3qHFzOQDh3If4mkLN9D0OFWNjjY5zoWZ/Lx+tcUKdMWnOCuxD4COYMwBkqqM4/8beQUAjx/qZnXzQV7XLAzuuJPlmwfERXuylMT3FWIBIzU5ncY/GMfXA3f1vnzIBmmqhzZHB1a76x4tkp9bKmJ1ywg9CTkPtd9iquzzTbmHiSseX5m4JNz20ckeAPaOtJBOV5iZEOZSndE599ydNJrF4NgWhO05nko+n8QrBDeHuEtfz1jItlUcHf2Kwz3SanB+vTD8fFXHU/zPBrkn3VHu4W93vILGz8p5MjbuwiuVTpj2SEsL1aUk4pAMrrXZErQ2cckP5tdLeyG8wk6mz9EPnlhBMnN4fcXnglLB5Q1nbIt8jo4BEXMUIUKECBEinOKINEcnFxFz9DQ8V+boL3ZvmUd1avNcmX1SajXUaVi+xribCdkM29fD2ku7K214qKSDSP7C1E6atBKVQD8w7DSG7fYYE/To5bBOl4oaujtvtd2wTYBFepUGNcYBVzKext146D6dUhwqvhayUi4KE26arCp9SKpWeDxxxeXzY5czWpFoY0EiT6tZYNaVYxm36nopgJxRYnlyJPw+VwNSY3AAvjF2MbN2DDOI2OOajeXpHJgVr6NCpe67FNMdcolyqGVK6jYLkyKgOSe9l93Vdn4yIN48+ekkquaFhRZjMRs3YOl8X0HX3NArRtU8nJIB1WDcXFCden89w2fJCvERelP3BrqMKTKKjFFcdcJja9UqdGsJxjxh256yGil6sZA57DUm6Qp20agmqfo2d1ckmv3O+IUMl7LkzGDsdQs1oK+azRK2p7JxUhx+p4pJuhqEFTFVF131Qpau0Syhqy7poOZXo1EMz8vK+BCG4nJ5oq6F+djYBeHnJ6bq3kl/2P0QTdosHQEz16FVcX1C5/AmVaVRFTbg2ZgjgO6M7HNZdoyY6oTshqr4TJWTpEzp77rGYQ6UA6aoGsfUXBal5ByvTB0Mmcrt+zvxLZW5SXm+AmpQ92xRxwTXdIkPTyaYz5ng2nJ9BU3x6Q5YMUNxKHiiy8mpZTKqRT64Rv8rfy6DpUbigVt1Vq8w68q82TbVPq+Qp6Z65GJlmmLC3HooYf00U3UxtTqbWju3+wpN4fYz1bqOa24m3qt6NtOgS5tTTgrb00JGd31iH+Nulk2lnuBY6ozMgUqO32xchVqSSecHLt9+To4llrJY0JgHoD87jueroV4pZ5T49cByynvlel+0bqjet2DQ1ZcPhr/9bOhRvjbdC8A16a1Ug3H5Vv58vnPrS+j/5FMy9tOH67CeCxQtqJ2Yy8kPjXKfmDq3jZlFwfWtwRWvfQQ9uKdsPuuFq0V/Mpmj7zy+5oQwR//jzM0Rc3QMiByyI0SIECFChAgR5iB6rXYCoOFhheyLSjzIbKn504y5GUA8XXJaibWBh4/nw51BVXZV8TGwaTMkUi96MSxfJ+9KdF7yYrTqtVpGDgVPpUGRDJW0Gg/rky3SbUq+Tb7mVg2MuhXuKi0FJLLsMSYAGPENDFzMINqccFNUfBMzYJYeK/YyHWhPWvQCK1MHubrxiaBdlSZ1NtSoPFDsD+un7Si1U3Rj7Ku0hOs+OL4ojLLXNtXdnA9V6h5LABVX5w87H0Rtk8j6KwOXYgfHsqxhnIRq85ONwlSoZY3Hc8KmPNrRQ2uiSMWS8xCLC1NkFeV7aSoWakFQfKq+gmIHldYdyRTygwwlxVVw0zImZsZCV3wGJ4TN+NTBq7h82Q4uyO4GRCOzNC7ns98cZcKzmHRl3Urgzl0KWIinqp2UDNEqWb7HY5Ul/Hq87ohedgzKjoyn42rEAw2XldYZK6cpWtKeoviMF0VrYWoujYkS3UmJyFXF496hxSFL1pwuYgQR9Hm9uzEVl2/N9AIyV3+yq+5O3d86HlYu7zdHMBSPJysyvjtVmx59Ilw3Y5RCf6dvDt7HoGuG/lW14/3Wclm3eltvmMl4oNTI40PdOAFL9/IV21nVMMKGQ6JZ+cWu1ahBRte1S57k0cketuXFkXpRYoKsIddUR3uelFllfFbGoTU9yxXt29hRlHU1xQ+vw5xWolWfCefqw8UlJFWLFaZ4ImVUh9aAVbJ9hbwX46HgerE9Fc9XeGK8zqp9dMXPAHhds4uHSlKRPm0s96IqHq26aJgqnsHuSlu43awbC1lGz1fxUFiTq7OoNdbGQ+HOPUvDjDlN8UI/sbRWwVY19lVkrAcrTSS0epZo7fgBOuLTvPKszfx6Z3AiDsl5UfLSlpU3UJtqWiaVaTtRZ7SKzah3NdA2Jn0YrC7ATcmyVev2U3EP/9Pxh9mdAMSUONVgbqxJHMBNecxeLixi5uFBnKHn7uau6AaKoVO4Rq595U/GGN3YQXAZMrXG46Xn193VlyfrfldLnoL/XtXM6Q7XV+bVwXy+bUQ4NkQPRxEiRIgQIcIpDvcEZKu5UbbaMSN6ODpO/O2S1Xxoz6ZQxzPjxUP9AohWqODK94xWwUUNNUclL0aTLp4fXcYUFd8Io+6ClwhqwdfrihWCzKdtViejdgMNmugQLkvupl0TViGtmKQV6Nbk1Jb9KgXPDqvBu74atlnrR3xObbO4YjET7OeQXXe8btBKdOjTofap6MWoaEYYja9P7gv1KQvMSWy/7r6rKR5bzA4qjvRpqJQLdQum6qIqPumAETBVh13V9lA7sSA1HUbbuuJy54GlGIcCLZgClOUYDpRbme2K0ZaR8fzokp8yaDfzq0nxnNo83kF+VBg8taRBk4UX+BPhq/hm/aahpiwa0sIkvGzBTn4/9wQ7q+Kf8+2B82g367W3DMUNNS0uCrZfv4Hl3STDdo4JW/bbbBRC1i6uOtw72U9ck3mzIjNCp5mnWZP+d+jTDM3RmT1UWAxBybn+xCjLYxIZ19jJvCcMY8Uz2DnTyoGpHABj0xm8oEr85/UrMDWX9vhM2PeV7aPhuVieGQ3Zv7yXRMPDCOb1qN3AqN0QMgt77FLIZDarkvW2JtB/TXlVhlyTa5+SeX/LWCd5Sz57vsK67uHwnB4sZXETCv0N4uPz6q4nuSRV96S5LvdIWPJg3M2yoFX2MdrYwENTi9FV6U/V0XlwcjEXNwmVsDQ2Es7v+wtLSWg2LUad0VkZHw6d4kueRjyYby4KD5WW8nhBNDz7C40ULRP3DtEGpQ96fPj1rwVgZfsoWaPCgriwLzWtXynQ4QnjI3O+6MYCLybZZ9k1cHwVW61rSDrjwv45vkZPy1R4bEPVXHg9NBolXF8NfcNUfBKaFZ7DnuQUs05Qd81XSelVXr9qY7iP7z9xDuZgwEB6sPsJOc4DC3NkElXWtQir02CUmbp6mP37W8Nt2zrzMgaGRdascIg67q7EADnurFohF7CVZ8WH6Fg8QWxCrgF3dJyjQTVN0DQIMtnU1hb8nNyDvHScQk+S0dcGtQdjZZJ/VffoagZqfFTfw0mSqhVeGyNOAy33N7I+KxqpTmOK6YCRr/gGccUOs08BPr90+VH7GOF3B9HDUYQIESJEiHCKw/PVeUkvz6+NiDk6VkQPR8eJD+0RL42ZgC0adeZXlO81DjER1C6r+CYaXhjRFLwEHZpEi0XfZEe5M8xWa9Jm8VBRg2wx29dDTxSJdMZDv5qddiPbAo+eVQEzMR4yUHEMjFBXpCkuVnB9ZNVyqIup7QMI2YKLMzvCbDVDcdlWresulpijzHiJUA9kKvWsrW59CsvXaAtYkIzqMNrSwKQj41CL4EG8dgzFCRmLohej5JkctGQcF8SneHl2S7juL59cM3/SBvv0VZ/pfJLCQWFb/vjAH/P3l3yPt7ffLX3orFIIxuT7E+exfbqNPfsCfYbhi/4oyOZpayrwzj7xYuo2Jnmg2M+jU6KJycXL3DnazyOmfH9dx0auSYkL97Brc0exP/Tw8XyFslsf3xGvgcfUXgBekdrGDd23ss+WdfdbzRy0cmyyFgTj7dEVMBINmmQm9cbl3Ga0SjiHauxHsyreNTPEeVP3BvY2S7uq4oesw4iVZdpO8IvNktFHUeM7v/+len0tNCaC+lM7qx0ctHJBXTxhLPaXm7hz+zI5tqqGYsq+zaTNv53zdTykn3bg0VNjt4x2lwdnFgdjonJudm+oy4mrNnuqbewsizZnzM4yElxDPcYUJm7IHGXUMjlV2NKFhjBItX3YvsbDxSWsD7yLsmolvCbPz+xhR6WDKTsVjJnLg7NLQj3f2vggFlp4zlbFD4Ss6ZmZQb74k6swg6TJ6V6V6lCQJdohrM1AueZHpZDRK4xbsm3JiWHVrg/VJalXSQf+RDHNQfU0SgHL4/gqj4/J9VW1DCojSfSW4F4QK2MG25Vdk5RepcWcDfvroZJWy+HcOBhQjFVPZ9tMe+g/1hor8MYzHmF0hWQpbZ7oYGJUPpemEixrHQ+z5MquyXktAzTHZbzHyylmyjKeB2YbuLhtzzzm6LNL6tq1T+3bwKbAxf3x4iJG9jexvBh4r6nK4S92gvpoaiZD/op+Dl4qa1x7/qNMWjKvN/7nanwFVnSJRutINfT6Hk6Gn0ueSXcwRwzF4WAyx7QjjPjWYgdZXca2IzaN7WtsrXQf1t6phui12slFlK0WIUKECBEiRIgwBxFz9Bzxgd2SEVGLboteDFNxQq2QobihxmjQaianlUImpkPPU/GNkIHxfCXUKah4hxl8qXM8kzTFwwi+N2mzIXMAYPl6qP3Zaeew0UK9heerdOlTYfSt4YdV7fNOCivIoAPIaUVyQQQKor+Y26cVseGw3RoLdlFCqncnFY8nLGFiXF+hWSuGrEZSUbgivSX0UxpyGkMmK6eWmHBToZ6qSZslp6nce0iyhWqRN8Dq5BD/etm/8v4tUruqsL0RzwgyemZ11EkdLybfOzun+NGhs7kkJxk0PeYED8z2B+fIY7Za908yDun4KsRWCBP3nsW/CZmsESdHo17k3Eap71b1dG4bXkExqGxe8OJ8NS8ahYFqE92xKc5Lie6lW89zf6mfPeUak6SysyxjlFQtRp0s+8uSRVN2TRbEpzgvIzWseowJLolLdHvIqzDtJmg3pH9xxZrny6Mqfqg5yaoV1sYOzPHS0kKW5q7xpeze2kXDQmmnpafIdycuZFFCOIC3NWzh/sBXaspJMVhuJF+V8/J/e3/M8maF15wvjEX/I/Xxe1nDVmxfZ1uQrXZfYRm/l90UztEOY5q+RE1rZWP7esh6JlULy9fC+bk2PhgyXRvKffSbIzRrwh6kFIvdtjBMW8td9MXGaQvcrSu+wdmpvZT8wFfId8N5bigOfbFxxp1McA4NMlol1PuNu3W/F8vXaNZm+b3sprDdv3vDv3NPQc5xmzHDjlJ9nqd1K3zVMWGlGCunw6r3IN5HAO2JWdEJBZllT4x3MT7QhFqRbRUX9KKMQbXJY/Xa/WGGX3NsNvRKk+NxQ5bW9jUOlBoZLOTkvOTGQ+3SSKUBFR/LlWtoopomq1fC5cOJLKke2cfZzaLHGavKGE1Wkzi+GurTzmvcG2qpqt4z/9lYb+os10VbpOHxbe8iZpYKm5Z98vD11bi06/Z1UVig0rpItr1jcBkdrxF/pE5EX2T9v6Pvd+95ch/7n9sH0RSfZJDNm9Qs1iUHw0yt72w6FyXIBLx6xRZUxWNx4uhaqFMFHsefbXb0Og4Rno7o4ShChAgRIkQ4xeFRT6Y5njYiHBuih6NjQI0tApgMNBnNQdRZ9GJoikdv4F9T9E3GFYlEXVRUxQuzmSq+wc5qB9NO/d14jfHJaSVm3RgbphYBkDaqLE+P0mnkAYkWa++b99stJFWL309KfsYeJc9jFdlu2k2SUStkAp1KSrGw0UKGysANL5BWfYZxJxuyNq3aDEXfDLPXXF8N+zfppplw06HfSo0Nq+mUeowJ4kGkhiLjQGBM61LijuLKkEF5a/N9oR5kn90iWpKAvZoJWLdLWnYBMGZl2TErkfrC2AQVr5X/0fcIAL+Ir2bfkLTZ2jbNVCGJV5H+zJTjXLX4ybAGmYbHyoSM1712P0sbD7GsSaLFHZ2tTOxooRRUVx+wWlgaeFH9bPwMtoy184pFkkF1x+Ay0vE6a/fPWy+mMahePjqRpb15JqzlNVDIcXH7XlamZL9f2Hop1ar056Kzd7EqPhzuB4RFm8sIPhJ4AcXVGGckBjjLDDK1XC2s2VabFzutur9Ntz7FroDd2DPbzJanFobnRc1ZxIJacKrisznfwcZJ0Vv85+B6Xr1AGJP1yf2sT+4P2ct1Zp0NAdh5Tr2fr98zy1dHL+WBPX0ApNMVdjS3887OOwFoUme5NL1N9onH7bOruWnvNQD0ZSZ5ScOOUDtk+TqPlXsB2DSzgO62KXKBlslFIRewSO3GNL+ZWsFkVvQ/l6a2k/NLbK5I9lWTPksmYEHFpd5j2M8Fx+2FLBzUHbNBdHiur4bMYU4ts1qb5qzgPO2xM4zZcn3fsm8lzeki7Ym6/idtWGGmoKG7NKekv5anoSp+yLooCmgFNfQO8mMezavyADQmSqxsGEWv6QTx5rneQ5292VVoZaSYCT3Etk+1MRLPhOvpqkdLTPqwID6F7Wsh63R20+C8Nj1foTNgijxf6iHGzOA69/RwTB6b6jmi5qeGq7rW84MDUg/x5n1XsPAXPqltcq05tnPY+l5ZzpM+MMLsOpP2gDHNXb3zqPt4JnxjucyBP9tVZ8Gb59TP02Mu9oTcZ/J2AlXx6cjMde5u5FTEiSkfEj0cHSuikYoQIUKECBEiRJiDiDk6BmhK/U1thz7NjBcPGZOCm2BLeQEr48IOZLQyVhDlaYpPVi2HWWY7qx3EFZuUKVlIB6wmbhsTh+RlmXFGKllKgUPyRc27mXXibChINK4rLosC3UaTVmTcyfDD2V5A2IOaQ3dKrWIoDuOORLc/KyymJz5Ju17ztqlHbt3GFKrihezKuJslpxXDKDWuOKF/TsGLM+0maAoi9yZ9Fs9XSQZMx4SbDhmoUbuB5fHhulO44vL6zCbMrIzDL4uL63oUPS/sRxDRWKqGhsdiU7b91chKWoKMmW3lzrCmFMCHFv+CwR7RufSbo9xfWsotB8XX6LyWAVxf4cz4QNC/lHgFIVHxrB1j1yFx8K4cSNO1apT39N0JwAMzS0Mt0GvbHuPVrXVm4ZLVO/DmeBntrbbyXwPi2uu7CpOzSaZmZcyWt43RE5sImQbL0jmr54Ds0zfIKUWuSMh4/nC2m259KmRNdlfaQnZAC/xxKllhX5q1ImtMGZPttslPps9iNNCKNJsl7naWhVlyqxsO8lRaModU3ee1K59gVUI8r3rNcYpeLNTT3Dq4ggVBhk+XnpfzE9RoU8ngHUWx8OnF69j9rb7we7EY57FiD/+3LOzQ+qYDXN6wFRB2cmV8mLt80ZTtnmkmZ/Twimy9Dlotq+yhvb3sm2kK2axLkjvCmna2r+P4ariuHbCc905Ju46ncmVrLcvRo+TFwmOzfZ0ufQo7yFAbthvr9df0MhXfCDVbWbXCPifOkwEjtXF2IT1BFmFXwzQTpRQHRoVp8GyNzs4pKkUZ+7KjkooJm6qrHnHN4YFhOb+zhTiKDiQDJ/akHerG0oZFo16ss56KR58pzEvRizFUbSQWZK9Zlx2kiYPs/JdzAUg2lqhla9uextTBLMlVomNrNIq063WGxEMN9V2TToqDVo4a3dtiFhmrZkI9VZM++5wypWKKzN3L23fwb1d2sGK/jInWkMWvVkO2SNE01Aa5PmYuWUx/z9CRG3wemOtX9D+311myG8/8xbz1vrW8m3+m94ht1BiwGt6w4IIjrncy4KGEf0uOp43ni7/5m7/hQx/6EH/+53/OzTffDEClUuH//J//w/e+9z2q1SpXXnklX/rSl2hvrzPZAwMDvOtd7+I3v/kN6XSat771rXz6059G1+uPH3feeSfvf//72bJlCz09Pdx444380R/90fPu64lAxBxFiBAhQoQIpzhqr9WO99/zwYYNG/inf/on1q1bN+/3G264gZ/+9Kf84Ac/4K677mJ4eJjXve519T67LldffTWWZXH//ffz7//+7/zbv/0bH/3oR8N19u7dy9VXX83LXvYyHn/8cd73vvfxJ3/yJ9x6663Pb6BOEBTfP31coYaGhvjgBz/ILbfcQqlUYunSpXz961/nnHPOAcD3fT72sY/xta99jXw+z8UXX8yXv/xl+vv7j3kftQrIl3EtH9m7Nfy9li3iorDHaguZGg2PJn029F+ZdNNhhNWsFXBRGbYlspx00hiKG7ItMJ+VAsKMmv/YezYXde7lsXGJWEd2N5PsEm3DjWtu4dz4IHagHVik6wy7wrQ8WBZ9SZted3HeZ7Uy6UqEPe0kuTi9A4CXxKfYbuskAy3B45UFTLvJUI+RU0th/1xfnZcFVwhqrtUw7SbDLL3txXZ6ElO0B3XiuoypkE0DeHlyIPTbcH3Y72RChmrcydCqF3iiJMfxrW3nYk0GjuOugtlWxrWlLUX1+JfzvhH0tYyLwi0FuXgfyS/ifd23kVQlcvd8hS1V0dY8MtvLExPdtASszc5DLazvHOLinOicppxUeBNpN6b5yegZnN+0D4DhagM5o8xQOQfA/tlGlgXuznfuWcrb19zPrCP9jakOC8xJfjS6HoAnNy/CyEvfm88a48L2vfxqv9ScKo6luPacx9gzK2xWe6IQegw1GTK3YoGb9qrEEI8ErOFENc1D2/uIZ2VOvWX5wyyLHwz9s/5y+xsYn5I55TkKvqeiBBlUquHhH0yg98g4/MGyx1iXFKatQ5smrjr0B/qkrJrgyq4zOFaM/WQFX177bTltc27IHipDTmPoeTVQbabTnOacIOvxo3uuDfUz57QMUnKNkCV5SWY7v5leBcDP7zkbX/U58yzZrjMxzUOji5gYlPOCo3DD5b8E4OHpPkzVYUE8D4iDe1KtssQUf6pxN8ueqmTBqYpHXLHpDZiamu/PfUXxd7rt4AqaAiZzx3grzr402d3S3+w+m/1v9DHTMuesyTitC4Rl6m2YYnV2OPTaKToxnpzsDI/V8xUu6wxqk6ni+9UXGw/GT+GALV5KDVqZH61secaxz/9c7nfTxQRWyaChSc7vO5beR1K1OGjLGLXohTBjr8YQ1Ry8p90kD84s4dqmx2SMnCz/PXZmuI/SS+tauWfCBU84nJPay+JAk/na772f/i8dgBpr4HqgyhjsensXdneV/j969JjaPhn4zL6Hws8aPn/RW2eOfnDgQWYKHotWDL+gVe5rf5M+98hFJNLH97KnPOtwwzn3P6f+zs7OctZZZ/GlL32JT3ziE5x55pncfPPNTE9P09rayne+8x1e//rXA7Bt2zZWrlzJAw88wAUXXMAtt9zCNddcw/DwcMgmfeUrX+GDH/wg4+PjmKbJBz/4QX7+85+zeXNd23v99deTz+f55S9/eVzHezw4bZijqakpLr74YgzD4JZbbuGpp57i7/7u72hsrIvnPvvZz/L5z3+er3zlKzz00EOkUimuvPJKKpXKi9jzCBEiRIgQ4fhQM4E83n/PFe95z3u4+uqrueKKK+b9/uijj2Lb9rzfV6xYwcKFC3nggQcAeOCBB1i7du2812xXXnklMzMzbNmyJVzn6W1feeWVYRsvFk4bzdFnPvMZenp6+PrXvx7+1tdX1zn4vs/NN9/MjTfeyLXXXgvAN77xDdrb2/nxj3/M9ddff9L7HCFChAgRIpwIeIHz/PG2AcJGzUUsFiMWix22/ve+9z0ee+wxNmzYcNiykZERTNMkl8vN+729vZ2RkZFwnbkPRrXltWXPtM7MzAzlcplEYv5bipOF0+bh6Cc/+QlXXnklb3jDG7jrrrvo7u7m3e9+N+94xzsAeW85MjIy7wm0oaGB888/nwceeOC4Ho5qxQlBiom6vsps8ArJUFxKVowvHbwMgJZ4ifd23Q7IK7gxO8u2spg+ur5Cb/xQPa0+EEOCpDCn1GqY5p8fT/Pof5zF6EVCc//9ld+mP6D6n6p2cldpCZcmxWxQRWWBJhP72tQwmqLgBm9LbTx69Gk+fuBVAOyfaSTfIpOtueU+zjBdSsG6C41JflhYQlNWaPiSHyOOFYyBCCprQvS4auP6SijCzmhlugx5hbAyMURKrYZjNmg3z0vX320nQzGs7WtB8VYRaCaNKh4Ki2JCw//hig3sLMorj/2zjRycbMCdlr74hsefPinn9Ytrv4OpuLw0JaLlS1I7UPGoBKJmGy18VfI3e6/EHk4ypAdvlDWf+wdXcJ8mAs7WvknaUvK6YctTC8FV2Gr3AuClXLBUVDsoW6L7DPpSlNZvsCm5MVYnRVSq4VH0YlzaIq8xN2e6sGJyPhdlpxgoNVEcFmuIhp5pBkpNPLlHyoc8OaujNsmrskTSolwy8YLXib51DlpSxvbaVZu4/qwNbJkW0fWaxAH+7eDFPDkk3//qzFv5z8RZAGx/bBGqB73rRRT+kxX/yfr7/oR4IH6/MF1Pnb5p8XqeCz66Z+O87+/dvCIsnNutT4W/a3j0GuPhb8tjB9GUeoHlS9t2hfYV/bERRpwcuypy4zQUl1ZTUrITvTPMHkqyJC3zJKFa+D9pYeWtMvb58zv55afkFdyBN/ZRWF/l0uVyfDtm2+lLHQqTArr1PMnAnqHiG5hzkhY8FOKKw3UN8qqnLzYevlq2vDMYUHymmuVeMLPYAMWiNStzZ6hoUqzKXDU1h9KcUjIJzWJZbjw0ObU8Pbwf2L5G1dHZ5PbU+xH8UZMixs9s5VdLgf9UYEGS0+pJDPsCo06Q5I2aeW0lMMaseU3eNbUcy9PDQsim4rCuoS6WfvAY/3Q8eIbOg/Rz8SaxGvmDK+/l2y0X8N4L5B55z0Q/+36wBIAF5x/g3OYBNh61tZOPD/aeP+/7J/Y+wnLjcDuC0w09PT3zvn/sYx/jr//6r+f9Njg4yJ//+Z9z2223EY/H+V3DafNwtGfPHr785S/z/ve/nw9/+MNs2LCBP/uzP8M0Td761reGT6FHegKtLTsSqtUq1WpdA/T0J+oIESJEiBDhxYZ3Amqr1YKQwcHBeZqjI7FGjz76KGNjY5x11lnhb67rcvfdd/OFL3yBW2+9FcuyyOfz89ij0dFROjokYOzo6ODhhx+e1+7o6Gi4rPZ/7be562Sz2ReNNYLT6OHI8zzOOeccPvWpTwGwfv16Nm/ezFe+8hXe+ta3Pu92P/3pT/Pxj3/8yMsWi7j3TdsOhgZo3foU7pwU2JRaJaOV+evF+wDCEhkgQtSUWqUnJin4d08uo+DEaTKEmVkSHwuj4pdnttBrTLPYEJFofm2CCy/ezbUpSUFVUahJxOLxIQadDHlPItF2tc5AzfoOjUoMlFrBWhhysvx+i6RDFxrjXJ7aHvRVo+J7GDVTSK3I8uTBkMXp1vM0BcdtKgoV32ciiDTH3TQFNxGyQwDnxoWRMBTQnpYyOuGmGQyi1l7jUChwNxSLXqNIwZM+FDyTEbeBroBZyKhllsfFcK7SZHBfQz93+CI4tWdiFIsS0dw8/EouadzFRUmJmlcaFrsc+N6URH4eKqVA4AygeArUAkBHQWmp0tEsD8aq4rN5h0RWelHFTXgsWidWDTPVOBN7G8MyJb7ho1SDG1ZJ53vbzuaafhmj2weXMTPQQGe/MFZNzbPk4jK2o6U0A2NNKBkZvzPbhslbCQjKGqiNVbzABLI4myLbUaBUlvPtTid498V3AdBl5Pn6soWABAB//m/Xk8hU+fp5/wbAI+XF5EzZ5z9d+zUG7eZQnP/5qdX84Yo6Xf65JSs5Ebhp8Xra2Eb33qmjrrPPFlFxUq0y7SbD6+ml6W0hs5pSLJYYYywJrgnL1+gKbDD+YMljXHrGtrDsyCf3Xk3yuoNsvVDaXb5okIIlov7u2w6xp7mFBWfItj8bWM3DexYRPyMoyJouhCxSiuo881MbjR69EO7ngvg+djsijn53z5309k2wKRD635FfyUNDi8jGROM4lrCp7JM/QA/uzuLGffyAOVRiLmf0HaA7mQegw5wJ7zEgrHPNcHXMyvDEhOzDdjUaeG7miPkgeaJmYFsz0sy7qVCcnVQt4qpNT1C4+k/a76bom2EJoCatxCsz9dofD/LcmMX71sncvWV4Ix+/ahOv2nF1uKzrun0ArG0YZuNza/YFx/cOPBDeHzVFoeQ7IdNu+T7qSZTter4aCuePpw2AbDb7rILsl7/85Tz55Px6L29729tYsWIFH/zgB+np6cEwDG6//Xauu+46ALZv387AwAAXXnghABdeeCGf/OQnGRsbo61N3gDcdtttZLNZVq1aFa7zi1/Mt1e47bbbwjZeLJw2guzOzs5wMGtYuXIlAwNBdk3wFHqkJ9DasiPhQx/6ENPT0+G/wcHBo64bIUKECBEi/C4gk8mwZs2aef9SqRTNzc2sWbOGhoYG3v72t/P+97+f3/zmNzz66KO87W1v48ILL+SCCySr75WvfCWrVq3iLW95C0888QS33norN954I+95z3tCtup//+//zZ49e/jABz7Atm3b+NKXvsT3v/99brjhhhfz8E8f5ujiiy9m+/bt837bsWMHixbJu+y+vj46Ojq4/fbbOfPMMwF5RfbQQw/xrne966jtHk2INhcH7RwXpurRWk4t1Q0O1SoGdeYmqViHldx4ZLoXgKdG2zF0lz9b/htAjAt7TInUTMWl4Ol06KLLeXvrPaQUm1osqaKEEYznwyOlxWFa8PWNddry8cpCuo0p+oM0+qSisdacZq1ZN3+LKxKZu3iUfJfHqsJefWPkIh7duIT3Xv4rANaa45iKRMxFHwqeQcmra49qxwlwcWLPvCdtQ1EoeHUbAA0vZKQG7KYwUs+oFSZdnW2WPMDWCqouN0Xr0BubphToMvJegt6WQ7w8J8Uot1a6+MFuCTUvadxFkz4bliX5+kw3B60cP/yNRB9GQaGmZbQbPJTWClcuF6uGDWMLMTU3LBLanZrhnLPlofuhsV7WNB+k6sqlksmN0tHzZGimdqDSyERVmJj2+Ay3blvFjx4Qawm1weLc9bt4ZK8wGLGEzat6RAfyzS3n4U2ZNPcJm3F+wx6+uf98tDEZX6Nvlv+1/s7gPClM2akwpf3PLtnIU7aM/VPVbv5kxz72W8KYmIeG2fZwL99fJIzZSxu2kWmScf/skjW8UDiSRuljfWcfcd1P7dsQMoMFL06PMTGv4LGFdsTt4qrDGXEJXvpNCYJq7K7KIAmgHzE8vHhTla5Pi07o89tfRvJXcOf/vRiA6WscUHyWBCVBKr4RanpqxUpr17fnKww6mfC7obi0avVyIRVfD0sHvaPtLg5VrmZwJgeAnY+RPCTtKg4obp39BZ0nJxezpVOu97XdB3l5s8zHmhkkgVbotoMrsIPisZrqUb2tNxyT2Cv2HXGsoH6+37lzT9Cux6jdMG+dmr5LUzw69HyoBUwpFknVwg6YhiGnMbxmDVyu3DLDraufe+r6VV21eTJ82LJTSWtUgzHnrub6PgYqBV+uw912jt2lDEc6lhcCLkrIYB5PGycSn/vc51BVleuuu26eCWQNmqbxs5/9jHe9611ceOGFpFIp3vrWt3LTTTeF6/T19fHzn/+cG264gX/4h39gwYIF/PM//zNXXnnlCe3rc8Vp83B0ww03cNFFF/GpT32KN77xjTz88MN89atf5atf/SoAiqLwvve9j0984hP09/fT19fHRz7yEbq6unjNa17z4nY+QoQIESJEOA6cyNdqzxd33nnnvO/xeJwvfvGLfPGLXzzqNosWLTrstdnTcdlll7Fx46n1eHzaPByde+65/OhHP+JDH/oQN910E319fdx88828+c1vDtf5wAc+QLFY5J3vfCf5fJ5LLrmEX/7yl8ettD8nuSfUQdxbXMqtB1cyNCy6gz86+37OS+0OyxoAYfQ1aDfxhd+8gtiEfP/8H36NocDMDZhf5BUFQ/FIBQ/2rboLqEx6EqWoQC4wSxtzkzTpsywICpFOuklGHIkIt5W7sH2dbVXJkHtVehuuD3YQMRj4eAHTVfF98p4RlhRpjRVILSjwhQ0vA+D3X7aZPY7oFB4r97Kr1EZal8ja9lSKbiw0KpwLTfHIaSWaVImw52auARS8BPlA91LwEky6ac6MSSZMUvVxfdCCccgoehhst/qzWL5Pjy4ZSy9JDLF6jeic/nXoEnTFY/eE6Jq8xxuoLq3gN8p+LV1HrQYZZg0O7c2FUMdhBIyRE0Tn+2ca2T4pBW1VxWfLZAdpU6Lm/tQYLUaBxwrCWG461MXY/uCcJhwyuTIzFWlH1T0OVZIs6hB2cFFmKtTW6IaLm3GYGJCMrh9d3UKa3aTZHY7TL5gf5b9iszAJc0sY3DK8kf83uSw0nry6/Um2dnWwKzCTPCcT4z9WHP218ouBD/eeG2a3xTX7MCNUU6kXxoV6ppbnK9zYd84x7eOedTFAjvs9W+8it7LEzybExPL12QH+4Z5XcONdopP48sv/nVTAGNX6cldRzDm/uvEl/J+zb6MhyLTUFD/U7AzbjeTn6KV6zUNc1baZ2SB7rbAwzn93rJXP+xpQHAUv0ByhAY6CNy2s9a54Cy9tCjIrPQ1V8UJdXjZWCa+7JelxLkzv4tM7rwLAumUpmat2PeNY1MazQ5tmoT4ZFi0uerGwbEpWrVDxjfA+MqF4mIobmreaijunHJDFS5I7uJVjOxenM56e+XvI9RgL7l0l/5nfOJxouBw/8+M++yoRApw2D0cA11xzDddcc81RlyuKwk033TSPsosQIUKECBEiRHguOK0ejl4s/O2S1eFn7/Ye3tSzgcoCYUyqnsG4k+UpR1iIM+IDYbkEQ3HRCxofe9P3ACnkWiv2CXXPIJAoTsMnowgr4uJgoNCi1pmZW0qiDdpU6mFhbCIsTOmihJliPcZEkCUnkeawE0dVfPZYwoS06jN1zyYviYYXlj5ZmhzjsVgPq5aKFmPcTXH3rETQ39x8Pr4PRkxYJgVIJapULOnDptEuzMD/I2HYNMdLoS+Kobh4KMSCbJwFxmRYDqFRL9Jh5udERD7Tnh7qTgzNwlBkPCu+T1xRMJR69HRuTN73/yw+y13b+1Hy0h+/10JVfRQtiJVsA6dR+tfYPMtMOUbclO+2o+F6Cm6QMdeULpEyrfo59xXMICNww9QiVMUna1SC/rn8+UtFo3VWYh8f3vlajE5Ztz1dYNdoKwuaRV+jKl5YzuRb5/xrqOcA+BhH1ufMxW1r0uHnW4efkP5UXdbED/BoSQxRx+wsHzz7VvGsQQq9/mxIMtmu6X72fbwY0PDD819jS04kfriyjY/u2ch7O8Rbp+ibfOkV/x5eh66vMjcgd32VMxKiOVM1n5s3Xc5H1strgZJrhKVPCl6cWSdOp5kHxCuo3xwJfYUm3STfKQWljUyfVWfsJ6nLNTBjxxgv1s/nOW2DZILtil5s3uuPS5p3syYh13feTfJIsY940M43V3yb+AGV78xIpuHPVtUrBoDou2rwfAXL18LSR5NuOiyoHPdtDMWZl8mW92L1wtJOGjegc+O6jYbPx/eKputo2rLfNnj4WKghu5hTS4yfxD+hp8Jrtd8lRA9HESJEiBAhwimO4ykcO7eNCMeG6OHoeeCh6cWszQgr8s3t51GZSKBNC9PhxXxefckjAKS1Kq+/6r5QrzTmZni8uIhts6KFuLplE61BgdhlxhitmksthI0pKnFFC300bN/liqT4/XTpU5iKGxZSHXeyYcR9y8w6XpZ5ittnhO26Y3QZF7TsY3dRmKMZK8Yr2sRFOqbaGHO0BF/YcDnKtM5oKgfAr9Jr+PYT58lBVzR8zQ9dmnEVKoUYih4UMdU9ZguitfAtjeGYw9aYMF2q4qMoPg1JYTN0zaUnnQegOzFNSq3SoRWC4/RYoPvsCTyInrIzoR4krii06PUQv4rLU4F3kucrKIqP3iHRt6L4eJ6CPyCO4yigJ6XRmR2NaAtKZBPVcF1N8cNsNU31woKgtWXTVjw8FhWfZKABOaN5KIz4fzWzhmysws3L/wOAPVYryQVVunU51t12Kz85JNk6/z28DuMV+3nvLsmCfO+unXxh6bEXSK5hpeEy5sLCIOtRUzwpEhzMuUviFWpzqu9hGYu955We836OB5/Y+8hhvz1dTzSXMarpij6x95Fj1hg9G25avJ4b9wjbVvASzLhxugNH9wk3TckRFqlDnybvJZkJHPD/5tz/5BeT68I/Kj3mRDgf7y0uw0Vle0ncyKdjSdYkbAq2bLur2sFFvZI9t7fQRNE2yVdF7+N6KqbmkjCkrSazSFOQBTdsNdKkz9KkC4tTcOMhS3zAauLe8cUsykjfbysuIaOVuSwpmbwrdmfCjLsOvUTeM0OX+JJvMuMlyAaZgQU3wWSgKXRRWBUfxg3OR41BqmmSdnsGI04uWFelW58Kz9nH9z6Khn/CztWphIeq8TCTskPz6dIUts+RyNXGKcJvH6KHowgRIkSIEOEUh48SWogcTxsRjg2K7/sn/iX/aYyZmRkaGhpY9KlP0v//HTm18EN7NoUePxtLvdw6spLWhEQQ+6YbWd8qrNLC+CQPTPbRE7jgvqJxMwv1ST47JJkmS1LjXJeTqHq33cZliUGSgQeRioKmKNj+4XWUflrs5m+3v4KZvDABjU1FkoFGZmi0Ed9VUCcDN+Wsg5mxcAK35camIn+8+H4AFpmH2F7t5MdDksUzls9w9dIt4X4enehhYFiYGXXCxGu060yR5qOo9b6pqo9dlWdtdTSG4ij4NbdnR0G1odoa6H+SLm1t4rs0XYpzVtcB/rj9HkCyZnr0Km4QlT5pNdOtyboNqsNOO8cjZdHXtOszIfO22hyn4quMBC7A73jwrbhTJvqMHLeTc1GCemj4sHjNUKgxGhhtIpawaUoLo6IofsgcaapHQrepOnJsyxrGWRCf4kBFtB1Zo8LlWRmzS+MFnrIVfjIt7NCaxAEWm+OYYXagHmb/7LNbmHTTHLIzAKxLDhBXbD6/dPlh5/tIqGmOPDwerboMBVH9uJOl4MVZbI6F6365fykAF2+ySGsVWoNsv28t7z6mfT1fvGunZFFpik+rJufp6Zqi0NMnwId7z31B+wTw2q2HKHlmyIr0x0ZCZshGY5/Vyp6KuPmmtQqrEwfo0Oo+YSOuZHR5vorlazwyK/MxpjoMVXLMBCyj5WnogT4lrjuo+GEtNcdTmSinGJ+S8+85CisWijYsZ5YxVRdnziuQBkPYi3PS+7hnup+umPSn08zTqhdYHNQNbFar2MHcVRUYdDJh/UPL15h2k6HWyvNVCgFDltSERa3VjDwvtZtKoKcEuH96KQsTkh3bYhRo1Qthfby8l6RJnQ21OLav84nFZzzHs3Jq4D8PPDTv+3ZHDdlNVfGJKw6FOV5vb/nR/2Tw/R9henr6WR2nny9qf5P+8v6riaUPzw5+LqjO2vy/i37+gvb3twXRC8gIESJEiBAhQoQ5iF6rHQVvvOx+0puCSuHpbWEtqCZtFtvX5mWkXdS6N4wums0ifUmJ4kpujHMaB8LMofsL/TyuWvSnJaq/Ovs4j1Z6Afj56Fr+Uz+bV7c+DsBjs4u4KFP3LzEUJ9SuXJAY4LW9m0Kfo0/c9yqmp+RU+i02qu7ia0FE7oO/N0UiqKerX1LgnqllABQa4iw2x7moVXQRtEq9tx+PngnAwEArBO24aVcYFTfwClJ9UgkrZFhSMQsrGThZKz7+WDz0FXJSHrFJlfhoEDUnVfIDooHSy3B/findCYmE/6DxIfKewoQrrFjeTYVjvcI8RE4rM+3Isl+PrqBoSRSsay6f7f8hvQGTtKJrhC2VbtTJgImrqGgl6Y85DeO9aTJBJfZEyqKrYZqzm8R9uerpPDohtdVe3bWJ12c2sd0Wpmi5McWwm2BnTHRj3xk+j3NT4kC8x8mzytCws8Lq7LNbybuJMKKOK3ZY+BFgT7mV/oRkBpqKe5jfzzPBCyqzP1z1MOawLy4qrXohrKM1FzVHaO9pMdHcjKYanguD83S9VE1jVGPJSr5ZF4IGx1jLcDqRuqLnAs+v10fU8NGCz3k3ie1rpINr9kClkU4jH1anB2jTahmlCnusttAna3uhnX35RmrJlKrikzBEz9cbk2u1plVbEJ/Czan8qCgO38ajGQ483gvAsANL37iTCxvF82qo2hi6o0+7SXJGmQlbMuZmnASLG8fmONerYT20ghtjhVEgqQgjmvcc9jsZir6sO2g106TLcVU8g4pvhPcUEMbvkCPMVmd8Oqz9puExHNRkA3B9haRSRePY5++pCi9gNrfbcj/90ujlzAQaMl3xeFfXHeG6BS/BWWv2crIKTnm+Ev6dOZ42IhwbooejCBEiRIgQ4RSHi4p7nC97jnf73yVED0dHQbs5zcqUvFO3fC3MFvmv/NnsKzSRDRyTz84NsDpxgCdLwjSoiseOomRpOZ5GyTXpS0kmkdQq0liRkKyzHr1Ihy5ZJq9Zsh3L9xkOKmhf0LKPe8pL+MFBibCnKwlKgafQm5Y8gu1p/NuA1A0zhw3c+BymyFfwM4Gz9qyOF/MpLZTIuHwow6HtwoKNrU3h+6tQAuZhaCrHGZ3DPLWrrkXRdNlOOWSglfVwP15HleZUkbjuhOsOTQdajKkYZlHBM2Vdvaji6ZAYD9qsKJS6JMq0ehzUGZ39RfE90ho9Cp7JoCNap4IbZ0dFWJpJN02XPsVV2U0A9MXG+cW4OBAPF7L85Y43cF7rfgD+vu+H/LJtFd/eJ9l2Y6MN+M2BXmq5zZqWMVZnxCNJUzwa9WKYvdSl53l/q1S9H3cNht0Euy05p0nFIqVaYfXyLy/5D4wgGGtSTSY9ixFH+rul1M3bmwYoBNlCQ24DheD8AlyTe5xeQxizfU+reXWsWGXYjLpu6DgOwlAdSU/0jeU9z6ntIzFKR4o8x9wMf7Zr+zwXdKg7M5tK+ajs0IvBGv1oZQt/sG0kPIeWr4V9bdZmqXhGeCy2p/GL8bW8rl2+F71YOE+SSpUGrYQaMCb78o3M7mgkviSoa2haFCrCbG61Zf5ULJkLT5qdrGwe5aIeYW3ve2odcekOyTGP4dksBJZFeTvBjC3zZr/ahOermAGTpKuuzKkgibRVtcjPmWPjrsYyQ/bZqRmMexa7Az2Vpnhh3zXFw8ANPZDyboq8m6QxyJhr0EohcwRgu3qoVwIYtJvDzK2cdnKzIU8kDEUNM4QBckaJa5sfA6BVK2Aqbqg3LXoxepJTL0o/I7zwiB6OIkSIECFChFMc0Wu1k4vo4ego8HwljPItXwv1Ca9p3sjm5AI2zSwI1x11GlgYk7DPjalhBtK4lebx0W4e2doLwCvOeIppK8H3Nwkb9N99B9g/LeHh7/Vs5Y25h8M2i75OlzHF77VJBfovb3kJ1oT056v7X46ftaEop89UhI0BMHeZKB4EEgQSo2CnodwW1Ega1Kk2CaOzf5OwC2qXRHqG4bJh1yL0vLTrGT5eNdBWVRUS41Bplv1UXYWB8SZcS9qNpSycICr2Yx5uQkGpmVPnXIwpjYBAof3hKgOvlIi6dfkUV5y1nfaAQcl7CWxf48yYOALvtpvZWxV90v5qCxXPCLU53z1wLlVXGr20azeDpUZ641Ih/b7yYh6bWUSxKgPx3vPuoF2XfTwy28euQiuzrvTh6oYn2Gm10xVoun5VWMPdhyTDK6nbTFSSdCZFZ7K2UxQGmcA5eLedCyPJZm2Wip8NtWG57Ba2BM7kACUvNo/WHnez5D3RT2XV8nOivG8pyXabyito0EpMBxqtoWqOnedUj7kdOP4MsQ59hoIXC3VFp4PfzX+s6OAvdk+E32v6KA8FD5V/+OZrAGi//AAdyQLjgfZmxMqFjJOpuLRpBS7LbgXg+5NnE59RmD0k58JtVEkFXlq5eJl9oy24VuD2bnhspZ3OtLBMyy/dw77/XgxAuUklv6eFqQ5hAw8Uc5Rsmcea6tGaKNKoS7uerzJsN3JJkK1m4oYO3Z4vVdwPeaKfsn0Yd5vD+Wr7GvsDLWW7MY3t66F26aCVo0EvhY7utf9BdE+G4oTu2Zri4/oKlUDLlFLyz/V0nDLQaxRcoD26tvGxMMPSQ8XFY8yVuRBXLM5K7jtpfROe7zgdsqPXaseM6OEoQoQIESJEOMXh+kpo0nk8bUQ4NkQPR0fBP955JWq7RBE3nPtrVgQ1vAzF5bzkbi5MibPxU5VuVMUPl7u+ihmv+9q8tGFHGHUOVRu5tukxLgqyUH49voLGhLA2W6Y7KWTjYSbJ9koXd0/2UwmYkXSySj5wp3aLBuq0gTFTywAirA1lNfq4CY/YeJAZFgdPF+duADujYMzKym5MMrfcQqBXWTODmbKxggtIHzFJHwh2EbBAQRkpqk0GWtLGDSJueyCN3xowFqoPPtjNoouIZatYcROrTdq1GmJo/cLEvHnhw6iKH/oVPVXp5pCT4TeBxstQXH66dw0Ay1rG8fyFjBZlPC1XozUl2TZprULGqISZbB3xaVJ6lYWNognYVuxkR1ClfdNEFz2ZPLcPLwv30aCX+c6kVLu/KLMTt1nG9tejy8mXEqhB9Jj3kpR8M3QhrvhGGIm7vkqrVmQ80P88VFpCRq2wyBQ2a9zJhPX0FpgT7Kh0siwu+jPL1xl3stywW1iIzy2RWllHwof2bApZmqWxUbZWuph2hFV8rqzRM+HpjNKn9m0IfYlOhh/RC41azcQP7N5MwRP9TEqt0qrP8N63/ASAn46u46GHl/NQay8Ay7tH6TZlTi0yx9EUP9Qjru0bYufexWH7lYMpKmlhJyfIEstU8YPz73sKuuoxWZH52pIoUlgbuGU/aKKV1DAjrVCNh7rApOaQr8ZDzVHJMVkQn+Kpahcgc/DcxD4AMqpL1VcoBH5eE26CCScdskO1awWE1axtD6JByqiVkB2aixZ9Bk3xMRTpw7DdyJbZbi7LifO+qvihXu10mydHqj9YuyYBUkjWMcC56b3cV+gFjuyHF+H0RvRwFCFChAgRIpziiDRHJxfRw9FRoDRYvGq1+Ax9cculvKFfooPX5B5jxMmSUgLNSaWNpGqFzJGmeGGF8bji0KrN0KOLRmFtfBANnzVx0a1MNqa4KvDE+dbERfxmdiUvTUv0dchO8+RQJ3ZBojw17uJVhKVRbAU/6+CVZZnXUw77bW5P0LBTww2MVMsdwvqkBgIH4CykpKtUmoNt8vJ/dUsWL+aj1DLSTJ9ya3AshwAFtEB6oJUVnKFU+AbbS7kQeCApmo/bbId+L56noMzqkJZI0181y9ldQkm5qJRcI6wFFldsVHz6YqKhuDu/jGxCNBMjxQyWq7GsUZZ1xGeYtCS6btDKtGVmQoffCTfNhZld9AYpQJ3GFHfkhY1JGBaq4vO6hTL25yV381S1m31FGZD/euTs0Fnba6vS2FSkEPgp7bda+M/h9axrlEF8feMGdlrCSJmKS1x1wui7y8jToedDLdG0mwy1VeH5Cii5uGLTbUwes+6o5hJ+RmKAJbFRvrHuuWWiPR+cbizAseKzS9Zw2ZNyDa1LiFO5GbAilzTv5i2//2DIDmW0MsOB55Wm+Kh4oV7pitatbFnWiTIdCP40H208YBWzLtZMKtQGKq7CxEgM35BrzVjtsrpPnPW3J9pIxu0wg3NiJsXS9kBTpLqois+hisz7nXs7aV9bCPVzZdekw8gD0KtPYSg+j1eEVRq2GzloNYT6SVXx57haazRoJRqCTLOCF2fj7ELuHlwCwOfO+H6YybbfamGReSjcdm18kDPjAyGTVPH0UNvy0T0buWnx+ud7ak45FH2Ty7OiAzUVh4xeOWn79n0V7zgLx/pR4dljRjRSESJEiBAhQoQIcxAxR0fBm9c+zL1TonWxikboUBtXnHlOxr/f8ESYcVRDrXaR7WuMO9lw/QathO3rxAO9yjXZx9lSlYyxRr3EHaPLuGdcIrWD01k8VyXZJBFteSaOYgb7VZEoU8gDmmIltk2Kd8lkJk5RVULPFHxQLQhKJ2GMgGpLtJoYVbDTYM7Id19TUBwFJWC+FA+ebnpr1ex4VFAcQq2TmrLxXHnWVmZ0/KyNGtRh81xV6poVZLrZhkfeEo3M39//SuK5Cus6RHuTNirkjDlMmOowPCgRdGLQoLLYYnnPZgA6jTxP+RIV7ym3sjI1HLJ2U06K+2aXhjWpXBRWp4XtWZkaIabaYQT9rfGLGKuk2fHwIhkjV8HJ1FLtNKYLCdyADfjb8Svp7R6n0ZAIe9hpDPUqveo4P5leH7oMr4gdpFUrsiVglhq0evbP3mobtq/xRGkhIK7cZ6f2zvOSORo+vXgdF2+Sdh4uLuG+deazbhPhmXHnWpmPd7KcK7fMhHXX1iUGSKnVsMaYqbihVmeQJlr1Qqgjs32NsxcN8sheOafqSAzNCvR9rkJiREUPprbigZ1WcGOyvGIb2K4wUIm4jaZ5VIJ6fpf07iahybzYXWhhdDbDzA5hrzo3+Dx23xlMXSH9ffnS7dwxI1qq3tg4cdXmyaJk1jYaJRr0cqhPsz2NRl3mcck1g/uT9KHHmGR540FemZNrzUUlG4zJ2vgBDMUJtXY1TASu7LavhV5Hln98tcBOBdT0f+/cuYesWg6vUdvXcHztmTY9oXBRwvvb8bQR4dgQPRxFiBAhQoQIpzg8//g1Q15UZv6YET0cHQV3jy3FTwgTcu7S/axJiE7onlI/GbVMNYiIGrQSJS8W1hVKzcnueLTYx55SC05QifvMhkGWxQ+GupK8l+BgUKNo22wHB0Yb8QLfIMoa8fYSpiGMVVnxSWYkcqtWTMZLaZbkJAuq5JpMTkvU5mvyr0ZuZcQwGs2qXxVOEK3WNEReYPFszkgGW61wumZD0HV8LVg/iHyNaQU3DrHAINYuJnBSsqFaVfBLMQKyDTfmo7gKTouwHaris+eQ6HsUw6M6E+OxPZIBkjyo4CTBWSduu2d2D6GnpCGrSUPN6/z745JV9oa1j5EN3vmPW2lsX2PMkgi/4AibU7uZaPhzdE0OW2a7KTjC8I2UMgxN5nDbAk+XbIX2lBzoVDFBcSKJOSmXipvwOZjOcpu3AoCx5gyrksPh2C4wJ8PMu6JvMmPHw7mxODbGA7NynLcNr8DzFd60SOqQLY1P46I+Y5baXERs0QuHW1dn+Yvdcr2r+Iw72ZAt2FhaxHd/dBkAC18ywJu6NoTX/AGriRk7hqIGF9CCMvaYzEPFUbBych0A6CXJFA2mKYX7W1n4crlYNdVjcjbJFMJQ2Z7GkqxQwWnDYuDBJtr2yJwyp12yO8ukhoUNuuOP+rlw0b5gO5WEZoesE0g2Wpsp87PqGajBjSKjVWjQSqFWKKlW5zFAMhaybsmfP/dqPkA1ZmkuDMXmQ3s28enF655xzE8HlLwYBTdBJrgJVjyDOw70P8tWEU5XRA9HESJEiBAhwikO7wQIso93+98lRA9HR8HL2nfQICQEi82x0P215JloeGFEZfs6uyrtjFvC3CxNjtEU1BiyfY2SY7JjXFySHx/q5veWbOWaRsl8G3OyDFZEO7BrspnlC0Y5kM8BUK4YtDUUmK0KuxFPW7y0R/yRNk914rgaLabsZ9Y1cW2Z9JlBBcUnZG20qo9R9IhNB55DeyfwUxKuTq5vxEko1F6bqxYYRZ9YXiJEY9al2Blk25gKigeBXAHVAbUANYmMXgRPl6jY14RRCgJU3JhsWwnqTFU7HYzHpSGn3cdNeqiObKu60LDXZ8qQbJwNE0vIdktDyuIy05Mp1Ek5F78eWk5fTvQ9XfFpdpXaiWlynPtnGxmZyYbM0eZUJxOBn1NzpsjQaCNmQjrvuSqK4qMactzlwQwVNzj5PsRnlfA43QRUR5OMBfqq7XobO2fk/G5I9nFWdj+DtrBiccUOWSSACSfNPWOBpuxAI/98+de5syBMUUYr06rP95R5107JlqyxFsfKKkU4ftR0g7WxHwoy1L6z7ZwwY3PfeDM7mjrCzMomfZZdI614jsyNs5cM8GhV9Ef6wRhmQRgjACeF1EEM/la5cXACP6KybRA3nbAOGzFwghUnKwnK/VWM86ShQ2WTxIPZUEniTKk8YkjmYkeDzL0FKcmQbI8XSKgW1SDzTlW8kGlt0MssMCc4YMnczajCjhi4h41NXHFE/xL0yaWedQl1hqmGI7VxOqJWr/D1W8cA2Fbu5NLuXTx1kvYv7u3H+Vot0hwdM6KHowgRIkSIEOEUR+SQfXIRPRwdBaviw6QDbY6Hytf2XwLAX/bdyp5qG/cXpPZW0Y1xacM2fjP6UgCenOzCcoSKOaN1mKxRYWmLaINUxWdN6kCoOSp5MdakxNvkcWMB2wY7aGwUNijbWGFsOkNjWiLEIia/2i7MQSpdJWHa7JmVKG9pZpz+nlEAdk/2kN6nENiekBj3yGyfQpmWdvF9qoulnlK5WUF1hfUB0Ks+yRGb+E5pC03Dykqmla9Jdk1g2oteEn1STdvkpMDJyJfYIZXUQT/UNqkKFHqFIQLAVSgtkM/6jIriqRiFYOB9mO5TQi0TaHh7JGovt/voHsQmpd3JeAPpmLAtj2ztRamq+Gage4o7+GUdam7lZTOsazVUNPEqOrVqUb6joszoqEFmUWpIIShVhhLqpuR/targqwp2JchQ8jTOaxkAoD8+wrSb5ImCZAd1x/P0ZsfZbUlF9lvHV4e14FLNJQpenAvSATuk2JT8WO2gedO2ujbN9dV5GZIRTj5qejXfr19bnquydaYDJyPLZh0TfziB2i7am4HpHM2tMrErW2J4Zr3mYbnTQ59VcQPnejfus/egXJe+p5DMVOnOCeOTNqzQT2dlrhx6bAE8MdlN3kqhVwKdk6OQ+4Gw2ByKM3yJiXmpXAM5o4yuuMQRNmwiqAEJsDI+TMmLhe7Zw3Yji8xD2EGtsbnsj6E4GEAFYaB+G/REzwU/XCmZwfmfL8YvnzyfowgnF9HDUYQIESJEiHCKI9IcnVxED0dHwaSbYntJIv5vbDofb0Yiqp/lzqTZKPLLvcLiVGdN1FU+Pek8ALvzLYwfEKbjtoM5jLRFR5O8++9vEG3CN0cvAmDvdDPLG+X99chAE9gKkzM5ADruU2l+6yhv6pEaRSUvxpgt+oCHDy2kwayQNoQ1Gak0cHHLHtnuggL3sSrMOEuOKnBgFGdGIlhtxVImV8qxKJ74H6lOsLIPquPBbCCMyGVDPZIbU3DqxIZkrlXr/knxcTCnA0asw2f8FVUSW+PBtlLbrblP6CD35y1h9K2XJVuupuPAAxOolX2K5eu6jIZdCtWGOouTGNQZGROfIyPmg6+AUsvKCyJ9JfhfA21OGqvmAlOyLL1fwSj5oecMgFc7Vr+eAQjgJjz8nE1Hm0T1V3VuYXFQEX1jaRHfffh8li4Rz6Y1mSHiisNjBfFP2jHeSnlEqLf+9zxEfluKA5Z4OCW1qtTee0rmQ0Yrh1lQeTfF15ctJMLJQ92rTEdVvJBRsSs6tAmdqHqwfayNa9seB+A/Dp5DYkzBnRE93cxah+qYTGS9GQKSGIDUPpVSl0/TKmGVF+cmeWh7YFwWZLvVWMaORCH0WYupDobihjXuBg810lj2OXSpsEFLekaZ2iyaI62i4aR99owJI7V/ogmrovOSpaJd7EseoiHIvMq7SabdJOuDKvMVT2oGNiuzRx2j32bG6A+2jQAyDtMBjVxyTb57+yWY03KfuK77HmYK8OhJ6pPHCSgfEmmOjhnRY2SECBEiRIgQIcIcRMzRUXD75Coe3S9eNorphU7Quwst/Pq+s7n8yscAMBQPXXW594BEfaWZBK9cL66yg6Ucew41c2BYtEE96TwV32BNRjQDg7M57tqwCgCtIhldiVHZUeY798N3wNgq7/obtBK3rREtwTu23yNO20EmjaE4oUvvxakddF42za+HlgMwO9BMrrUZpoXpUPIzZAeE2ZpcoWGnISOWLvgqzPTGUBdItXq95IVsimpBfAoUN4hqcwrFhT5eQrQwasZCGRGmyJxSMFeU8M4LfJl2NqBVFKa2yzg0F33sdOAc7AnZU0t2cZJQ6iDUIKlWnSlyY8zTbbgJP3Tw1suiBakFVlpFkfWCCFu1FfwgItcsyT6LSaIbRtHHLHjUisGZMw4TqwN2zYVqTrKJQGrI9XUd4spOyVFZGhtlvyWR+S8HV3LZum1snhCd1gJjkn8dewn37ZO5YRdMlr3nIUA0Rc36LM26ROZ5N8mq+FDIWFQ8g6/21yu8Rzi5GHXECr7LyDNsNVIKJqFmupg75bM+q2Nn4DO8EgB7f5qmMZ/xC2Uyd6VLjO8SXY/igWtKNiZApVXqqxUelkzHBxfkUKqBw3yDTXEmjqEHNdAyPnlb2IuNo93MTKXoWyAMozcWJznu0tAk82hd4zD/dY7Mv0lLJdY+i7tb7hvahIIZh1KvzO0xK8PqBqlxOGo3sCYxSEaRazajVeZloFlznKB/m2qlHQ2teqH+2ZPPLipL1g+y60nRFG6b7WCJOnDS+uSfgGw1P2KOjhnRw1GECBEiRIhwisPzT8BrtShb7ZgRPRwdBWm9ghJkN6V2GqgX5QFY33iA0TMyPH5IoodD0ykMwyWTEH1ItWrwqw1rATCnNNa/bDvJwL/m/sE+MnqV87KiD+pMFlhxvkSAE9UUG3ctxCnU3WfV33TzXyPirbHrkYUYH5WJ/Y3l90sf75GsiT/uvCfcpuDF6Y5N8ceLZZ27Xr+c/RP9NOzeB4A3MUn6UYkCXbMHO6WEGWeeDp6mUMnJ99i0GjJmmu2jOrIOQCzvU25TUAJvFr3VwQoqjJe7PUqjmdANOHNQwUmA1SDLk6MOk2ulIa2ioFXqjI9Z8MnuVkKdESpYAWtjjoEx61NqC7II5xj1mnmITfvM9Nbdv81pYYwg0Ax5AQvmBNl3Qead4ilotoo5I5FyudXADUpC6Q74OjiBe3ZDc5E3LdhAjymOxcN2I2vjQr29c2nNAVwG9OXJAe6aXoEzJQew7F0Psehh2amhOFQ8I3TbXWyM4aGS0SRyv6n/tz86P5WxyBQtUFyxOeA3sa8krKe2K1nPrATMAih3CTuUdKCwCPr6JNtz8ImukJW105JtaRRkDsbHRbOUHgrqD27TKLfUNHsa7pJy6OGV0qtsn5ZrPROvojb7pA2Za77mU81ptKQk5XRt8gBja6Q/921fQnU0iblYlr3myo08Vejkje0PS98Vl5mAEu0ypogrNnts2c+3lnfzib2PhNqmuOLw4d5zT8DInl4wFAcj8E7bWe1gVcMI+zpkLsxYMfZ7TS9m9yK8gIgejiJEiBAhQoRTHFG22snFaTtSf/M3f4OiKLzvfe8Lf6tUKrznPe+hubmZdDrNddddx+jo6IvXyQgRIkSIEOEEoPZa7Xj/RTg2nJbM0YYNG/inf/on1q2bn0p6ww038POf/5wf/OAHNDQ08N73vpfXve513Hfffc95H3fuWIYaFDzt+uxD4e8//dEaNNXDcuXVVE/LFBPFVJiSv502xiZFsGk1umz6xXL+4A/uBGDlihH+ZduFdC3LA/Cy5m1sLsprs7hm83trNvNYu6ThLno4xZnpTRQ8ob1fftV2fnFwNQB7vrMeZX8C7hfK+08bennLhfIa7RcHVlEoxWnOCJW+LDfOzLWzZPafIQdw90aUabEWSIxZWEtilFvkglEciM34YSkPxQe9LPvwdIXZTgU9KDyrV3wy+2FGvDBJxGyqet0SQDE8qMi7qZmVNuaYQXpA2i116GT21C9SX62bSZZbFIxiPXXeTkNirL6epynhqz61quDGZZ+FpS7aU1poHlluk1eAsXx9WyvwvHMNUGzC0MBOi8FlqVt+8BUfjECMGvdIZsukgn2e0TYcFOWUS+ex2UU8gaTZJzSLXw6s5O/W/ACAL0+ez/7zivRTnz/7z5Pz0rF7ep7gVVM8NDw+1nc2EV581M5vVi2zyDzELUVJnPBMPxTuK8Er11Dj6ss1s29IRNaxWaX+GnoSQMENXgXrVVm/9rdKr/hh4oGT9OlqyZPU5dVZTHWwgwrQuViZrtRMuGz1mgGsVRovaZH0fA+FwdlceBxnrN3HyqykpV+W2crLs1vCZa6vompy4VV8g6IXCxMCAG7sO+d5jd1vA+pO0jr5IJX/+4NnU7YN1nVLQs2W2/oZzLe9SD2M8ELjtGOOZmdnefOb38zXvvY1Ghsbw9+np6f5l3/5F/7+7/+eyy+/nLPPPpuvf/3r3H///Tz44IMvYo8jRIgQIUKE40Otttrx/otwbDjtmKP3vOc9XH311VxxxRV84hOfCH9/9NFHsW2bK664IvxtxYoVLFy4kAceeIALLrjgOe0nuS1GZZ1MpPGfrqD1VdsAcF2VYj6BFpOoX1M82q/dyiu3i/LyocGrSXZKWq3yUAOVFp/vbJcIzBpJkumZ4aHJXgC6k9McLImxY1x32JZv58L2vQCktSo/Ongme7YIs6RaCnQLbdPdOsWhuMVFC/YBULDj/Ga0H4DiQy14SZiwJX33rtZmiLtMrpKIsH1TDt+SqNONa5SbFfxAfJwYg3KTQr2qQL3gql7yAI2i6NAxCgqeEUTSQH6gAbVB2vUKJpkn6hFopVXFM3xqIbYTV8LU+HJrkMoflOmoMUhBtQSSB/2wiC4KuIYSFrQtd3hopSD92VEotxEySYmDCkZZCu8CJMdd8n0y3VVXCugqwbH5qjBNjYuFdrIdjdIuSeV2FSgNZdCaRVTfncgTV20qQfHOq3KbqNQGEPjxpov47LVreDaMOA1ktQqtmhxMxBidWigEEzSlVhl3MnQkRYU9vGQWZVAuEDcOlRZISTY8iicMUWWhzHM754UJCzP9LqRdjCGhjmZ7ZF1Pl+WeQcgqeQmPhG6HfUmqVlhQ2fI0ktihKeTa3DBL46M0BIWwPV/l1V2bZMMuyKiVUOQPwhDV5m5ctUOjUTyxk/jRypYTMHqnPzaVhQ1eaE6EJpDXdD/JP224lImDcs9OuhDkU5wURNlqJxen1cPR9773PR577DE2bNhw2LKRkRFM0ySXy837vb29nZGRkaO2Wa1WqVbr1dBnZmaOum6ECBEiRIjwYiB6ODq5OG0ejgYHB/nzP/9zbrvtNuLx+Alr99Of/jQf//jHD/vdzhDa+M+FcW8Ga6GPkw5S2JuE6vjGctEKWf8Swwre46cumMadSqDuEBbHAAoHMuwNCtOOJdJMBIaMmc4CM4dSTBQl1bs4G8PLm+gBM+I0uBBomQam2untHyER0Dp3Dy2hmpcxaZiB5KgwIwB2VkWf0GnYK+v6pRKeLVGnma+iugZmYIaoeD6arZDcG5glVupmjQ4q8UkfvSLf8+dadHZMYWiBSaVZoRKUOxiZycLOHPEJaUevKJRbFAIZB6XWuqaoxhTVqn7oZdCsejHcuctcXc5L7awYBRUnFXxTwM764cJKK8R2+8TysoNSi0ZVMnCJHwIrC4nxYN0W8HrKzJZkfJ2hFFpVCfahU+m1yGQkRNxfamJdcpDP775cxkj1+L/9PwbgM/uvYtFH7udYsNCY5MnKAjoS08e0foQXBxNOmpIXY1EyuEi64OGFYg6bHFZwGh3U/TKxFQ9UGzKbhZkxSvXSN1pFo9qo4QWFZlMHRI8UELx4Rv2aMFvK2K6GGVKm1FPqNYcGs0wqsAdp0otk1Apa4IYaV21WxaVOiYEbaNlk2wk3xaDdTI8xEbZbKwFyw+6t4T3sdMXwB6QsU9dnj+0afCb8230vAeD3z32ccuDrMWvHObd/H5tvEZPc2BQQ1Z39rcVpozl69NFHGRsb46yzzkLXdXRd56677uLzn/88uq7T3t6OZVnk8/l5242OjtLR0XHUdj/0oQ8xPT0d/hscHHyBjyRChAgRIkR4boiy1U4uThvm6OUvfzlPPvnkvN/e9ra3sWLFCj74wQ/S09ODYRjcfvvtXHfddQBs376dgYEBLrzwwqO2G4vFiMVih/2eGAP3TInOanojENWM3lOkJSVMQrFqMvv+i6i91lfMCropbMpZHQcYee00A38tEY2vg15U0TaIZmGqLU1iUiZrMRtj1dIh9hwSesPYnaDSbRMblHBScbUwU6y8tMpEMcWTdAJw4cJ97A/E6QcmukkP1pmX9F4VOxsUlAVhjXz5rO0ZRjtnWWimWGlWiE0RGiC6Rv1CcmNB8dmAkepoz7O04RAva5SxOeRk+MqtrwAgPq7gJ8EPMsc8TY69mpPvWrWur0CTaLvW38QhHycpeiaQLDmKgW7okEu1Qaca+K7F106RNIURsz2V/NZmksNKuA+z4ONr8t3KKMTF14/8Khe9oFEJ2qm0uWBpWNNBpxIuviZxQ+PSCaqHMhQKcuAjiQzDdo5XLZC5uC4xgBvQA0syh9jJM+NDe0QPYigOi2Njz7J2hBcLP1wpWUgXb7IwFJef75NM0esWP86DHVIOxtgVp+FJPdTlgbBHRlC3GQ9KcokSy0PDbpmHAFaDsEo1ZikxDoVFAdOKiG+tINVt1o2xN7gveLvTOJ1Vfm9VPetsv9VCU1CGpkErkVLqMgEDl5Iv83qP1YaGjzEnS7KGzy1Z+TxG6cXHwMfl3qpazDsPxws1YOw3HlpAMjDczFfkHlDuCYoA53XmVFV5wRG9Vju5OG0ejjKZDGvWzBe6plIpmpubw9/f/va38/73v5+mpiay2Sx/+qd/yoUXXvicxdgRIkSIECFChN9dnDYPR8eCz33uc6iqynXXXUe1WuXKK6/kS1/60vNqSy+BtUWyEnZ/ez3+oVqxSfBsjfFdEsklhlV0t16KQh2NoQS6nIeURSxiU6iZ8X3QZ5XQ2wQVFrxcChcOTjaydV8nvhNomVI+iuaHTI2+YobyQdlJZ0eeFY2jPDS0CICSbYZZbkOLc9j5FIYEkhRWOBgTOofWSv+7xpbh79ov/bFsFBfK7bKunRKNUWwiKM8Rk7IcIBGxZ9ajs8IdbWz023jyUgmNX9a9k8RiEbO3rptl5N5u7CBKxoPUECFTo1l1zyFzRsp81LRHlSZhjdzguM1paNgttJyb0DFn6+fIu6eRgyukQ8sWH2SisYFSMKX1WQVQQwbKjdWZK7WiotpyfAC9y0YYmc5SCTylsOpvm8d2NxPrLNIYMIVl22Sw0kRPXDQou6oddBlCkb2+aQOfZr731lx8YPfmUP+R95JklMrvtJfM6YC9pRZUxWNps9COtx1cwZl9kp72xPgSctsUnGDa6BVQbT+cy6V2JSyoLF5ePkYx0PAlAZ2QzdQs8JpkLmuah0pd71h0Y1iH5IKIVcGbMHlysguARd2iHxq1Jbtyrv4IZJ7VCiPHFZvFsTEKwcU14aZPyBidCvA16Prk8WuNno6De1tYvVLu0aWKib0rQzw4h74CHC5LfcHgwwkoPBvhWHFaPxzdeeed877H43G++MUv8sUvfvHF6VCECBEiRIjwAiB6rXZycVo/HL2QcBJ1liT+ZAInCLL0InhbE6HzsuIBvmgIABIjdW8gc7cwPT0fl4hm6MMXYebnZKXsUhhfKg0rj2dI+FBtlahv8VmDHJjK4WqiF1AUn1iHiBl8X+Hu3f24ljRUyid4ANFBuLaKna5nq8VaylTjJlpVaJLx85qIrcgBoFk+pY56NlhqSMHKEWZ1mXnCDDO9IDqeWuDiqzDb6/HWRaKhOVBpRFODLD3Dou1RB70oYfP4GTGqzWCn/XCMUmIyGxTkrI9JYkwKw9Z8kIpdPlaDHExyBOxkfd1qE6gl+bLvgYUoaY85QTPVXJ2RstPgZIMwPuGiLKoSM0Q7UHEMKuNJqRwKGCNGuJ3VU0VTPRoTMvYvbdnJHWtSZJ8Q75MWoxD6HNlBx745WHdkf8xqIqWIZsHyNSrBgI47WTR9TmcjnJIYvmCGHf98LpesFjXZ+HSaA/uFidF9YYBCfZwBxTkJX8lhiAeJYaqNOGLXnN8zcn0ZgZ7OVxT8wJleVX1sT2PWDrInPY3uxZJaOWy1sWzdIGtzB8P9zDpxWgKquODFw/lYc3au1dNyUci7qdBb68HZJcDh+qPTCQs/duLZIoBYoAW1PJUt+4SlM1M2nglecH+vNkI8Sjb9rUX0cBQhQoQIESKc4oiYo5OL6OHoKFBdMGpeOz5hNpoWZEWUg5I6ehlieZ+emx4AYPTPLwrbaPz6A/Pa7P6URDkT75B13BhoPxUhTiKIKn1VorzhXy6kvKpKYEBN/NYGZoQcYsxMYxQUlFrGl+ozMRFEs1UFN+ajeHIRJHQXS/PnvWyu5IIaYhqkB+vRrGb56OV6PSg3VmfPPBOmLqhiJuUH19Zozc0yXMkB0G7OcEGnaJkWxKe46wad6W+JnfaCHw2y52099JwpdJHymVbSHxHdxrQVZ/++Vtq68nJsB3MorkL2qcA75owCTWlhbRakp9k20Up+TARLsWyVZa0Smr+ibSu3jq4iHWSWDBUayBcTWBNCQRmNVXqbZB8l28TQXKzAbyplVlHSNomUZPmUGvSwvlxr6wzTxQSmKhH2HWuEDawGg7QiNhxm/xhBFL7HqftwGbjEAyvuvJckp8qx9JsjYZZbhFMby/5kA/k7O8PvWkHmjZkXfVyNRa40glZR6t5dbp25dJKg+ErdUdkXdtQOivapNsSHhfEpxWLETZtZWy5wVfHpzYrGrenMEiuzI6Hv0awTpy8+jhUwkqN2QzgfVcXD89Xwe6teIKVWw/l4WXYbm+k/gSP124MFc/RLu7+9HoD+1nEGTRvlNskM1qqg2CdPxRM9HJ1cRHfnCBEiRIgQIUKEOYiYo6MglvfQgor0vlr3/iHIUGjYE1SrNxTmEgDt//Ds78CbvybrjLzvItHxBEiOe7R8pV4kd+T9F1HqlP3YSSXUzOhNFWIPpEL2ykcJ64+ZU2DOKMxKIhuFwSxmRyn05ohP6iELprp+oIOQaMI1JOqtteUZ9QyvaquHqnlYo6L/0Ysq06bDjmmpQD6VSIaVwg3V4dWdm/jqqyXbb09vD74K+4aF3VLf5tLnyIA2x0v0rNnJhkGpZbTgFypTfzjLzPJA5DWawgsyxdpiBRo7iyxdIv5Ag5UmdhRkEEpujD/sfigcO7XNw/Z1vrpXnG6bE0VyMWln30wTpuZgBGxQ1qxyVt9gGFVNZIosyUoa0YJ4nhajwM9W1YscA3hBXDHjJcL6VENOI18auA8vCCYzKgw6PrlgeZM2Rimorj7mptGUSHN0umBwOgdAU6aEvlbqrA3uayU5UPe6UR3JyqwF56VOSAd112J5HyehyDUHZPcoqI5PuUVWrnaD0ybXj6r5aIpPUzBfTc1h06joXs5sH8JDpezIrTulV9lbaQ3nsqG4ofbN9Qyqns66pBjbNmmiSxp2ZC7HT6Qx0G8Z9v6NsPtO2kU/INf69oE+vLhPKvhboHhQaTt5TEzEHJ1cRA9HESJEiBAhwikO31fwj/Ph5ni3/11C9HB0FHiGglIbnTmvlRUP9Epdw2MWPFxTYept4sKt+ITeJg3fFM1R6ToxoSy1qlhZwqryHTc/M8vU8ff3M/RhiWA6Pnc/hX86D4DkgylmF/r4hnSicbNKsVu20SzRDqUOyEUQm1Sxx9Mo7dKp2YU+DTtlmeISah9A2DGjGHiwIJ81CWaptoLnqpARWskxNDRg35CwQYNjXfhdQkk9FF/Eq5c8SUdWDnTP4hitzQXGdwYuv5qP3iWsSb4aJ6lbvLp/MwA/fNl5pB5sIJBiUF1f5IxmqRVV9gwyeiX0Cmo0SlzSvBuAimdg+1ro97IsfpAOdZr/r//nAGyuLODBycUAvLP3HuKKTSYQgOyzWmnVZ8JtVcXnoJUD4JzUXiacNIseFq3R/vNEiPbElETy22faqFwqhY1v3PMEI06SnsDue8iNkVRtBpyG8JyeGZMx+Yve+YamEU5ttF+7FYCdXzqf3n4533rGIn5IDzMkzQLCxAZMsjkNWrVe+0+r+pRbZWJnDvi4BiTHAmY4o2CkhMnRdRdTd9idl+tlthyDbcKkPmTpXLXkqbC22gJzkkNOZp4vUk3LltSq7Cy20VCz1jclm+0/Vhy9nNLvCsbeW9eGtn3h8PtwVm4rWA0apS4Z29gkxAcU1OCeaJR9jOrJY389lOP2OTre7X+XcEwPR01NTc+pUUVReOyxx1i0aNHz6lSECBEiRIgQIcKLhWN6OMrn89x88800NDQ867q+7/Pud78b1z29/TPE0VY+Kx7zauhYaTWMCPWKOOKaBT9Y16fYISvPvPlCst+uZ6zpZR8UJdy28D8uJH5IokXjV4/M2//U2y6k8esPkByRdcf+9CK06cAn6JCPlVVwUvV2fSXQLuTmZ8xoFSh1+Rj5Wo026SNInSfNItQ9uWagNwq2LbcQOm3rMype1cRuDM6r6lOZipPZVnsBD/GtQkFZDQrfHz2fJSskO+2alZtZnjzI5laht361fSUH8jkZZx+6UjN0BFbc737Zrxmzs3Sb4jrtojDt1PxaFGxfoxQUg+s08hQCV2vXV2nQSiw2RY8kNaQcRgIDqpIb493ddwCQd1Pcnl/FH7XeA0CPMUGHPhM6C2uKH+qIVhhjDChVzs3I+O0n0DgFmUQl2yQg2phwU8H20k6/UUVF4f2LIpbotwX9767r2tyvtOMkIDEh11M1K9o/zQruDeW6QzaArytk98vccE0FFKlXCHLdeWrAUJgOrqcyu1GYo9iUeOoAWGWDHYU2tu4V5rKvZ4x3L7qTLWXJDJ1xUoxWJJvzyUOdLGqY4tFpCVK/N3U2zddsP+Fj8luJGsHiQ2aPfNHLoDo+WiDV8tW6XvNkINIcnVwc82u166+/nra2tmNa90//9E+fd4ciRIgQIUKECPMRaY5OLo7p4cjzntt71UKh8Lw6c6pBDTwsfE2ZpztSHZ/YjIyJ4vnCxtSW+5J1BqC4PqXXnR9uZxY8jJKCEmSsKD54MdEHlF8r6x1aG3jvDMP0Wy4MGaD4lI8W1GzTKh6pYYVqLog63Xo9Jyclbt3xSdmHZkHqgBI6eNsZX6JWhDFSbR81jG6DCKla668cq7SjAArOiEyZarOwUPEpWV5pqrNV5rRPfERjb4Poka7p2EyPOUmrLvPisaYeDk2JhmL9ogMsT42G3iuTbponprr4dXEZAK2pWQ5M5QAoTSS5ZO0O1jZJ9k1ctelVxTn4ycoca2KkjtSElwoj6rhqUwyKqW0sLeItLfeFWWQpxWZsTp2pjFomGVQ2VxU4K1agWRMdUdPOWb7av5jklXt4OkacHEvM0fD7/1hw0WHrRPjtQf//fpjCm+pFrVVXCXV8IGzy3PuCVq1fe9VGBSszp6Zgn0VfYx6A3swkDw8vQhdLLDwDrFYn3M9MNY5SkOtw35Yu/r/J16DrchG3ZWbZNyQZpGv7DrAv38j5HVIbLGKN6jiSzuhIsDP1z74OiqtgzgRMYU5BO/RC9C7CqYBIkB0hQoQIESKc4oheq51cHPPD0d13331M6730pS993p05laB49awzX6tHeCCMjxOvaQXmVGgG8P2QGaqtG1jb4OmB3kipb1Nzo1Y8eYfdvCXQJMQUYa78ejtWWgk/x6Y9YtO1diE2JctKHVBp9fGCCDUhEhycZMAAVSRiBQgKy4fH4iREY1TrU7UBEuM1lkm2V62g3UOBbik752JT6n01C2APix7o3t6ltLTO0KyLgOntffdxcEEOgL7YOL84tI68Jeu+qn0TZzcNckdFmKMFqTw790t2zVXrN9ETn8IO3IBtV6dDk0FYFR9CwwtdqlXFZ9huZLBc9ydaYMoBPzjey9XZx6kEQrK8l2Cn1UFOk1D9qUoji0wJCUueRk71Qm3TpHP0Sub95ghZtUJrzUgqwm89VLteW00v+3iaErJFrqEQz89n3WvXsGsASp2ZWNA9QX/grTVYylHem0UN2F4n5RFvkYyzmGljak6YqdrUk8f1FNrScm3tn2jCTP3/7J13eBzV2bfvmdm+2lUvLrKKbVzADRts0yGAKUkgIfmSF0IJBEJiEsD0QAATCKGEFghOo+UFXkIKJEAA0zEYDAZccK+y1ay+Wm2bnZnvjzM7knCTbElu576uvbQ7MztzZnZ2dc7vPM/vSTnHa6sNs/6bsb4+7f2eTMah6YFUbucyf734HQfwRKwBrUwnp9UGlh53jo477rjtrlPsf/aKopBOp7e7nUQikUgkEsneTo87Ry0tLdtcHovFePDBB3nooYeorKzss4btaVwdJogQFSylS+aaHTuQUYcsFUcJEht0eW7Zyk9mJOlRMDxKt31l3KjVlK0oWbbztqYQKVcJbbRfuyCRb+/Hp2J4wd/QGVcU2JIZoarEShQMb6YN0F5hohaKGBo9raC3iEwrTVfxtnb6GvkbLEwXWLbJkOGHRIG9bouoN9dhW6RYLlFXKjNqDnQWCcdSwN0O/i1iP4s2D2Zk1hYqvCI+qNTTRLlHPPcpaU7IW87mVJ69rpmR3joOHymMRpqNLL599EJxDVDxKSnq0jliXTqLmOWx99Pd7bfV8KNiOf4vEd1HSBWKzlUVrxNUO0fXGravkV2rzqfq5Ntuwmv1AgJqvfPeT9orgA62hUcx6LA83DRsyjbXS/Y/VMNyMpbcUfFlT/ttdTViOCpSpEzDFeuMY3R3iN+O9EHivsr3xWhIClVyfWM+yqA4Xp+4p5WUC8XeUdrQ8GgGJ09e4rRhbXs+gwPCP2vN5iLcPvGjsmRNKRhSKfgqkXOmO8+7ZhNnWP+bI5wqApbaWV/S2yTU9czrtF/BtWXgrq/VB9NqUjnqOT3uHH01jd80TR577DFmz56Nqqo88sgjnH/++X3eQIlEIpFIDnQsnLHzbu1D0jN2KSD7n//8J7/4xS9oaGjghhtu4Gc/+xler3fnb9yHUMzODDQtZTlZW5YilJuM8GB6RBV7Jx7IFPFAIOKRLFVkOQBoepfYJBt3VGybzNHQgwqBLXbMTNpCTSp0lGQCeXCOmQqJfSZyO+N/Mllv3laLdLDTX0UxLbLWq3gXiZgZ13cbiGSJzyrRnk0qW8FtJxcm8oTvUdf4qoy/iieikPLifLu8LSImKxO/JLyWtr6GAOlWLy+uHceJZasA4dIbsE+m1N1EqafJ8SfyKAYGilP3KY+oowqF1QQpS6PU3QSIrLKMMpSJNTK71FLWFJP3F44GIDgkSslQEZ+kYlKdznFqUI32bOG83I+dumdfpgZTYrtnh9QUNeksSu1Mu+pYNttTjnLUOFeXT9vmOsn+iaV2qa2oiO+EpnfJRnV1xhhpGthhd3iiJv5G8ETF93LjR8NpmSTu8+B6N8YQg8KDhFq/pT2LId/+EoChH9vq0uGdcUQqMSLvC5uViRWb+eKzyswKFAvWPCTuyRE/76zbeCBjukG31fGGnx6BN2I5caHuDgs13RlzFNrQ3e8u3SXISE13ftaS/Q9155t08u677zJt2jTOPfdcvv3tb7Nu3Tquvvrq/a5jJJFIJBLJ3kSmfMjuPiQ9o8fK0WmnncYbb7zBhRdeyAsvvEBJyf5dnyeRp+Fy2zeSBZounscLFFwdYOTbGV4BEavjSogRhOFVnHpkhteOIeoSh6R8ZaDh6rCrabeniQ3ydGa6KSrpAOhh8TpQraDZIxhvRMQfZeKVUmEF3XbLdncoBGs6q31HhyqkAxC3FShXh5+QX0yoN4ZMAtUq0UnitVrvJWuj4uxXS0I6KI4fLRVqlOnJnICCpx0nYy7j9NuVTCwTpoJhqLy1aSQAQ3MKKQ22AvAFw/BrKaZkrQcgR4vhUTqD+jXFImGJwCbd1FidLCFpBzqN8tWyLClctw/1baDd8jkK0upUCX/bPBmC4rWmmo76U2f4aTayHEWqOh1mZXIQp2WJ+lnjvNXO8T2YlNjxRwDp42q2Os8frBTbr0jt398JydYE/vERHd8RyozlEjUZm0eL70LectPJBNVSdvxKqrPWmqXZrvkIT6TWpBirGl7ILm0jbcsXucG4c7zNUzvvxa5Ej97iPHffNgIA02th+Czk/8PupLI6MwpdCVHjLoPpBiUNWcJKTcSF2b+tqg7xIrDN/PE1WQxkuprMVhtYetw5evXVV3G5XDz33HP87W9/2+52zc3NfdIwiUQikUgkAtNSUKTP0YDR487R448/3p/t2OuIlYBmqyFavLO2mqVC2tcZRwTgjlmdI0JEHEJm2661lTLRdHpQjAgV08KyYxJay71YGgRtBUpLWrhiCskC8bqjXMQOgYhfcHcxIVeMriqSiHPI1ERL5gKqBaatHM0PoTSIuIUpl6zmE18lhXliZ01bvERGmHgbxXEsF06dNcNrz8Xb3y3TA3oQPBH7tUbnJK0F7RWWOC6ghHRysuIE3EJS82lp6uMiWCmWdjM2u54VcVErykBlmLfJqXMG0GYICSrPFSWkJsizlZwF0Uo2xEUK3zjfJnTLxcqk2M/qeBEb1hYTHiTObVJxNUtSxWJbTz0rLJXRXlFdPWJ6GeWtxWcrfD7FpMEQH3CTGaDJyOK1lnF2a7rHG034XGW53fYx/q1VJcn+T/DvIpYn+fXDiRdopErFfZ5e7yZymrhf0lVBfE0KatqODWwzccUtXHFxn6fCGsUf2e7ZYUgszKNods9cnL+Ky860SvrAyjJQ3Pt2ncu+pqs7dusF07EUnCoBkXIV0wNR23BfMeiWueaOdMkwTkN3FyvJ/kSPO0e9zUR79tln+eY3v0kwGOx1oyQSiUQikXRiWX2QrSbjx3tMv5UP+fGPf8zUqVP3We8jNQmuTMaX0ZllYrhF/EDcrsFrKSKOwPB1qkEZ0l4FT4eF9ZUEykSevS+vgukW5jpKWqhVhldzjhlosIiWZ9qjOM7VvohwwM64VqeyOjNm1DTo4U4H6+y10HqQgseODcqqtRyvldajGgldeRDmJ6IWk7cYRp+y1sl2Mf0malx1jo/VOVevJYUPkpVJmlFw5u71MBSP3UJ5WEyxNiaCDA5EOCws4orq9WxWtIv4nLAnQdTwUBUTaXF53g5adT+qfaB8dwche+iWslx4lDS1uti2IRWiNekHoN30kzDdeO0st0OC1bRP8FETCwPwnYJPmOwVDsQGcEpwHR8kBon2Wi50S2O4uxUAtyJcs0HUS3Mrae4d/CYAsU0G55ce2e3zTNuy4v+OGoLkwMX70gLMb01FbRNf1MZjdKw2kaxy0KRNrF4xBONQ8YVprg0y6AMFV8x2ntctImXiu5aYGGf04DpSs3etHZmQPcUCkiqebDvG8CdHUPDorqlR+ysZDztHDdLB09L5umvWsh4UswhO1YIBlo1kzNHA0qtstd5gyS6qRCKRSCSSfZB+6xzt67gSYhSh6mKEYLjFw3KBHhAjCC1ue5l4FEfzVHVIBVVSQZXgljSuuCVGHyakslRMt4LhF6qL6YHoEPFoLwdXXGShJfLB22bhiZj4GlV8jSqWAvFBFvFBwpE37QM9oKAHhFM1iv2whB9SrFghVqzgabcIrwVvq3ioXXw5Or47DW+bheEVGTJqGlb+dwR5I5rJG9FMuCiKlWVgZRkULIbCL0zyvrTI+9IimSfqsFmqeJhu4aadKIBDT1rO6Nx65q8azvxVw5mUu5kjstcQUFME1BSmpZAyNVKmRtrUGOpr5YyiLzij6AuOzF5De9rH541D+bxxKJsTOaiKiWoP0xrSIZrTQZrTQQo97bTrXtp1L4alMNJTT1BNElSTxEwPKdNFljtFljvFulQRHRZ0WBAzFRKWhWmpmJZKvtaObmk82zaZZ9sm81rHCOZ1HMS8joNYHh/MxlQBmwyLTcbWHf5Fk0znIZH4//UxwQ0qwQ0qocUe8j9xk/+Jm3V1hVQcVEuyNkiyNoiSkxKxiYp4mG7FcdPX3AaVWU273AbLJR5qSkHrUEnWBUjWBbAU2HzjEX13svswLT+cTssPhVO2pYk40rQP28Vc/BaqadvbyF5nuiCdJerh6SGcjOCBIqMc7e6jNzz66KOMHz+ecDhMOBxm+vTp/Pe//3XWJxIJZs6cSX5+PllZWZx11lnU19d320dVVRWnn346gUCAoqIirrnmmq3KjL3zzjsceuiheL1eRowYwRNPPLHL16mvkJ0jiUQikUj2cky7fMjuPnrD0KFD+c1vfsPChQv59NNPOeGEEzjjjDP48kthSnrllVfyn//8h+eff553332Xmpoavv3tbzvvNwyD008/nVQqxYcffsiTTz7JE088wc033+xss379ek4//XSOP/54vvjiC6644gp+9KMf8dprr/XNhdtF+i3mSCKRSCQSyb7LN77xjW6v77jjDh599FE++ugjhg4dyl/+8heeeeYZTjjhBEBktY8ZM4aPPvqIadOm8frrr7Ns2TLeeOMNiouLmThxIr/61a+47rrruPXWW/F4PMyZM4eKigp++9vfAjBmzBjmzZvH/fffz4wZMwb8nDPIztF2ULoUjNX0zpT8VMguGOuUD4F4vkpWtdigvVRzAqc9HSqumEkyRwTsWip05IopMbBNFgPiIKGNCrmrUmyZ5HHaEC/QnEBrb3NnMVktJabvDE/nKCBzTOwAw7Q/015hApkplmi6cEwpDbewHcikqqq6mNJrWS0ixodf8RHbszXULz1CpPNn2QssSJeIi1Lii/Dd3AV8v+BjANyKQcJyk6OKYNSJviq+FhYNrNZz0RQLwx7R1KeznZIgABva83DbU2qTQxvsqTCx7cZ4AVWrRXr+X9xHc0/FPyh0CW+BhnSIXwx5mfdjwnjyMP96MrHyH8QraUyHmBoQxW2r07k0p7Nw2x9yQE3x1paDABgabONHRUuoSYvA7lnDD97OFZHsCu3/HUHo1DV7uhl9ise22YgXQbzENodNqVxQOp9fNZ4GgGt5EN3fmSZueMSUTQaXumvp940/OYL0RJE9oqgWIa9O2CcO0rZy8C7tc3/G9CgYbpFEAuLzSPtxrFAyZp0g0v2tLnMtltI9TKG/6ctstUgk0m251+vdaaULwzB4/vnn6ejoYPr06SxcuBBd1znxxBOdbUaPHs2wYcOYP38+06ZNY/78+YwbN47i4mJnmxkzZvCTn/yEL7/8kkmTJjF//vxu+8hsc8UVV+zeye4m/TatVlZWhtvt3vmGEolEIpFIdojoHO1uzJHYV2lpKdnZ2c7jzjvv3O5xlyxZQlZWFl6vl0svvZR//etfjB07lrq6OjweDzk5Od22Ly4upq5OeMjV1dV16xhl1mfW7WibSCRCPB5nT9Fr5WjTpk0oisLQoUMBWLBgAc888wxjx47lkksucbZbunRp37VyD+BrNknZAy1L7UxTt1SR5u+2U3AVQyGVDbGUGF6Yrk67+USuihpUidlp/6pdqNVvx6t5IxZxuwxJsNawAzTFuni+guHrVKigM720fZgoEWLaIpOWECNPwFnmbRV/Pe0WbcMVgrY/oeFROg0tFREEalfjQEtaeNoUsqpFI2JnTSPwj20XqyyY8yE11x3hFKZVK6NU5ImDBtQUGpajxGhY5KgxRwFqN31sSBU6++o6+MrTOjg0XEWxTwy/Y4abcl9ncGpb2k/UltA2RPKYOkGoDpcNegOAdyJjAEiaLtZ6ClibEBf/j6uP4rSyZXZ7TJr0IKN8tfbxxQVpN4SkN7dlLEnbBLJmWoTXF41jaSQz6u4s0yDpG/Y39Sjz/Te8naapIy9YyL1XfJdbfvIcAHf7ZhDx5JCuF/deIq9TRc4PxncYG7LhjiMov3HbKfmxEjBtw9egL0WuP0aezy6ifNZ62lI+uGO3T3G/ITpUlANxZgJcdpKJffndsU5rhLQfTF/ne1VzYJWjvmTTpk2Ew2Hn9Y5Uo1GjRvHFF1/Q1tbG3//+d84//3zefffdgWjmHqXXytHZZ5/N22+/DYge30knncSCBQu48cYbue222/q8gRnuvPNODjvsMEKhEEVFRZx55pmsXLmy2zY9iZyXSCQSiWRfoy+z1TLZZ5nHjjpHHo+HESNGMHnyZO68804mTJjAgw8+SElJCalUitbW1m7b19fXO7VXS0pKtvofnHm9s23C4TB+v3+3rtnu0GvlaOnSpRx++OEA/O1vf+OQQw7hgw8+4PXXX+fSSy/tFoXel7z77rvMnDmTww47jHQ6zS9+8QtOPvlkli1b5rhwX3nllbz88ss8//zzZGdnc9lll/Htb3+bDz74oNfHi+erKLbCYna5SnoYtIbOGB5vyiKVrRDvogpmRh16AAIdnYVnk7lilJEpGZIKKbjtahS+Jp3GcT5nBONts/CvN2mtFI3oGGphuW3DuITC0NvnU3OtSMu1NPDYc+SJPHH8jBqUyFEJbcQpjGupdJqYWcJMMjJcLHBHFfxbOtu/MzrGJjls+EYAsj1xJ1ZoWtYaIqYPj60c+RSdDsuDhji5hOUiZktcbsVAU0xSdj2WoJokzxXl2OAKABqMLDbpokRIQzpEtitOxA7aao4GGJcn1J9lySGsTxaysFn4/puWwkh/PTXxHAAqcptZHhFfxjHhOrJcKRL2Rfq4vZK17QWMDosv6OapUfx0Fvhc1j6oW2FPSd+R6xdxaPUvjQJAfyMfW+yj/Bf7pmFh0UPbbnfJAx9SdVEBAOOLa9gSjrB6o7gni4rbHOPT7wz7jMHuVk5bK9TTe78S52apsPYBUewWQ8FyWYy4XCi8qVwTs118t7zhGOtXDqJlmHCA/cawpZiWgv65+E15YfV4yv7f4r467X0L+zfOFROKvC0aO6n8gcYuipD9+62HO98HolSTkq8NTHtxnB52ex+7i2maJJNJJk+ejNvt5s033+Sss84CYOXKlVRVVTF9urBJmD59OnfccQdbtmyhqEh8sefOnUs4HGbs2LHONq+88kq3Y8ydO9fZx56i150jXdedXuYbb7zBN7/5TUAEYtXW1vZt67rw6quvdnv9xBNPUFRUxMKFCznmmGNoa2vbaeS8RCKRSCT7InvCIfuGG27g1FNPZdiwYbS3t/PMM8/wzjvv8Nprr5Gdnc1FF13ErFmzyMvLIxwO87Of/Yzp06c7/29PPvlkxo4dy7nnnsvdd99NXV0dN910EzNnznT6EZdeeikPP/ww1157LRdeeCFvvfUWf/vb33j55Zd361x3l153jg4++GDmzJnD6aefzty5c/nVr34FQE1NDfn5+X3ewO3R1iZGQ3l5IrOqJ5HzvSHtB82O37HUzkKzpsuel7YHDEpamDdmsrYsRZQXAUjlgCuudGa9JYRhYyaDRUsouGzlqHWkj1R2Z1acaoCrwyC0WbGPq6KH7Cwzv71Dq7NNmZgjFGEw6W/sbLuWtLplWSjO+xTSflDSdlHaqMh0ixWJ1zlPzt/hNcrO7XCyavLcHXjtoCifoqMpJkaXYZYbw3ldl87BZ0tvxa42Wo0Am1PicyxwtfPi2HxAlOJ4bNM8mgxRpDakJkhYbsYERSd8aXgQtXExb35f1ddI1gYhJNrwrfGfk+fqLBJ7UsEyVsZEuZDPW4YyIaealXb5kFxXDPP4apZt5zwjRzXs8DpIdp30cXYwnK0cGQGc+3rj7UdQdtO+qR5tjy0pcS+X+luoDDRS4hfqUHMywDmDRXZnczpIzPSQo20d9VB16xFCQbbjitQ0BEe2OutH/Lx7jGA2sOXfowGIGl5MS6HITqcL+FPUzTrC2Y/SJRur6Hf713X/KqZmx2XVWE5GL4jYI2+rJQpp22TiTRVDxBllyoZoSXDF982Yo56yZcsWzjvvPGpra8nOzmb8+PG89tprnHTSSQDcf//9qKrKWWedRTKZZMaMGfz+97933q9pGi+99BI/+clPmD59OsFgkPPPP79bCE5FRQUvv/wyV155JQ8++CBDhw7lz3/+8x5N44dd6BzdddddfOtb3+Kee+7h/PPPZ8KECQD8+9//dqbb+hvTNLniiis48sgjOeSQQwB6FDm/LZLJJMlk0nn91RRHiUQikUj2OHtgXu0vf/nLDtf7fD4eeeQRHnnkke1uU1ZWttW02Vc57rjj+Pzzz3vXuH6m152j4447jsbGRiKRCLm5uc7ySy65hEAg0KeN2x4zZ85k6dKlzJs3b7f3deeddzJ79tYVHi210/tCeAN1ZqdZLkj7bLUlYaFndfqVuGKd8T6GBxKdSVmoabHO8IuhhxbXnDikVI69b1tsiaUV3B0u1LRY74l2zounQ8L+PhP3pKa7+w0pBnjaxTHSflGUNqMWYdGZEVcgbPCdwophOkuR9ICib67AFqjsv+J2Kl42iAm+KmKWkLMSuFEx8dlpHzlajFZD3CvNRhYdptcpGPtVLiw9iqvXCjfWcncDn8XL0W0Zb3i4ibq4GIknGwJMnrSWYQFR7Hakv57l8cFMzhYxUTHTy4iAiClyqQaRtI83qoVakf/17oH92+InqzuzqR4dOWKn20t6R+YzqLn2COd+tPrNaGTPUekXKqSG+H4WZwsFfGF7GasSIv5ocmA9uqURVIQE/eDGD7lk5TkAuDraSG4OkbFBMnxQmdvcJUJua4q+KeL3OhYESJouJgQ3ARD2Jai3f+O8LeK7n7SLYtdfcQTRw+IMP0f8w9pRhty+SGS4+Fu8wCSZqzm/2XoIVF3BZf+eK6blZCa7M0W2u3QwjB1bA/UtfTCt1uOAUsmu+RxZlsXChQv5wx/+QHu7kGg9Hs+AdI4uu+wyXnrpJd5++23HTgDoUeT8trjhhhtoa2tzHps2beqvpkskEolEItkH6LVytHHjRk455RSqqqpIJpOcdNJJhEIh7rrrLpLJJHPmzOmPdmJZFj/72c/417/+xTvvvENFRUW39T2JnN8W23UGVcDw2EOErl1IC9KBLvPOKQjU4qgtWsoinideeFvFaCwjisQLxfs8TWJC29cEqbDYNjHYQEkpqEn7db6CpajOey1XpzqFJRQhb5udvWZAOiDeZ6l20cSM/4ZPeCdl5thjJZ0qk7dFqEYeIbbg7oBkDgy5c/dGiBlH7EwGmoqFpig0GSKrsERroyEtFJ8O0+tkrgF2vFF3xnlaAUhZFhtcHY7qdET2Gl5JjXO2i+oe/vXRFACyh7ZxUF4jg/3ivZG0j8PCG8Q6Vxy3YuB1dS9+uD1+snqNEyNVo+fuZGvJ7uCJCBUVwHTvf/EcbzQIH64zir8gZbloM0Sqsl/T+c8mESLwmjaGaUUbOC17EQCb0tkU+kX8nKpYxHM9mC32b1YozbBA83bj5bry/qZKPO60o7bWfziY4iNFzFd1Qy5eXwplcTZgZ7wmXE5WnOlP0362/TtqWYSe3bb/2T6DLU/GCzQUA9y2q3kqWzy3kp2bfVXJtFT7t1YDKz1wSkxfOmRLdk6vO0eXX345U6ZMYdGiRd0CsL/1rW9x8cUX92njujJz5kyeeeYZXnzxRUKhkBNHlJ2djd/v71HkvEQikUgk+yJ7IlvtQKbXnaP333+fDz/8EI/H0215eXk51dXVfdawr/Loo48CIuapK48//jgXXHABsPPI+V5hQc4qWwFqM2keLYYN6SzhDZRBDyi44mJuGkR8UkbR+WrsjukSbtqZeWrD11mHiRqNYA00ThcKhRZxYWkKyS41fzKu13pUuGebbnEAT8Ry/JGMACh65zo1DR2DOrMx0kHLmXZO5iPmse3MDF+rib/TjHqXSVhuWs2AExuECvV6Np9FywA4NWexoyrVpnJ4q+YgrhkpKjC/ReVW+zu/9EgA/lQ1D8NS8CniGumWRnlQNLi+PETYneT7R4gRbZ6rg1WxYkp9QhaLGj5nlK6bGssjJWSdsrZH55PJkgModTfBdivOSXaXgjkfUrCnG9GPJI4Vg7qNiwrYnMgh3yMCWdp1H9G4+GFIRr0s1AzGBTYD4FbSBFziCx7VPITCcZI+oXp+/6CFfDDe89XDbBO/V8ejddZsc7fDxg0iKDJrlZucE9toRChHqRwYXl7neC+t3lTMyJ+JuLCxoRreeja4y9egv4mcIxSu8NPbz7bNXpXxnhNKusuuUqHqQhFyJbv4wtlksvkyP2uJPFDa+r79kr2DXneOTNPEMLYuirh582ZCoVCfNGpbWD3QA3sSOS+RSCQSyT6Hpex+QLVUjnpMrztHJ598Mg888AB//OMfAVAUhWg0yi233MJpp53W5w3cU6g6KIbtR5SyCFWJ562jRPZXxlcoHRB+F85NZ4HSJZ3BUjpvRtUQClDGBwlLxAABpMMGvmaNrFVCoTDdEB9kouSLye9USsO1RBzU1yy8N1x2PFLu4/NpvPQI5ziuBCTDYsgTaDTA0kgH7fikpOLUX0OxsFSLpB0j1ZCnUnH97mek6JZGQzrMSvvkKv0NbEgU8O4mkeV1SLDaiTMKqCmyT1vNH7ehGH2VdkvjYG8NHfZ7G4wQlX5xvbIGJfGqaSK2OhRQkwzythGzZbqAmnJ8lnRLc0bwO+NHqzaQsNyYduBZnhbbyTskkp3z0QQXEOXi9QsB+Dg2gmNz7Yy9VC5NepD1SaHqaIpJnp0qNSpYz3Nth3JqpYgy+lb4M86pMng3JtKvVCyeHT1om8fM//pK0m8Mc14PuvdDum15Dwxj3TbfO5LNZL4x3gVFpN/Ix3Vi1S6c+d6BbXmGHhS/x5mf71SegR5WMF3i+64Y4vcWwB23MNydalKsIo2pbzvLtj+QMUcDS687R7/97W+ZMWMGY8eOJZFIcPbZZ7N69WoKCgp49tln+6ONEolEIpFIJANGrztHQ4cOZdGiRfzf//0fixcvJhqNctFFF3HOOefs0SJxfY2mQzJbDCdaDladOWr/FkgUQLLA9r6IiHiejJKUyoVMsJGrw67VY89Cmi5A7cyMUHXoGCZWWh6TtoMUtJgd25SbxtPgwkwIcyNXZQfRQ0WKnKvKh69RZFYANF56hOOsrWXmzO1aau1DNNJZOI66oSpoy9j0WAqV1/W9d4mGhW5prGkXI9+aeA5fbikmmRQqT9J0sy4u1q2ektzufraFWzEJq+I9Mcvj+MU06UHK/E2UaK0AhLQEIS1Bc1qk5gXUJG12llu5r5HPexjZoiomJiqFmjAHfaZ5GrD1tLJEsivcUjHZef69FSLwxUQhS0sStxXSiO4j6BL3fF0qzCWj5pG0jXlSaPgsg2MDIn7uk0QpRy4W0vS2YpFcJ1bZ35hd58vmEjTV7P0/jwEi/PR82s6dTtu5IvYo+69bxx7Fh4jvsBpXUUwFMxMREjBQm9ykJwvnqGSbl/Rmca19jSK+NOMF5c5JkmzZ3avZC/aW4moHCLt0f7tcLn7wgx/0dVskEolEIpFsA5mtNrDsUufor3/9K3/4wx9Yt24d8+fPp6ysjPvvv5/KykrOOOOMvm7jHiEyMYniFmlciqGQDohLlciHVGnS6YEbfhfJfAXFyHhfWCi2SmN6IB3sdL12xQBVzHODUI78tZljaBj+zpptoZUuEoVgldrmRhZ4/Pb89igdIxoiXioyVtSky/Fd8kREvFLCjiNyxSFQBx32HHukEnJWisbnPr7j2mm7iqqY5GlRhgREKse8zRXEqkPgFo184IOTOOiSBT3e349WbQBgWXIQoz2dsUIR0+/4D5mWilsxyNOEH0yNnsNQdzNupdPLKBNzlBl194R2w09Ii9NuCgVvYrCKw1YZPH7QsJ28UyLpHc+N/moWpPi+DP7IxUS/iO9Jmm40TAK2evpcy1SWtxVzaK4wr50U2MDBfpHl9kEP4vh2hWRa/Bbuy/MEeaWtAERjXoy05pgZ+T1p4kBlvgg0chWaRErFd3/LwhK0BCSGi2tfEu6gptE3sA2Xys+A0WuH7EcffZRZs2Zx6qmn0tLS4mSu5ebm8sADD/R1+yQSiUQikUgGlF4rR7/73e/405/+xJlnnslvfvMbZ/mUKVO4+uqr+7RxexJPMIU7aCsNcTcdQ2xJZ2icoE9H18XrZFoFv4WrTszvq7qCHhLde8NnYngVPC2qvU7UL3OcVl2QLBCjQ9NvosZVfPVipekWGRSKKtZbloLfI2IJ4kkPHZWdWRKJYstRnLxLFeGqbatV3jZRdTq0cdtq0frfHNEnGWpdeWlsLj9c1U5FQNSR+kCpgGAaJSpuN1dRfJf3fXV5p6Hnj1ZtINvOHjsoWEdATTlxRbrpolbPJWGrRIM9LWj2sGt7ddy2xbOjB/GT1WtI2HXiQqpw187Ue7t3+MG7fC4SSU+omRbBXCa+0JXeLaxMDHLu69pEmKZ4EDNHrB/ianU8ufqL1jbxHWt/ThQdL//eon49Xn9w5rDFAKzuKCJmeMiyY7qKvSK2MNctFGgNi7cbDwKgelCKUGE7Q/ziN2dsdj2vNpQNWJvltNrA0uvO0fr165k0adJWy71eLx0dHX3SKIlEIpFIJF2QAdkDSq87RxUVFXzxxReUlXXvMb/66quMGTOmzxq2p9FUi2RCjMBcG/yky4XaEc5KEPSkaGwXgUOq10B1meghcSmDm1Q0uz5aanyCdLPPqY8WKzNQgjqegFiQSrkwOsT7FFNBTaik7XikZLGO6jNw2R19RbUYX1gLwLpIPq0ug44akYml6Aouuyx3KhvcUXDZlaTVlEX+HzrVonV3T8fIFlOhrpb+zTcpdolR2NCcVlZFvVjZtvu3q3cZHqqy/e1NW4ZzKwar48XkusSobqinGd3SCKhCUkuYbtoNER/QmCkutwNK5otUQK+Wpt30U2ifi08xcSuG49ItkQwEnTUHu9cePG5JLVPCG6n0bgGw4+56lgFa/c+D0eaJ+1wxoL3SRCsWv3MF2R2ETl2zzfepmoll7lLN8gFjWxlqXSl2i3hIX0in3fAxyK7fmDTdJCwXAbvkQFs6wMHZIs7xoPFbyHXH2JwQ9RWrYrmU5zez7ask2dfp9X/HWbNmMXPmTBKJBJZlsWDBAp599lnuvPNO/vznP/dHGyUSiUQiOcBR2Kom1S7tQ9ITet05+tGPfoTf7+emm24iFotx9tlnM3jwYB588EG+//3v90cb9wj/b/hnLE0LQ6C6/BAH54nRg0dNs6kjF7dtXlQ8KMqS+hLSJba6MdQgy2vXQUp4SAPGIWK6cWRhE6pikeMRGWhV7Tk0e8T8fTrlIu0zCITEupF5zTTEOhWOsnAL/69QZHjV52bz8OrjsDzimL4mjcxgsWOohZZQSPvFlyDtV4hcdQTRQ2xbbkvHXSviZyyNPo83ylCj5+C2zZdMS8HSVRQ7W23Yd5b0al+ZGm3aVxxauipKGiatup/LC94FYFM6yKfxzmydhOVyMtsWNJcBO64D6NfEtqsjBVTHDuMXw14GoN3yYViqVI4kewWGpXJscAUNhvitMFBx72Tu5JLVwgV7VSLO31wiRKK93Y/LZaLHhVpeX19AwzMhPF67juGaEOkCkfnpcyXID7VTu7S4X85pINDtIM12w0fc7PRLUxUTrE5FOmZ6UO115b4WVMVE9YnrOzpYyybFzxsD1Wg5rTag9KpzlE6neeaZZ5gxYwbnnHMOsViMaDRKUVFRf7VPIpFIJBKJZEDpVefI5XJx6aWXsnz5cgACgQCBQKBfGranURWTQ8I1ABT7OhWcUl8zRZ522tLC5aPIE8GlGmS7bXdbS6HS3wjAwrYyYvlupuWtB6At7WdjLJ/GhLhmrR1+huW1ALCuvoBAKMGEEnHMhOFmYkE1SVN8REfnrCJoe5tUerZwyYh5/Dd8CADVCyqdStF6XprWkOo4bYfXKuhhUFvEiNByWTBCKFkV/ZhlElIT5NiZZBVZzaymBMX2Epn8hcXCiT2Xd1uNbd9jqxKDHPVIw6LY2+5oS6WuDtp9NY7qlKPG+CReAUBLPGDXHt8+B2cJZcmrpqlJZBOzs9U0TFKWi016/o7eLpEMCO+P96ItGc9Qj/DlKXW14VN2/N0q0oRFv+YzOadSqLuftJYTTXuoahHxNIOHtTE2u45FzUMAcB/WSpZbqM8Jw0VpoJVrz3gNgIevGtn3J9bPnBRcAcDadB5N6SzazU7XprZ0AFMTCn7SdFHkEfGGATVJzPSidVGsc9wDmIQklaMBpddRdYcffjiff/55f7RFIpFIJBLJtrCUvnlIekSvY45++tOfctVVV7F582YmT55MMBjstn78+PF91rg9iQZodsxMvruDArdIB/OqOmhxahI5ADQpISoDjc773IrheO9MzK5iRXQQg9ytgJjfrgg2MtgvLnvYk2R6rpj/V4tNoobP2XZ1ooRybwOqrbYMdrc4cS4+Jc047yY+8ZUDsD4MKdEcfDVukoUGRq6ID9CDbjxtYNppb3q+gd+X6rsLtR3+PqaIH64Srr4HZ1WzoHAYsYRQX2oT2Rz+hVDMFkzUdrqvf43Zdh20U0OLeatDZEhWJ3PZkgzx42FHAXDfxvkMdzWT6tL/f7thFACFgSg7ugI/X7MS036fT9E5OWcJKVuBCqrJbs7cV65dzv3D958sTcm+R6OeRcwu7pinRSm2y8hfvfZLBrsi+Gylw43F39vHU5cWummTkeU4bU/NXcdYXzU1JUI5MiyVej2boK0WbenIorpVvO+Y0rXUxrO5f/2J9n43DtCZ9h2XlR0JwO+rPmCI1sYniXIAau0f0kxmq1sx0G313tBU3Eoa3RIqU1vKT67SNLANlwwYve4cZYKuf/7znzvLFEXBsiwURXEcsyUSiUQikfQNliUeu7sPSc/YJRPIA4GWdIBhmogj0q0gCVs5cFtpDFSnSnZYixPQkk72Q0BNOXW4kqab4YEGqlIiPqU6nsOmaA7HFa8G4JSCpc7ITbdcDHa3OnFFn0eHURpqdjIlCrWo07YO00ODEeKz+qEARMfq+DaImKJQlYW1UaX1INGeaKWBt0HD9IhvhdauUXzp8j6/XtsiZlcVX94xCJ8rjS9LqFmxtAevmql5tnPlaHu8FJnIyg6RMRNyJZgQ2sxcRHzYrLLpPLzxA8cV+/KyI4DaHu87U5Ot1NPE/cPH8PM1KwFIWG6CapKgkuq2nUSyp1h6qMHhX4jnRVo7nybDAJRo7XyRGEq+bYI2ztPEScFlrNWFEhtUk47TdpmnkVJXq/M7Y1oKa7UiItlCJamNhuloFrF/n/lKmV68nka3+K59+OA0Rlz+0YCca1/z02FH8oOV1XwWFb59YVeCbNsrDUT8UdTwAuBW04TUBE2pzhhUU+8+c9KvyJijAaXXnaOvmj9KJBKJRCLpZ/oiZkjGHPWYXneO/v3vf29zuaIo+Hw+RowYQUVFxW43bE9T5G4nWxPqQLYWc1QQ3XKxIZFPrluMLvJcUdyKQb0u5uM1NUHSrm3kVXXcisGWlBjJFfvaqYmFnfiANrV7FpZpKgxxiVicSVlV+JSU4xXUavjJsZWsmnQuyxODObRYVN9+u2YsTtKEAl0Npd35CZIBF96NYvQT3Nw316cnZKqMr35MZNWF8sQ1KymMODE74N3l/a/sKKbIKzJvXlp9CPP95Xxz0VIAPprgcuIKesqRi8XnXeKKkGM75P502JFMW5TmgY0ivuKKsjcIqkmaDDFiHOJq3eX2SyR9RSZ27/sbdbYYIQBUxaLc3Yhuq7MxU0FVLEKqyMQa4molYqvcQTXJpnQOS+OlAGRpCZJmZ422w4s3Up8tfsfWt+axJRkilha/Y2cf+wELdkMB3tPkaDGOzxZq+sZUAXlaZwaabroc5agumQ3eTn+1pOmiPpE38A2WDAi97hydeeaZToxRV7rGHR111FG88MIL5Obm9llDJRKJRCI5UFEs8djdfUh6Rq87R3PnzuXGG2/kjjvu4PDDDwdgwYIF/PKXv+Smm24iOzubH//4x1x99dX85S9/6fMGDxQb4gVkh0VV+aCadJQOt2UwJWs9zbYjbZsRwLBUx4+ozQg4ylAmDimDSzEYn1vjLG9OB52siGxXjDytw8lI0xSTz+LljPKKOJnF8WFk28rRv2vHkeeLs6FNdD7VhIrVxZRBMcC26SDZ7EMNp0hVigWG18dAO/SMvPBToLNe2eGhtc716y1Xr/3SeX7Zcxdz13efAmB+uIJDCzfx4oZxAAT+q2+3NtS2OG5JnOOzlgGQMF3U2EohQEMqi7HZ9YD4HI4JrnBG3+92jN6l85BI+oNZZdP5U9U8AJKWQokr5sTdGSj4MDHtEhKqYhG27+MOy8OmVD4L20TYxJZ4kEuHvccJQaGoVKVz+TxWDkChN8r6aB5hj4iPfHnTwRS+FaXIL+KVSv0tHB8S36V7hx88AGe9ezw8otOn6bglcWrNTnf/PFfUUY5MSxXqkY060D0NGXPUIzLCjbITv6+d0Wufo8svv5z77ruPr33ta4RCIUKhEF/72te45557uOaaazjyyCN54IEHmDt37m41TCKRSCQSiaQnPPXUU4wbNw6/34/f72f8+PH89a9/3eX99Vo5Wrt2LeFweKvl4XCYdeuEZ8/IkSNpbGzcapt9CZ+Wcvx17ts4n3V2hseGVAGGqTrKQdJ0kzDdzihCtzRWRUUGVcCVYpCvDdMOggtpCRa1Dsdj12WblLMJw5Z8GvUQATXlxACUuRvZnMrj7baxAPx3zRjcS0Sci+mBDZUJLFPsN1it4m0V7c7EG6Wz7CGCauFd5sc2eaXod/1TS60n1E0XlbDblgUcP5FdYUVyMABXfuvfzgjvkor3ydE6CNg10V7bOJrh83PYMr11p/u7cu1ydMtFqyliwDRMZ783rFvMX+qPQbWHXCumpDhmXed75x6yawqYRNJfXGx7fX2V/9s8HxOLHDXuLOuwnd87TC+jvbWcNmwVAK9ED2Kst5YlSeGQHVLjTAgI37JsV4z2tJfmpPi+5PpjxHQPqxOFgKhLuCguFKjfV33AT4f1LvZvT/LOOD9HL046rxvTIcfzTFVMdEtzfhvadR9Zttv4gCADsrfLfffdxy9/+Usuu+wyjjxS3G/z5s3j0ksvpbGxkSuvvLLX++x152jy5Mlcc801PPXUUxQWii9DQ0MD1157LYcddhgAq1evprS0tNeNkUgkEolEsg3ktNp2+d3vfsejjz7Keeed5yz75je/ycEHH8ytt946MJ2jv/zlL5xxxhkMHTrU6QBt2rSJyspKXnzxRQCi0Sg33XRTrxsjkUgkEolE0htqa2s54ogjtlp+xBFHUFvbc3+7rvS6czRq1CiWLVvG66+/zqpVq5xlJ510Eqoq5MczzzxzlxqzN7H4KLArbjCrbDqXrRHGjeWeRlRMGtJ2er67jZjpcaZdALI9QrZuSGSR5+lgYlDI0XlalE3BXHLsIrVHBlcxzCWmmr5MFbM4PoyWtJg6G++vwqvqeDVhMmjW+QnUif2bHkgWu9AiIrBb6TKiUAwwXeBtFI2PeVVQoGNwX1+hXefFsbsXEj7NvxaA6nQO+bZpXSb9fmNKqJnHDV1DVax7tmTry52Blzmnr+bmdZ01AhvMEHn2VGmDEXLMON2KsdXU3G2Vk3ar/RLJnsCNSr2ZdqbuAccexI3BSHcM7GDtea0jSVhu8uzvl0/RHXPb5R2DmL98BFNHi/lln6azsT2XjpSYoksaLhp1Md38WWIID2/8oNe2GnuS98d7mbao09w1Y8SrW27Spka1XTpqkL8NayCDsqVytF1GjBjB3/72N37xi190W/7cc88xcuSuFUbudecIQFVVTjnlFI477ji8Xu9uR4VLJBKJRCLZAbJztF1mz57N9773Pd577z0n5uiDDz7gzTff5G9/+9su7bPXnSPTNLnjjjuYM2cO9fX1rFq1isrKSn75y19SXl7ORRddtEsN2VdQMTFRHUv+aj1XFKO1MS2VYXbhx6ThojGZRcIvzNSayaLU1+Kk+gNOYdSDPfW0m37WJ4Xy8W77GPxqioakGIGZHgtXQtzZatTC1aaRDtrR15aWGfChBxQ6hoBdJ5fs1SqWAkNv33OB2H3JvcMP5pnN4lwM2pw0ZYCgItKVAUYE6jkqvIrr//ptACxToUiJONs+s/lDVHvbjWmVOqMzcbPE1YZul4u5vXLCNtux8XlRYLnsu4u72QvsC6nLkgOTJAamhWOj4VN1RmutALi1FO0WPNE8DYDGZJAvo0M4KVeYquZrHRTZKtLXcpYRP9jDuJBwlN0YL+Cg7AbyCoV5YqvuJ2Ab6KpdHWn3IT6asK1/jZlAbWFmuxZIW/o2tpMMNGeddRYff/wx999/Py+88AIAY8aMYcGCBUyatGtKf687R7fffjtPPvkkd999NxdffLGz/JBDDuGBBx7Y7ztHEolEIpEMODJbbYdMnjyZ//3f/+2z/fW6c/TUU0/xxz/+ka997WtceumlzvIJEyawYsWKPmvY3kZXo7DL1qymWhfxLJnUTtNOye86ThoebCBmeFibKAJE/IqBSto2gVwQG86JWUJ18KhJDvNtpEbPAeDz1lKiuoeWuEiXLSxrJrFcqEqKqWD4TLyNYj/xQRaqIW76aJmFGU5jbBFqVXidEJb2J9bpQnnTsGgyRYxWSEngdaUZ6RVmjW4lTUM6TG6uGM02N2WhqeLTuaLyTTalNSpdnfYLRVo7nkypFtPPH2uPs4/WsNXxq2YfQSoiRoz1L47hmQYRf/btgoV9f7ISyW6ivi3S8RsMWJgYRo4mlI+E5eYLW6n2KTork4N4v2G4eA8WR2evJEcV24bUNK22MepoTz0N2evw2EWXt2gpSrxtHBUUMaifxcvJs5X1g9xb6LBcjjHl9mwGJDtHOmRvn88++wy32824ccIE+MUXX+Txxx9n7Nix3HrrrXg8np3sYWt6bQJZXV3NiBEjtlpumia6vndIjI888gjl5eX4fD6mTp3KggUL9nSTJBKJRCLZdaw+euyH/PjHP3YSxNatW8f3vvc9AoEAzz//PNdee+0u7bPXytHYsWN5//33KSsr67b873//+y7P7fUlzz33HLNmzWLOnDlMnTqVBx54gBkzZrBy5UqKior65BgPVx3P10uWACLGSMNy3BfddM6zF7raWREfTKvuB8Cjpsl3dzilSNrSft6PHQTAYHcrCdNNzLaqj+oefFqa4TlN4jgofJkrRnmWBmbAwF0l+raKqTj3vGIAioUxVGReZX3gwvvS/ts5zFc7i0RuTiscaitHnyRKyNOinFshzv2Vr3fa/peubyKkptmY7pTUAmrKMeuMmH6OyhWlR4pXtXHb4tPJD4njVK8v4Opj/sO9b50GwP8M/5S2tFD3/m/L4UBLP52pRCJUS4Bht/QshnDNQ9O4ovi/gFBa811RamzVu9UIOOWJTBSa01kclC2U0sNC6/mso5yL898HRNZZJlvty9gQRvtr8dqljo4OraRIaydlS9RlngZGesR+PLaWru2/szmSvYBVq1YxceJEAJ5//nmOPfZYnnnmGT744AO+//3v88ADD/R6n73uHN18882cf/75VFdXY5om//znP1m5ciVPPfUUL730Uq8b0Nfcd999XHzxxfzwhz8EYM6cObz88ss89thjXH/99Xu4dRKJRCKRSPoSy7IwTdERf+ONN/j6178OQGlp6S5X6+h15+iMM87gP//5D7fddhvBYJCbb76ZQw89lP/85z+cdNJJu9SIviKVSrFw4UJuuOEGZ5mqqpx44onMnz+/T45xwtIOjgi8jNueb1+dKqEhHXJijgwUJ4PKrRhEdB9BTWQ5eNU0pqWQ5xLeIgnTTXWyM3ZJwyJuz+sX+GIEXEnWRkTZkkNya1k6XljVW6aCx1IQOhVoSTDFU/y1Com0h4rr94/stG1xU8UUAG5f/yl59rVtN110WG4KEXFDh/nq+CRR4mSvQWfRWsNSqUlnOSNdj2LgQ3de52tRcnwi1qLZyOJHYz7g/SYRcxYencCn6mgJ8Xkf4ttMuymUQZ+q00jv57Ylkv7i9TN/i24rolXpbDpML5tTeQBOGQyAunQOAH5b1S50RWh0h/gwXgnAxmQBC5rFbEEk6aM9z8e0sPAbO9jTQKvpps4Q6qxP1UnY2Z4r9HxKtDby6SxZItk1FPog5qhPWrL3MWXKFG6//XZOPPFE3n33XR599FEA1q9fT3Fx8S7tc5d8jo4++ui9srBsY2MjhmFsdTGKi4u3GyyeTCZJJjtr6UQikW1uJ5FIJBKJZO/jgQce4JxzzuGFF17gxhtvdOKi//73v2/TObsn7FLnaH/izjvvZPbs2T3e/q1DghyyxkfYdlOu17MxUJxR2MctwzmrSGQt1eg5JE0XYbfYVhQwNNBthSLP1UHMVorG+moodTVzx2YhB6pYvPPRIYx4Voy4Xrm4EMUtjhHKjuPSTDrCIlMLC2wxCiXNfq0adeWmiincvv5TAFKWxga9gA26GFqdFNiMT9XxKZ1JAvOiowD4TvanLE4OYYhbxAcZKFSl8wjbBTkNVIKK8GkpdTdR4mpjcEkrAO2Gj5TlovJqoUS+fOwEqmM5AFwy5F3GrPI6MWUBJYlP0SlxCRWq1fRQ7upsz9lDt/7SPr/5IwCWpLzOMunILcnga4BUDqx5UPgRjbj8o+1u23bedEzrA0c9DapJNMVkUmAjAKuTxdSnhdqjYpHnijLCJ2L2QmqCXFcHlZ4tgFC5rx72mrPvIa4IATu20kS41dfpYl8hLcG6pIjvzNZiNCtZLLML2P5wlagWUOJqFW1SUo4SLNkJMpV/mxiGQWtrK++99x65ud2rItxzzz1o2q6la/eoc5Sbm9tjF+zm5uZdakhfUFBQgKZp1NfXd1teX19PSUnJNt9zww03MGvWLOd1JBKRRXMlEolEsnchHbK3iaZpnHzyySxfvnyrzpHP59vOu3ZOjzpHXSO9m5qauP3225kxYwbTp08HYP78+bz22mv88pe/3OWG9AUej4fJkyfz5ptvOvXdTNPkzTff5LLLLtvme7xeL16vd5vrtoduaU58yihfLRtSBY4a5FJM6u0RVMzwUuyNMMgj6qd5VZ2k6Xay2UxLxbBjlT7tqKDD7+X4PDH99/sVx+BpUUkUiw83XBChPSJiWyKtAbAUPGOjTptiNSJjakcjyf0Zn5pmtLeORQnRsf0smc1ET7NTA2/GlxEnE/CTRDkftI1gfFY1APV6mJXtxZxdIq5dvhZ1YiZ8io4OhGxVKV9rd+IzAP4n/2OMfDFwGOmO0Gy4qLZjLzyKQYMR6tbGmrRq79fgH5s/Rrezeb4/dPp2zy1TA04qSBKgx//gokMVZrxxBVdPfxWAIwJryFcTvJ8Sqs5U/1o+tWOK3EqahOWm1RC/I/laO6cFV9Bu/659O7SCOkN8J9bqheRYcQJKZ7xfxu8NRBbcytggQGTuds3QrUrmE9BSaPZ9v8H0ctqX4vcxZnp4Z5x/16+L5IDlkEMOYd26dVRUVPTZPnvUOTr//POd52eddRa33XZbt87Gz3/+cx5++GHeeOMNrrzyyj5r3K4wa9Yszj//fKZMmcLhhx/OAw88QEdHh5O9JpFIJBLJPodUjrbL7bffztVXX82vfvUrJk+eTDAY7LY+HA73ep+9jjl67bXXuOuuu7Zafsopp+wVqfLf+973aGho4Oabb6auro6JEyfy6quv7nLE+rZ4dOQIJ/NpXbKIwe4WxzsE4MUaUXdrQl41XjXd7b2ZLDcAFLp5HrUaAWf0NXXIRt5uGcOmAqE0DAvEibYLFcm71ofpBr1MjL4CoSSpLIMDka6Za6PcafBtAqBES5KwYLBLxBU1pENk27E/U/3rcSuGc60/jZRxbsmHJCwR/xVSk04sWMT0oSkmQVWMkpuMLAxLdWInliSGkucSHki6pVHuanVGxSlLQ1Msx3m72QgQsGOZUmoajBQR+5i3r/+0W2ad1qUmVUZdzChImmJyS8Xkvrh8kn2Mood7Hk+Yvc5ED7pZHBVq6qH+DfgUg41JkQFb5m507nNVEf8KMvduoRal2XRTbaukMa3d+b6E1Tgb9Hximsie3aAXsCRWysKmoQCUh5qZFl4HiIy4FfFBRIxORUg1LTbpImMuR4s5qvvGeD6jP00zJlgDCAX3zweV9+Lq7N9Ih+ztc9ppwnfum9/8ZrcQIMuyUBQFw+j9/8ded47y8/N58cUXueqqq7otf/HFF8nPz+91A/qDyy67bLvTaBKJRCKRSPYf3n777T7fZ687R7Nnz+ZHP/oR77zzDlOnTgXg448/5tVXX+VPf/pTnzdwbyVTff3na1bSkA4TsJUFj5omac/NL2sr4ciCdRS4hD2AT9XxKIajHjWls4ganQFj5Z4GNqVEB/O0vMVwCAz1tQLwacswzKTYbyrXgsIEli5GXJV5TSS+1VkZ/kAkoyBlFL1Ww0++1oFpqzFdlaK6dIhWI8Chvg0AnFM0n9HuJtbade2Cis4nSTF3XWh/dpkaUx7F4NnRgxzlqNK7hRJNbPNlcjAGKo9uPh6AaXnrmR5c7bSxyQih2tuapoqpKE7sWo6WoESzWKaLuKivKkOz1y90FCSJpCekgipmRZw8j1A2E5Ybt5JgZt7HALSZ8EGm8KKlUeFtcOquaViE1DSarbxuSOeTsM3UEpabzak8FhriO9KYykLFYkyOSIQ5JFjNSG+ds58h7mZeahHxckeFV+FTdTakhHrVYXo7YzBRaNX9fNYu/JQOC61Hnyueu0/a2E9XaR9CTqttl2OPPZZEIsHixYvZsmWLYwi5O/S6c3TBBRcwZswYHnroIf75z38CMGbMGObNm+d0liQSiUQikfQhsnO0XV599VXOO++8bbphD9i0GsDUqVN5+umnd+Wt+x23rfw6P6ycT6MuspLGharZGBXxRzmeBMdkrSBfzVTBduFT0rjtkZKG2ekzovhY0DGcf1eJqsLTSjZQ5m9mUZuYx29PeZk+RtT7yvXE+LC2At2uDeZSd7+XvL+QZ498Y6aHtXqhs/ylsV1TPMWo9SU6l/2pah4j3a3ivZbKx20ii+eI7DVsTuU58UqZkfWaRGcM2/vjO7MdH974AUs3Dgag2N/O9OBqQqqIMzrYU4Mvk9FjeklZGjriMzQthVbTdNzVb173ue2LJeiqGkkFSdJTzEYvIU34rCUsNwlLJUcV91gKBa8d81jsijDSU4fPVrWLNQMTBdWOmRzsaqXGjj+qdDUw2NXCP5qFWjvU10KRu9M816OkWZYQvkZlnkaGuFoZ7Gux99NCvhanwxTfmXbD53iRuRSDFiNAyhT/ljan8vifoZ8A8NK740kcW9cPV2jfQcYcbZ+f/exnfPe73+Xmm2/us/jiHv3K9tY1ur29fZcaI5FIJBKJRNIb6uvrmTVrVp8mXvXYBLK2trbHVe2HDBnCF198QWVl5W41bl8g5/TVrFxYQqlPmF/maDEn0yhtqbzdPtZ5fXp4Ubf3lrraaHWLlMNSdzMGKs1Nwu+mNjubUl8zOR6hVBR6o3xQLeb4v1GxFE01nU8vevSW/j3JfYhflB8GwCGfaYz211JrxxE1vTSKbJ/wKioPNbN5apSjF3eWjbl42FFf2ZMYEBjLVTTFZFWHMBEdExRVzLuqRV25rOxIRvAZABOXNZGw3AzWxBhERcG0lSK3kiBhqXRYIo4jhUadHnJG7gE1RcIeQZtfGcOYqNywbrHz+s7K8T25NJIDjJy1CSyXj3njhwNQ4GpnUXwYJ2YtA0Rs3VifyAzzKSlazQBuuzbhWj3ARG8tGW9hDZOR7gYAdEtlo17A4aH1AIz21uBT0nyZFIppmxFA7SJRBJW0E+/3n7ZJW2XwFruFz1GlX0yJtOkis21DLJ/NiRwARoQamP/fEYROXdM3F2dfRDpkb5fvfOc7vPPOOwwfPrzP9tmjzpFlWfz5z38mKyurRzvVdX3nG0kkEolEIukZMuZouzz88MN897vf5f3332fcuHG43e5u63/+85/3ep896hwNGzasV5loJSUlWzVuf2ZFpBi/JjqEUcPnxITUdYSo6xjljKK8qs6MrKUYdoaITzEodTcBsDZVhKZY+LOSne8NZKPZ762OZZM2xH5rE9nEEh5C/k7lQ9KdpYcabJ43lk3tOQAcO3gN7WmRGfhxTRnnf/kRSTv7ZmM8n7X3T2D4lfO32s+6RBFeReeCwvfFe2MjdnrsezcIp+13YqNoNYJ8d+gYZ92Tmz5wnmtYeOyRulsxaQaq0yIOqtzd4PgjGZgYlurEJ91ZOd6pKWegdMtkky7akgzxQg++ZpPlG4Rb9fcHfUJTIsSShIhjHOJuptwlfn+qjWw0TOceK9GEmpPoEt/msxXwdtNDpWcLpS4RPtFqeyV1xbQVimYjiw/SYee71qwH+bxhCEeVCB8kv6aTsNXTmOnBq6bZFM0BIG1oNLcLx+4fjp3PmLw6NvfFhZHsdzz77LO8/vrr+Hw+3nnnnW5eR4qi9F/naMOGDb3esUQikUgkkr5BBmRvnxtvvJHZs2dz/fXXo6p9k7CyS9lqku6cVLTcyWJ6u2U0HSkxknKrJopiYZjiw3qpehyDy1s51Cc8cjQsJ2tjiLuF96KjGZwjRmxrNxWxzJOkwCc8SrLcKaYMEe7P0bSXLF+S0nArkImOkXyV1qMaGTJPjCAK3FHWRUWW2nFD17AuXkiunYGmWyrqoBibbjkCAE8b+JrFr8jzn6YpK2/g3xtEFqHvhWxi1ygMPU34rhT5otRNb3OOOW1RmndiowCoTeXQku5uY99giJG5qli81TGaco+Isxjr2UKeFmOLXQsuYbkp1MRnP6ts+3XXACpdCfQuWW4gFSQJBJ//iI23HYGrTvzGJEw3hwY3OI7Un8XLOS1rCQD5agcJy+1kjrkVg5ipkbKVpBw1hW6rQQFVJ4ekk1n5boe43wttJSmkJRx/sKZ0Fpv1POd70JQMMjpvC+W+JntfSScmc2O8gHxPlEEBsZ+ajjChYMI5nzJ/M5vZWqU6YJDTatsllUrxve99r886RtDDbDWJRCKRSCSSvZHzzz+f5557rk/3KZWjPuAPL5yCWSlUiJK8CIOzxKgpqnuI6x5n/t1Ia9ToORzmE6pDVTqbOtvnqN3006IHaIqJEVZRUQTTUvCoIu7koGANW1LCS2lVexG6qdGaFDE0soe7fSJHiQybPz15FIUF4nMZFapnZXsxK3WRffmtQV+w0F9KNEfEN0w99Usno2ZB/TDq20KYK8W1N4sgOiLNcYWrAKhJ5NLVfSXP1eGMzBdOVOArI906Q+zHrRhsSuY7tazy1Cgj3TE0r8ge6jA9JCzx9dz093H84dD/dfZxe+UExxH85nWfsy7to9QlMvFGumNsMjzMXr8Q2NppW3JgUXbzhzRfJBTRl7aM58rS19mkCxf+Sk+D47nmU5JA0qn1l7BchNQUYYRHl2lBh30//l/LVC7Nn+ccY0bWl1y97jtMyhURQWP8NY4iPtyzhdoudSdjaTeH5653KgoYqI7zdtgVZ32sgE/XDwOgpLCN4weL7DRtf5U8ekMfTKvtr5fRMAzuvvtuXnvtNcaPH79VzPN9993X633KzpFEIpFIJHs7clptuyxZsoRJk0QowdKlS7ut6xqc3Rtk56gP8ESAz4TqUDdJoWCoiBXpSHk5tHATS5qF/4duaLy4aQJnjBV+Rxv1AlbFhX9Oua+RddECDi4QOsQhoWqgc8T0eaSUIq+Yiy/yRYkkfWxuyQHgoqXLmXtIz2wWDlRGnr/QeS6icuodxW31wmLyAjEiOUK129iey3HFoiba2RVbeLdxJBs+EYrPIWes5Ecl71KkRQG4t30G2KNrgFcOzt5hOzI1+QD+Z0W1E2/RagbYZKT5R6tQhCYFNhLShBo0YVANa1NFlHsattrfbZWTuGndIjQ6fwAK1SQ1XaqgSw5s2uwEy+aqwXQM8TqeQ24lzSZbuc7TYgQV3fHZ0i1bubRfZ2qtAZybN58OS3Oy1zQsvjfoUz6MiAPVu7LJtmMw87UoqmI6DtpnD97E5lQehv3tMy2FBW3Cv+3DNZWotV7cSXEv1xoK85VyAKYUVGFaKl2/axJJhv4oPLtLMzLvv/8+P/jBD5g+fTrV1eKf+F//+lfmzZu3k3dKJBKJRCLpNVYfPSQ9otfK0T/+8Q/OPfdczjnnHD7//HOSSTF33NbWxq9//WteeeWVPm/k3k6oyqRtuOhnujxpAi4xuqnIbu7mFLstMusP9laTMyhGje3oXOhqJ2G6idlz9yubi/AVikyS5mQAn0tHT4qP7+PWCkCoCqt/L4r/jvzpx313gvs5yyancbORkXRW/n7id8cAcPFxb3Ni4QpeuUs4Y//oEiHZXl0+zd6yrdu+xi7s/pUa6a/nxbH52zzu2kQR2XasUEM6xEMjRjnrnnvq29wx7QUAvlf0Mc9tmcpBWaLq+Q9XVfH4QcOcbW+vnMAzmz8EwLAsNAXKXSLL55nNH3L20CN6diEk+yUVN4h7Y/M/DuGj6AgOzxIeQwnTTcTOpE1ZLsrdzbTbnkUNRpg8NeoMn1ckSxyn9oCaxKfoDLc92uqMLIZ7tjC5SHx/vkiWOop4vZ7NUE+z42W0Kl5CQOtUf9pNH0u2CB+mwFIfsUMSUGtn8A5qQbF/H5e2DkL92qZ+uDr7DjKVf2DptXJ0++23M2fOHP70pz91C3o68sgj+eyzz/q0cRKJRCKRSCQDTa+Vo5UrV3LMMcdstTw7O5vW1ta+aNM+R+jZj2i6Q4zOcwMJgrZyFNSSrIgUoxuas61pKTy05QQAvGqafLeIT1Ixqdez7Xl1wepEiTNX37whB2+xGJm5VJM8b5xNbhE7UBFsIlO1TcnSsczuAWgnLO3o9vqtQ7p770i2ZuTPhMt1YpGbXFfn9VuZHLRdJWjsQhempVLpFyqeV9V5ZtNhTF64yX6dptquFbVleist6YAzinYDxy2J8844ESs04rzPeByhDq1+YjL+UJJpo9dtt71d1aEnN32AexeDECX7L/HGAC+5D2bYSKH4jPVWs87O2Bzmaca0FCd7NlMjMmYrSZv1PAKqfa8qBrrlojXj0aa141YsOuwszRo9x4kpcqtpStytTvZaZn9RQ2TaPr/hUCJN4vcoywArraJV2N5uniQtcRHLWV2fywgObOVIMrD0WjkqKSlhzZqti//NmzfvgCg0K5FIJBLJgCNjjgaUXitHF198MZdffjmPPfYYiqJQU1PD/Pnzufrqq/nlL3/ZH23c61nz4DQsj10Hy1JoSoqRUK0RpjEWxK2azrampbCgvgyAQVkRDh0k1KCadC6jfDVOjayY6WVCYCNVKeHqjIJTBXu9p5Ck6aKwUmSvLWkdBIjA+KxwAp9bJ/BesdjPMfVE0z4K3CK7qsAVAaRy1FM+muACCpzX21ONQMQXxUwvzbYbcNz0kEq7WNYm4i82t+Q4nlfDaCVuuKlLipG6bqm0pIJA09b7vUBk2r1CJhNuxxlx55ce2ZNT61Pu3fAR1YZo1/3Dx+xka8meIHuJi46WPF7JEW7vpUOaHEfslKXRYXmcTLagkmKLEeKtyFgAAmoKU+scS7/TNIrhWcLd/ezc+YSUNLr925WndThu2a1GgA7TyydRMXAe4m3BrRhOrbWD8+tYZNeMjJRrkNDIKRZxeKpisWWT8EgqHNrST1dl30HGHA0svVaOrr/+es4++2y+9rWvEY1GOeaYY/jRj37Ej3/8Y372s5/1RxslEolEIpEMIHfeeSeHHXYYoVCIoqIizjzzTFauXNltm0QiwcyZM8nPzycrK4uzzjqL+vr6bttUVVVx+umnEwgEKCoq4pprriGdTnfb5p133uHQQw/F6/UyYsQInnjiif4+vZ3Sa+VIURRuvPFGrrnmGtasWUM0GmXs2LFkZR24PjtKfhLNJdQhv1snZccYpa2t+56WJbYBCLh0JzvNp6QJGAFnrj5fi5K03I7bsrc45mR85Lk6iJkeJ9PtG8WL+b/XhT9OycnLHNUIoGJBgBXRIIdmi3pujXbtLsnu0fSSyCw7dvAakqb4GrWbPpKmm1VRcf3XtOZTEOggbWcEKYqF12V0209mtG1aKiF3guaBOoE+RlUsgor0oNmbKXr4Qxp+egRVG4cDcOXXinh40rMANJtZNKRDhFSR5bjKCNBmBCj3CXVIw6TdFHFCbsXg3JIP+VejcF9fqxcSVuNsSBUCwvU6ZogYo5He7v8oNyXzGemrQ7U9kpY1F9O+0Y5zqmglpWt8Z5hwInu/aQQjf7ygfy7GvsoAKj/vvvsuM2fO5LDDDiOdTvOLX/yCk08+mWXLlhEMCnX8yiuv5OWXX+b5558nOzubyy67jG9/+9t88MEHgHCuPv300ykpKeHDDz+ktraW8847D7fbza9//WsA1q9fz+mnn86ll17K008/zZtvvsmPfvQjBg0axIwZMwbuhL/CLptAejwexo4d25dtkUgkEolEsi0G2CH71Vdf7fb6iSeeoKioiIULF3LMMcfQ1tbGX/7yF5555hlOOEEkGT3++OOMGTOGjz76iGnTpvH666+zbNky3njjDYqLi5k4cSK/+tWvuO6667j11lvxeDzMmTOHiooKfvvb3wIwZswY5s2bx/3337/3d46+/e1v93iH//znP3e5MRKJRCKRSPY+2tqEp1teXh4ACxcuRNd1TjzxRGeb0aNHM2zYMObPn8+0adOYP38+48aNo7i4czZjxowZ/OQnP+HLL79k0qRJzJ8/v9s+MttcccUV/X9SO6BHnaPs7M4AUMuy+Ne//kV2djZTpoipnIULF9La2tqrTtT+hKJZpONiyqs5GqC0pBWAxoSQHjNBuKpioSg4pSnerB3FYTkbAGGslrDcjqzdZGQRMz0U2IGNl46Z5wQxelUdA8WRpquS3YOEY8fUO9M+47Or8appZ1vJ7jN2oQu3Kj5Dw+pMmW/RgyxoLKOuTUxdJtq9HDSqgbqYKD2SG4xTHhYTZ1sAt2JSGxffraZEgIpQM0cvFqaq74/39nm779rwMe2mj1ZTpEc/PGJkn+07RzXIUdv7bH+S/iFclSaeL6bq3R+FeKVyAgBFngh5WofzO1GkdeBTdacobMaMFqA2lUPSdHNUjvgOZMxqM9P+GxIFNCbtMIuwKGKbmXpe1V5EzHA7dhetkQCWW8gZWd4kUbxOGxLHdi3pLOnLgOxIJNJtudfrxevd/m+OaZpcccUVHHnkkRxyyCEA1NXV4fF4yMnJ6bZtcXExdXV1zjZdO0aZ9Zl1O9omEokQj8fx+/dMKaQedY4ef/xx5/l1113H//t//485c+agaeJLZhgGP/3pTwmHZTyLRCKRSCR9Th9Oq5WWlnZbfMstt3Drrbdu920zZ85k6dKlB1SJsF7HHD322GPMmzfP6RgBaJrGrFmzOOKII7jnnnv6tIH7AtqaAMYQEYyq6y6WN4lesFs1sCylW3ffsuhWdHF+i0hx/dmQN3ilbSIN9ohreKCBmmQ2ZX6R2u1WDEdVAvApOltSYWddV2KvVTImLAIhq+J5DA800KILFSuT0i/ZNdY8OI2c+BrMLoVeM8pgbTSMSzNIbRSfYbBO4bPQUPKyRBHOAn8HIbusx8jFKdbHwkR1T+e+2woo8IrPZ/BHQWqmdR/d9QVbjBBthlCOvreijudGl/TofX+oEj+KPx521DbXX1i67eWSvQtXhwEF4rfbFYMX3zkcgKzhrRw/dDXHhlcA4jeqSGunVRH3SrOR5RTBBmjUsxjtF/dn0nJT6GqnXhcq6LK2EqIpoUIEXUkOCVZzqK2Q57tHENISvNcsVMtgIIkrJFL3m9qDHFTY4JhNSvqPTZs2dRMzdqQaXXbZZbz00ku89957DB061FleUlJCKpWitbW1m3pUX19PSUmJs82CBd2D6jPZbF23+WqGW319PeFweI+pRrALqfzpdJoVK1ZstXzFihWYppy6kUgkEomkr8lMq+3uAyAcDnd7bKtzZFkWl112Gf/617946623qKio6LZ+8uTJuN1u3nzzTWfZypUrqaqqYvr06QBMnz6dJUuWsGXLFmebuXPnEg6HnYSu6dOnd9tHZpvMPvYUvVaOfvjDH3LRRRexdu1aDj9cjDo+/vhjfvOb3/DDH/6wzxu4L+Cvh5TdoTZNBcM2NbMssCwFzZ5Dz6gNyyOdo3WPKlSf1ckS1kYLGJklbiJNMclxx2lLi5Hbxlgek8LCPj9bi6FbLqdo6bLoIPwnC4PI0Z96qEtEaE6K9xV4Rdp/Rl3yqnr/XIT9nNVPiPg6SzdYXDcIv1dcx0ibH7NdqD/uFg3TY+GOis/ZHQPXOyFqxovRT95BMdZHRXxYR9qLiULMVo6iCS9jC+sZ4hVmd2lTo6YfzqPd8JOyxNdeY+eDmQc3iqKlmdIQkn0b7e2F5NjP286bjq9R3Kt6cy7/bhtPeIJQNr8e/oJiLUGOaas66Swn5tGtGOho+OzfEh86biXNILe4d79RvJiVMVFMttDTzqH+DeSoIpZumZZgQyKfHI9QUyMtw5ypnkkjqjipYBkepbsHjsRmgLPVZs6cyTPPPMOLL75IKBRyYoSys7Px+/1kZ2dz0UUXMWvWLPLy8giHw/zsZz9j+vTpTJsmCnOffPLJjB07lnPPPZe7776buro6brrpJmbOnOl0yC699FIefvhhrr32Wi688ELeeust/va3v/Hyyy/v5snuHr3uHN17772UlJTw29/+ltpaUal80KBBXHPNNVx11VV93kCJRCKRSA54Brhz9OijjwJw3HHHdVv++OOPc8EFFwBw//33o6oqZ511FslkkhkzZvD73//e2VbTNF566SV+8pOfMH36dILBIOeffz633Xabs01FRQUvv/wyV155JQ8++CBDhw7lz3/+8x5N44dd6Bypqsq1117Ltdde60S8H+iB2KYbvFVCAUiWWbTbqk0oJ4ammY5ipFoiW62mXVwvRQGfJkZfrzSMY5C/jahtnqYqFpviuRR5RQZQLO2hOpkDgNev06h3mm5umd7arT0lvghlfmHetiUVRsN0Yo2qk7l9ffr7PasfnQqmHddlKSQbAqTbhTroSih47NAgJQ3poEImMdBSwPCCr0Z8zdbmFeD1iM97ZVUJx45aTVwXo3FVNVndUsBgfysABn1fOPa68qlU/X0ct094EQCPYgBF29z2W8sbmejbSLtdKDSwlyiOt6//FICbKqbs4Zbs+xgeBa/tOmq6QFvk46Oh5YAwmh3r28w4TysAE31VvB87CIDmdBCfqjsZbB2ml3ZFd2LZTggu57Ss5QDolkKH5WJFStxnC9rKOSRUQ008xz4wqK3iO1AebKI6mUuuu3uhbMmewbJ23pPy+Xw88sgjPPLII9vdpqysjFdeeWWH+znuuOP4/PPPe93G/qTXMUddycxX9jcbNmzgoosuoqKiAr/fz/Dhw7nllltIpboH7i1evJijjz4an89HaWkpd999d7+3TSKRSCSS/qYvY44kO6fXylFFRQWKsv1R7bp163arQdsiE+z9hz/8gREjRrB06VIuvvhiOjo6uPfeewHh23DyySdz4oknMmfOHJYsWcKFF15ITk4Ol1xySZ+36asERd1XVN1LZso8OtiFb0gUt10yQlXFnZnpkGuqxaKGwYCIVdrcns2InC7Zaa4EgzzCeKvOFWaItxWAPC3K0zWHk33a6q3a0ar7KQ800agLb5244SHb2+YoEfXJMND3WVD7NWkFEDE3vkIRK5FKiew/V0whUyVGM8H0gD5CxGnEom6UpIrlEVKS1eIjbon4I2+9i3etgwjliP25XQbRmJeOtBiNmyhkvS+yf6JHdwYz7i7DvrMEzxpxP14+738Yyafb3dawVOjijzWrbM8GSEr6lrw/f+g8r7/8CLQkrF4xBIB5niTefJ0cNe5sk8mOXRst5MT8ZYTsdQE7niijHH0UryRHE/d1SIujWy6WxkXqeMJwMz24mg+bRJYumsUpx3wG2HF4msK6WKbQsyw2240BnlY70Ol15+irrpW6rvP555/z6quvcs011/RVu7pxyimncMoppzivKysrWblyJY8++qjTOXr66adJpVI89thjeDweDj74YL744gvuu+++AekcSSQSiUQi2T/odefo8ssv3+byRx55hE8/3f4otK9pa2tzbMwB5s+fzzHHHIPH0+kbM2PGDO666y5aWlrIze2/WBtLg4zVUNZmi2S2UGlC61SSLWGSB4u4IZ9HR1Ggfa1oi788gmmKbS1LIeDROSFPzNW/0TTWiUcCGOJvoy0tVAfd0rapGgFsiuYQcido08W2IVeCdsPnON3uyDtnw3MTSKc0Rpz72S5dh32dqtlHOM/1bKGYKGkF1bAwA+J1sjaI5TNQbfHU9IBpf0xJHySL02Tbvi1tuoZlKmgR2yw1ywSfuFEMv4WVUmlvFaNtFAtVM/mgWqTLDsttcfyTwvMKiRzVsMvnteavhwI4n6vjjP377Weg/WtMAeVrG5yR5i0Vk3f5+H2JjDXqH4of/JDWC6YTWiXuiS+LSnApJqECcS+P9tZRkxRK5hfVQ1jXlkdltghYmlGwFK+iM9QjVO9ViUH8ed2RgHC9HhluZLCvFYDTCxfjU3SOLxTV3dtSPnJdQmVqsTNzM3GWjf190vsaUjkaUHYr5qgrp556Kv/4xz/6anc7ZM2aNfzud7/jxz/+sbOsJzbl2yKZTBKJRLo9JBKJRCLZm5AxRwNLr5Wj7fH3v/+9m5LTE66//nruuuuuHW6zfPlyRo8e7byurq7mlFNO4bvf/S4XX3zxLrW1K3feeSezZ8/erX0E6ywn7kQPKmQsYaJlJlllEUcBSKbc6LqGu1Rkjum6RipmK10xjcKDG3ijSRhjDfa3oioW6+IFznFcbqE6vDNu+66h2d4En9QPw6UJpeOcYQvQLRer45mspGS37av/eXDnCx0so8/6y/scmTJpWhJ89eI6GF6wVAU9sy6hoDW7HWVJD5kopthWMcBX66JVtbMRdQUtrmKEbBUqpaDYNfgwxWvsj99T5cX0WHQExYJVcQ8hW4HKym3arfO6avJcAKo+z+fzSZ3LR/704x2+7/7hY3bruJJ9C8UAb5sdFzk/xPJjijgpX9yvCdPFogYRj6Q3+mjbEKD1MKH4rIgP5tDgBoo0ofhsVAsYkSt0n03RHOKGm+XtwvdoUF4rdelsyjxi/fHFnQp4iSdCxPBTnwjZS9r694Qlkh3Q687RpEmTugVkW5ZFXV0dDQ0N3fwNesJVV13l+CVsj8rKSud5TU0Nxx9/PEcccQR//OMfu223PQvyzLrtccMNNzBr1izndSQS2arujEQikUgkexQ5rTag9LpzdMYZZ3TrHKmqSmFhIccdd1w3hacnFBYWUlhY2KNtq6urOf7445k8eTKPP/44qtpd4Zg+fTo33ngjuq7jdovRzty5cxk1atQO4412Vo24J4T/dz6tF4hMHksFs0soR3t9Fp48uyaaBeq6AHq5UAQsU0HzitQ2I6myZFmZUBMAK0enfHAjuT6xbVT3UBcRikQJy7bbli2xLHRTI5oQ55Sw3OiWtlX9tQyK0pk9V/69Rbtw9vs+LRdOJ5mtOJKzYnYmaWkp8Xlm1pkuUDU6ZSbFJO0XK93tCloCstaKr5XhAT3bwtUmbgjTZ+LfYjsSh0BNa6TDImBpzLFrWfXacLS42DbhcWMGxX3jUkzir1c4Lui9pdMdPU3FgjCFHjHCXzBRul5LOlENyNhreaLQGvU59Rw1xaQtImKCglUaegjW1Ynf7ix3ilJvE0NcIrtssLuVWJb4/UmbGmvaCkjbivSMfIMO08uiWBkA/i511NbH89nckYNLzWRISuWoK30xLSan1XpOrztHO6rc219UV1dz3HHHUVZWxr333ktDQ2dwakYVOvvss5k9ezYXXXQR1113HUuXLuXBBx/k/vvvH/D2SiQSiUQi2XfpdedI0zRqa2spKururNvU1ERRURGGsW2FYneYO3cua9asYc2aNd2qAkOni2d2djavv/46M2fOZPLkyRQUFHDzzTcPWBp/KiSGXGl/Z+aap1VFS6gk24UnTs5yhdYxFkZcXHYlrWAY9lDNb6C2up33qr40mz4fTPY04RvlUk0Mc+euybU1uQRz40wcJIyX6lI5ACybvO16RSFfcpvLDygsW8mxB7GKCRlDaEMFLYGjFLk6FNIhy5GnVV3FFRPrFAswcUbfrjgoloKdhCPctXPEU3+D2DaV8gGwpKGSYAdOikQqVyVSJ2IvVmsmYW+C45YIFXFHMWc7wrQUXKqBV83cC1I5knSi6hamZtcF7LAwWz3U6EJ136TnUZQnklVa3X5cHYDt35bv7aAtHWCDLuIjVUzH6T/fGyVlanyjSKjSm1N5mCiENXEv+1SddkN8B/yaTlMsSP7XVw7MCe9ryGm1AaXXnaPtWYonk8luafR9yQUXXLDT2CSA8ePH8/777/dLGyQSiUQi2WPIztGA0uPO0UMPPQSAoij8+c9/Jiurs7aXYRi89957vY452p8o+p1wm02dehhtlW5neTIf1FKR1dGY7UGNayi2WqQmVLCfKzGVdG4aLWKrSqpFoFZx6rDppoau7/zjCqzxEC9w86U9b19W1kxzKgjEtrl96NQ1u3C2+xfJbAUUnCzDtBsUMZhF1cH0gmW7m6fDllCRusQnOSpSCixXl9c6uDrAb+cJaDrYJsNoSWg7LoZ3iS0rRRXaJ6YILRIDDDPYqcC2rM0lPjTK0+3C42cIX/bq/P4+Rqi8Yxe6yNKSaF1cryWSDJ62NGmfXetPt/DVa6yLi7iiTxqGOcp1vDQNKRWPrZAalkKZt9HxUvsoUslgr4gX+lbeQpqMEOuTnbGlATXFILeITzrcV8XjLcJf7N1NIxj8rd7d2wcSCux2xcW+r9i4/9LjzlEmdseyLObMmYOmdUryHo+H8vJy5syZ0/ctlEgkEolEIhlAetw5Wr9eZMocf/zx/POf/+xXx+l9GcWE7A0ipiMZVomVAjVCHdAssDTLSXQyc9J4NwilQA9buBvdmEPtekW+FGkN2uNCwkh0eNDcOx/xKwZ4WhRiy8Xn82XOIE4tWsp6CnbyzgMXb5tFOqg4GWqmB9IB2+9FEfXTPK0iGCgdFJ5WmbAdV4ci4i8APYxQjTKJbAZk1Vi4EmJfWsrEFRf7iZSpuFYGHCXJ2wJs8NAxTGyruEy8WSIIKpkMYJgqOUFxbzT8ZzSF31jR6/PsjDvbtZglyf5NpMyDO94575LKM8n3CE+2QVkRPv+yHAB3swt9cBLNVqebk0Ea0iFK3cIxO5b2cnh+Z41N3dI4ObQUgCWJoTQbQXx2UN+zbYexcKL4wgzupSJ6wCGn1QaUXsccvf322/3RDolEIpFIJNtBpvIPLD3qHM2aNYtf/epXBIPBboaJ2+K+++7rk4btq5huxVEO0n4FNYmTzWSpYLoUdJe4Q11hHVdcKEeGTyEdMlAbhFJUWlrLkrIciIr1nqBOqsPNznDFRexMJkZm6RflLM0dzAgOzHppO2L9b0SsQ3i9yB6LCRNfFEMoQiAcsk1PZ/aat0khldP5C6OmRUwS2PFHpu0XA1hu6BikkLvK6LY9iM/I09oZA6Ckwd0OrrhY0uFyo9tK4ZARDVTX5tJm/7Kl4m565g4mkfQcT0fnfW14FTxDowxytwLw1MapeOvFvwvTBcRcZBWK7DWfliakJhw1yKOmCalC5SzRohiojMxktgXW8r+th/HHkZ3mvhLJ3kiPOkeff/45ui5u/M8++6ybCaREIpFIJJJ+Rk6rDSg96hx1nUp75513+qst+wWpkIrhtZUiRSGrCjwRcUe2jbAz09Lir1kdcGqyeZtAz7OoGL0ZgMqsRlYUFWPaGSJl313co+MXPSSy5tbeP91ZNuI8qRrtCEsVj64+R13XqbpQjzJocYV00M5e84E7ai9Pi2w1s4vAl/ZBa6X4muWsN5x4s+z1JvF8lbQd/mMGwNsMtuULuE3MlEh6qF5bCAoEC8SBxpfU0tpXJy+R2KS9whEeIBlWGJLbyufRYQCEs+O0FtpfgoBQgTJj5IgupNNlicEAFHijNKRFMF2+GuMwbwuGrZHmqS7eH797FQkOaGTnZsDodZXRCy+8kPb29q2Wd3R0cOGFF/ZJoyQSiUQikUj2FL0OyH7yySf5zW9+QygU6rY8Ho/z1FNP8dhjj/VZ4/ZFDK9CKixGSYEtJlYMDNsQJJVj4m5TsUIi8ERpcTtBJ5YbhpY1MjZbmOIkTRd63IWi7tpQYfiV83fzTA4A7Bie9nLwNSiOz1HXMnSuePdlitXdy0gxwd8gXhhe4YZtm/+SDgIuiNt1j32tKu5ol3glHRR7MG6pQp3KvNfd5HIULMNrYQRMWpqF07orb0sfnLxE0smqPx5O0Qc4v0dt49LQEWTtKqEG4U9jecQN6fHr6HEX0YS4eS0LXm86mLQpxtoe1WC5a7Cz72x1M7bxNiGl1/9yJDYyIHtg6fGdGolEsCwLy7Job2/H5/M56wzD4JVXXtmqpIhEIpFIJJI+QMYcDSg97hzl5OSgKAqKonDQQQdttV5RFGbPnt2njdsXyXliPnVXiCyoyDAVVwLsARWeFkXErqidVdyTubYHTlkHBf4OZz+jAvWoh1gsby0e0PYfSFRcJ9Q1fW4ZtR8OceK/uhQKd3yLXAn7pR2D5G6348bcYGasghXwRESGG4CeZccfZbLMQgqedts/yYJAg0FCFwf1toGepWAbC+Nts7OCgMgIIGhgpcW2K5uLyKelLy+F5AAnf6ELwwPtdsZmqDhKdGUuoRpxb2spjbg99k1VGviyUk7MkdedpjXpI+ASSTujQ3V8LUt4FpW4YngUhXfipQA8W3s4UDdg5yWR7Co97hy9/fbbWJbFCSecwD/+8Q/y8vKcdR6Ph7KyMgYPHryDPUgkEolEItkV5LTawNLjztGxxx4LCKfs0tJSVLXXsdwHDIFGcQc2TALLZWH57OARj4mlq3gDYoSVLFdQW8VHoGkmbUkfalBsGzM9aFi4Tqwa+BM4wHCftJHUX/Nxb/BtewOTTldzN2DhuGJ7I5YTG5T2KaR9XTLOVGwZW7w5UQCW/b3xtlqoaaEWgaiC7op11ncDnEy23IOaaKzJZvSIGgDG5dSyaLfPWiLpgv2PN1Eigus0S0ExFEcFTeZDslj8bqnNHhLZKoGwCJAbnbOFllSAwT4he5Z5G2k1RVWA+ZGRTPBvZG7LWACaEwECA3le+xNyWm1A6XV0XFlZGQCxWIyqqipSqVS39ePHj++blkkkEolEIgGkcjTQ9Lpz1NDQwA9/+EP++9//bnO9YRjbXH4gkbSz1dBMEcfiFdKCy6d3K2vl8ulYaWGKYxgq1c05TCvcAEB1ModFTUMIsA5J/3PQ0HpWtg8FwB3Vuo+wlE7vI0sVTtbBetN5nclkc8VMTLeCHrA//yaIFyrodmKnFge/rSpamogpymTD6VkKWrxTLTJdEBskto2uzyW7NMLwUCMAYS0OSK8YSd9h+MS97GkS0qW6JhufAqkcsd5SQY3Z61IKVouboiENgHDEHh5soMgjHLOztRhhVQTpTfJvYHWqhOXNImUzdOqaATwriWTX6fXc2BVXXEFraysff/wxfr+fV199lSeffJKRI0fy73//uz/aKJFIJBLJgY3VRw9Jj+i1cvTWW2/x4osvMmXKFFRVpaysjJNOOolwOMydd97J6aef3h/t3Kco/L1wqe644wiskAmaUBnSMTdoFh6/mLvX2z0oBWJasjS3DbdmsL6jAIBsd5zADKkaDRQuxUTNFp+FnuXHbfucdvU3AqH+BOvNbj8ymXWWpqCY4ErarxUI1lmowvQcVbdI+zPGVqAHFMdN21IhFe6MV3J1gBEWfli5Je343TrtulipYQHdp7Mlkt2hvcwiuEnBL2zWUA2RtZnJnmyabOBuEcqR4bUwvSZloc6MSa+aJmCneQ5xtdBghJ11H7dVSsWoL5AxRwNKr5Wjjo4Ox88oNzeXhgYhrY4bN47PPpNlKiQSiUQikezb9Fo5GjVqFCtXrqS8vJwJEybwhz/8gfLycubMmcOgQYP6o437LKoO4dUqbZNFH9Qd1ElFPKRiIrDEVxjDNMS69pSXQ/LrOCgohm4fNlUCsT3S7gOR1HG1FLySBcCWAg8uO75CMUFL2K7YgK/FwpWwMG3LX9PVmdFjqUItcpQkWyRK27X21HSnqqSmhIqkxMXGrjgksxUM+z3tBxko9tBlUChCnjdGyC3iOFyqjOuT9C3usihGYwjF/snROkQ2Zcb7C5+BpXZJpfR2FiAcG6ghZnppSQsH94TlJmWnXf5+43FEk15yiAzAWezfyIDsgaXXnaPLL7+c2tpaAG655RZOOeUUnn76aTweD0888URft08ikUgkEomcVhtQet05+sEPfuA8nzx5Mhs3bmTFihUMGzaMgoKCPm2cRCKRSCQSyUCz21UAA4EAhx56aF+0Zb9j2K0fsvaBaYwqE0rb+oZ8FLcJdgHHLH+Spk05ALRUB3hPy6Pm8oz8XLsHWnzgsvrJyVR4RPwcgbTjxmgpIkjalZluSFmYLsUZgbniJoF/frzd/ca+PZXoYDuQ1a/gjonP3vAq3QwfLQXcUbtYLeCr1YiXioMU+aIM8rVRnxSeAB/Xl5HHqr44bYkEgGF5LawZ6yawVAT9mzEFPdhpNeGt8mDYRZIVA5Soxuf1QwCYGNrEUE8zun1DtxoBFnZUAGBYKjmnrx7Yk9lPUSwLxdo96Wd3338g0aPO0axZs3q8w/vuu2+XGyORSCQSiWQbyGm1AaVHnaPPP/+8RztTMpUIJQ7jDl1PU8I2zFfAVefFPVKoQyndBXZpEf96F4Pvmr+nmnnAM3XEBhrtz0l1majCbQE1DemASLMHaBsN+V8o5D7Ws8+q6RANVWTk445AW6WIcPVvsUeCmbhWRTwyo/PEEJ38QeI+casGrbqfurhoRN7pfasa/WBltTiOYuBWRGP/OLKyT48h2Tu5cu1yAF5q8bJ6YwlkzE5ddkmbhF0YO6GS9ovnRn4ay4SkLv59rIsXcohvE0FVZBu0mz7y7Po63pM2DODZSCR9R486R2+//XZ/t0MikUgkEsl2kNlqA8tuxxxJdkyxr51l84YDoGcbWHlp8v8ZctaXPC3Vor2B5iOb6PhvLgBmWnXMGQf99sPd2q85Lkp6jbAISB4SR90gbBw8bYCioCU6t02FIB0Qv16lZY2cXLICgKjhJW54MK3+UWbL3aIsSUhNkLA9C65du5S7hx/SL8eT7D2MdDcDwsQxvyhCeqFIqlEMsFSFlF0YWU2BKyae+0bGyAnEnX2oism6VBGGbZunYfJa/Rixjk0Ddi77PXJabUCRnSOJRCKRSPZypHI0sMjOUT+z/vAY5eye+iAZGDIlDkI72a43lH13Mb53RdHNWNpN3jAx4l72n4MwfJAKi18rxQDDb1EyQqg4RxWtI6CJGI6WdIBlbcWoX+ufUfjtlRMAWPWnwzhpwjIAzi+Y1y/Hkuw9/HrDJzTY9WqGeFtoj/kId4j70fQoKJaF4RZqkWLhqJwdLX6OHLKeYq+IifPZAXqNdoXl98d7pWIk2eeRnSOJRCKRSPZ25LTagCI7RxJJP5M4tg6ASZ93ljL8fFIHRr0fK9tOZYtqqLpKrl8YKpmWQnVSxEC16n58WrrfS80edPEnXLPxAwBSqJyxrAm3XXn3nhfPpOJ6qYDuT4SVFHNjowFImm4qCpqoGiLi44I1FqoOftuXKzpIJXaQuAOLStqIG27H10izzG3sXdLXyGm1gaXXhWf3NMlkkokTJ6IoCl988UW3dYsXL+boo4/G5/NRWlrK3XffvWcaKZFIJBKJZJ9ln1OOrr32WgYPHsyiRYu6LY9EIpx88smceOKJzJkzhyVLlnDhhReSk5PDJZdcsodaK5F0smhS5wi7gkWsu2c6bBFpcZYGltuiJiK8jFYsHga5YqQ+vqyaIYE21vdz+2Z8GWGLIbye1ulFzG8b7mTIpYv6W7eSDDQhFU4IrgRAt1ReqTkY1f6YLUVBMS0s1c6QtAC7GHMyrbElkcUQfysALXqALyODaT2qcYDP4ABDTqsNKPtU5+i///0vr7/+Ov/4xz/473//223d008/TSqV4rHHHsPj8XDwwQfzxRdfcN9998nOkUQikUj2eeS02MCxz3SO6uvrufjii3nhhRcIBAJbrZ8/fz7HHHMMHo/HWTZjxgzuuusuWlpayM3NHcjmSiQ7pfKa+ax+YjIAB5fXEHDp1MdFzIdneBMNDdkAxI6p73fVCKDM00jCEkqWYalMClfxcq3wOsopjA5ACyQDSZ3hotUUvlsrkoM5KGcLn0dFZmW8CEKbQDHEf+OsOgt3XChH+po8mk8yWGiVAuBSTdLH1eyBM5BI+o99IubIsiwuuOACLr30UqZMmbLNberq6iguLu62LPO6rq5uu/tOJpNEIpFuD4lEIpFI9iosq28ekh6xR5Wj66+/nrvuumuH2yxfvpzXX3+d9vZ2brjhhj5vw5133sns2bP7fL8SSU8YecFCAAo+CjMutJniwjYAZn/+dafOVX9y07rusXtrU0XOc9NScZ1YBUBh/zdFMsA0GUFyNOG7laPFyHHHiQwX/zx9TQqGG6fGoGKAp12s87SD9WwB/K9w908PfNMPSGS22sCyRztHV111FRdccMEOt6msrOStt95i/vz5eL3ebuumTJnCOeecw5NPPklJSQn19fXd1mdel5SUbHf/N9xwA7NmzXJeRyIRSktLe3kmEolEIpFI9hf2aOeosLCQwsKdj0kfeughbr/9dud1TU0NM2bM4LnnnmPq1KkATJ8+nRtvvBFd13G7RdzE3LlzGTVq1A7jjbxe71adLolkoKmZFuGM1VvQ7dpmYwbVk+MRo/rtTwrvPnXpbHI0UUE9pCYocbcCoFsuTBQgqx+PLtmTlLvb0Oz0pUWmh6pYHt5mkZ3mjkLarzhKg6qDZQdhSPVhDyGz1QaUfSIge9iwYd1eZ2WJH+zhw4czdOhQAM4++2xmz57NRRddxHXXXcfSpUt58MEHuf/++we8vRKJRCKR9CWKKR67uw9Jz9gnOkc9ITs7m9dff52ZM2cyefJkCgoKuPnmm2Uav2SfQVMscjSREFAebObTRjG9m0VbvxzvhnWLcWMQs0SG5yY938lWu2PxqZR9d3G/HFeyZ/nrpg+c5+22j1XCdLOioYhUth1X1NbF3wihGqnCLJ2GiVB57fyBaq4kg1SOBpR9snNUXl6OtY2o+/Hjx/P+++/vgRZJJBKJRCLZX9gnO0cSyf5Ku+07U+ZvZIk2qF+Ocfv6TwFQFQvTUmgwRMzdm61j+bxhiDj+dlSjP1TNE+8FPIpQF84vPbJf2inpHxpMETzkU0zaTfEvIGG5GV24hYWt4v5LxDxkbRbO7QAoEPtOq3i+MmdgGywBZLbaQCM7RxKJRCKR7O30hU+R9DnqMbJzJJHsJTw8YiT/s6IWgDytgxmDlgHwFsE+2f+vN3zS7fUGPZ+GdJh3m0cBUBsLsaUmB4CcPjmiZG8kZoq4soRi0W4K1dC0VD5bX8phIzcA8GV2McloNlpSqIORwxKMOGP5HmmvRLInkJ0jiUQikUj2cuS02sAiO0cSyV7Es6P7J86oK3XpMAA+RafQFeHjz0YCMPJnH3EQG3b43h8PO6q/myfpR57f/BGb7HppDUaQDSnhM7chkQ/NSx3OcAAAJZVJREFUHhZtOAgAV4fwNtKS4n0jzvtsj7RX0gWZrTag7BO11SQSiUQikUgGCqkcSSQHGKY9JkpZGptT+Yz82Ud7uEWSgWJ1WnOe/+Szc/C4hHnRoSWb8bSopANCWghWK7hjFlpKSg17C3JabWCRnSOJRCKRSPZ2ZLbagCKn1SSSA4RflB/GJI+LQi1CoRYhZnp55eDsPd0syQCTMF0kTBffGP4l+cEO8oMdrGkrAMAVU3DFFEwPaCmLtFch7VVo/59pe7jVEsnAIpUjiUQikUj2cuS02sAiO0cSyQHEqYMn7ekmSPYwHkXEGa2MFLFhTQkARWXNuDogVC3+e2pJi7RPwf8D4buV74sRfXbPtFdiI7PVBhTZOZJIJBKJZC9HKkcDi+wcSSQSyQFEwhIO2dXt2WStEdlr7kqDWKmJOybCUL1toKYtvCdtACC6R1oqkew5ZOdIIpFIJJK9HdMSj93dh6RHyM6RRLKf8/uqDwDQsBii+fn6kMl7uEWSPYlP0QFobQugTIkBYHb4sbwmraPFNjkrVHzN2/5HOnv9QhKW21GgclSxj1sq5H3Vr8iYowFFpvJLJBKJRCLZivfee49vfOMbDB48GEVReOGFF7qttyyLm2++mUGDBuH3+znxxBNZvXp1t22am5s555xzCIfD5OTkcNFFFxGNdp+oXbx4MUcffTQ+n4/S0lLuvvvu/j61nSI7RxKJRCKR7OUodAZl7/Kjl8fs6OhgwoQJPPLII9tcf/fdd/PQQw8xZ84cPv74Y4LBIDNmzCCRSDjbnHPOOXz55ZfMnTuXl156iffee49LLrnEWR+JRDj55JMpKytj4cKF3HPPPdx666388Y9/3IWr1HfIaTWJRCI5gFDtlKXHpz9BQE0BcO2as9i8IhvL/u/ZOiXFyB9+us33fxgbydsNo/j+oAUA6JqLPDXK7PULATm91m/sAYfsU089lVNPPXU7u7J44IEHuOmmmzjjjDMAeOqppyguLuaFF17g+9//PsuXL+fVV1/lk08+YcqUKQD87ne/47TTTuPee+9l8ODBPP3006RSKR577DE8Hg8HH3wwX3zxBffdd1+3TtRAI5UjiUQikUgOICKRSLdHMpns9T7Wr19PXV0dJ554orMsOzubqVOnMn/+fADmz59PTk6O0zECOPHEE1FVlY8//tjZ5phjjsHj8TjbzJgxg5UrV9LS0rKrp7jbSOVIItnP+emwI/d0EyR7IQE1hU9JA/DbEc9zp+90VreIMiKtjVms+vNhHPSjT5ztb1/fqST91ziYmOkFwKfq1BnZ/HFk5QC2/sCjL32OSktLuy2/5ZZbuPXWW3u1r7q6OgCKi4u7LS8uLnbW1dXVUVRU1G29y+UiLy+v2zYVFRVb7SOzLjc3t1ft6itk50gikUgkkr2dPsxW27RpE+Fw2Fns9Xp3c8f7H7JzJJFIJAcIvyg/jF9v6FSDEpb4F+DB4Mohr/E7VUyR1PljVDfnUP/iGACC3hRXrBwOQNYpa1HZROXaLQDcPfyQPm3jXRs+dp4bX4n8+EX5YX16rAOVcDjcrXO0K5SUiNIz9fX1DBo0yFleX1/PxIkTnW22bNnS7X3pdJrm5mbn/SUlJdTX13fbJvM6s82eQMYcSSQSiUSyl6NYVp88+oqKigpKSkp48803nWWRSISPP/6Y6dOnAzB9+nRaW1tZuHChs81bb72FaZpMnTrV2ea9995D13Vnm7lz5zJq1Kg9NqUGUjmSSCSSA4qM+tJVQUqhkbDcnF30EQC6pdEwJMyKuFAEkqaLkX6hAByxfjU3VUzpc8Xoq3xVNTrgMe3H7u6jF0SjUdasWeO8Xr9+PV988QV5eXkMGzaMK664gttvv52RI0dSUVHBL3/5SwYPHsyZZ54JwJgxYzjllFO4+OKLmTNnDrquc9lll/H973+fwYMHA3D22Wcze/ZsLrroIq677jqWLl3Kgw8+yP3337+bJ7t7yM6RRCKRSCR7OX2h/PT2/Z9++inHH3+883rWrFkAnH/++TzxxBNce+21dHR0cMkll9Da2spRRx3Fq6++is/nc97z9NNPc9lll/G1r30NVVU566yzeOihh5z12dnZvP7668ycOZPJkydTUFDAzTffvEfT+AEUy+pDnW0/IBKJkJ2dzXGcgUtx7+nmSCQSSb/RVT0CMG2jo1bTT8T0U69nAxDSEoz21Drb3VQxhf7mq22DvS/mKG3pvMOLtLW17XYMz/bI/E865uibcbl8O3/DDkinE7z3/m392t79BakcSSQSiUSytyNrqw0osnMkkUgkByhdlZhfb/jEcc9WsRjmamaYqxnIKEVD9ljbJOwRh+wDGRnxJpFIJBKJRNIFqRxJJBKJRCo1ezl96ZAt2TmycySRSCQSyd6OnFYbUPapabWXX36ZqVOn4vf7yc3NdbwUMlRVVXH66acTCAQoKirimmuuIZ1O75nGSiQSiUQi2SfZZ5Sjf/zjH1x88cX8+te/5oQTTiCdTrN06VJnvWEYnH766ZSUlPDhhx9SW1vLeeedh9vt5te//vUebLlEIpFIJLuHYorH7u5D0jP2ic5ROp3m8ssv55577uGiiy5ylo8dO9Z5/vrrr7Ns2TLeeOMNiouLmThxIr/61a+47rrruPXWW/F4PHui6RKJRCKR7D5yWm1A2Sem1T777DOqq6tRVZVJkyYxaNAgTj311G7K0fz58xk3bhzFxcXOshkzZhCJRPjyyy+3u+9kMkkkEun2kEgkEolEcuCyT3SO1q1bB8Ctt97KTTfdxEsvvURubi7HHXcczc3Ch6Ourq5bxwhwXtfV1W1333feeSfZ2dnOo7S0tJ/OQiKRSCSSXcTqo4ekR+zRztH111+Poig7fKxYsQLTFBOlN954I2eddRaTJ0/m8ccfR1EUnn/++d1qww033EBbW5vz2LRpU1+cmkQikUgkfUamttruPiQ9Y4/GHF111VVccMEFO9ymsrKS2lpR06drjJHX66WyspKqqioASkpKWLBgQbf31tfXO+u2h9frxev17krzJRKJRCIZGGTM0YCyRztHhYWFFBYW7nS7yZMn4/V6WblyJUcddRQAuq6zYcMGysrKAJg+fTp33HEHW7ZsoaioCIC5c+cSDoe7daokEolEIpFIdsQ+ka0WDoe59NJLueWWWygtLaWsrIx77rkHgO9+97sAnHzyyYwdO5Zzzz2Xu+++m7q6Om666SZmzpwplSGJRCKR7NtYwO6m4kvhqMfsE50jgHvuuQeXy8W5555LPB5n6tSpvPXWW+Tm5gKgaRovvfQSP/nJT5g+fTrBYJDzzz+f2267bQ+3XCKRSCSS3aMvYoZkzFHP2Wc6R263m3vvvZd77713u9uUlZXxyiuvDGCrJBKJRCKR7G/sM50jiUQikUgOWCz6ICC7T1pyQCA7RxKJRCKR7O3IbLUBZZ8wgZRIJBKJRCIZKKRyJJFIJBLJ3o4JKH2wD0mPkJ0jiUQikUj2cmS22sAiO0cSiUQikeztyJijAUXGHEkkEolEIpF0QSpHEolEIpHs7UjlaECRnSOJRCKRSPZ2ZOdoQJHTahKJRCKRSCRdkMqRRCKRSCR7OzKVf0CRnSOJRCKRSPZyZCr/wCKn1SQSiUQikUi6IJUjiUQikUj2dmRA9oAiO0cSiUQikeztmBYou9m5MWXnqKfIaTWJRCKRSCSSLkjlSCKRSCSSvR05rTagyM6RRCKRSCR7PX3QOUJ2jnqK7BxJJBKJRLK3I5WjAUXGHEkkEolEIpF0QSpHEolEIpHs7ZgWuz0tJrPVeozsHEkkEolEsrdjmeKxu/uQ9Ag5rSaRSCQSiUTSBakcSSQSiUSytyMDsgcU2TmSSCQSiWRvR8YcDShyWk0ikUgkEomkC1I5kkgkEolkb0dOqw0osnMkkUgkEsnejkUfdI76pCUHBHJaTSKRSCQSiaQLUjmSSCQSiWRvR06rDSj7jHK0atUqzjjjDAoKCgiHwxx11FG8/fbb3bapqqri9NNPJxAIUFRUxDXXXEM6nd5DLZZIJBKJpI8wzb55SHrEPtM5+vrXv046neatt95i4cKFTJgwga9//evU1dUBYBgGp59+OqlUig8//JAnn3ySJ554gptvvnkPt1wikUgkkt0koxzt7kPSI/aJzlFjYyOrV6/m+uuvZ/z48YwcOZLf/OY3xGIxli5dCsDrr7/OsmXL+N///V8mTpzIqaeeyq9+9SseeeQRUqnUHj4DiUQikUgk+wr7ROcoPz+fUaNG8dRTT9HR0UE6neYPf/gDRUVFTJ48GYD58+czbtw4iouLnffNmDGDSCTCl19+ud19J5NJIpFIt4dEIpFIJHsVUjkaUPaJgGxFUXjjjTc488wzCYVCqKpKUVERr776Krm5uQDU1dV16xgBzuvM1Nu2uPPOO5k9e3b/NV4ikUgkkt1FOmQPKHtUObr++utRFGWHjxUrVmBZFjNnzqSoqIj333+fBQsWcOaZZ/KNb3yD2tra3WrDDTfcQFtbm/PYtGlTH52dRCKRSCSSfZE9qhxdddVVXHDBBTvcprKykrfeeouXXnqJlpYWwuEwAL///e+ZO3cuTz75JNdffz0lJSUsWLCg23vr6+sBKCkp2e7+vV4vXq93905EIpFIJJJ+xLJMLGv3ss129/0HEnu0c1RYWEhhYeFOt4vFYgCoanehS1VVTDs1cfr06dxxxx1s2bKFoqIiAObOnUs4HGbs2LF93HKJRCKRSAYQy9r9aTEZc9Rj9omA7OnTp5Obm8v555/PokWLWLVqFddccw3r16/n9NNPB+Dkk09m7NixnHvuuSxatIjXXnuNm266iZkzZ0plSCKRSCQSSY/ZJzpHBQUFvPrqq0SjUU444QSmTJnCvHnzePHFF5kwYQIAmqbx0ksvoWka06dP5wc/+AHnnXcet9122x5uvUQikUgku4nMVhtQ9olsNYApU6bw2muv7XCbsrIyXnnllQFqkUQikUgkA4RpgrKbMUMy5qjH7BPKkUQikUgkEslAsc8oRxKJRCKRHLBYfeBzJKfVeozsHEkkEolEspdjmSbWbk6ryVT+niM7RxKJRCKR7O1I5WhAkTFHEolEIpFIJF2QypFEIpFIJHs7pgWKVI4GCtk5kkgkEolkb8eygN1N5Zedo54ip9UkEolEIpFIuiCVI4lEIpFI9nIs08LazWk1SypHPUYqR5L/3969R0V1XX8A/w7KDM9hQGAYRJ5aHlFRsFCCFVtQMGkK2tRHaAHrwqWVihITtU1AjQaLxpBmWR9JA0kWSUiyIDZpxKIGjASJoPhEFIpgWwYiKiAEYZj9+8Nyf3N5KCTgMGR/1pq1uOecuXfvOYNs7z1zhzHG2GhH2uF5DNHevXvh6uoKExMTBAYG4uuvvx6B5EYfLo4YY4wx1kd2djaSkpKQkpKCM2fOwNfXF+Hh4WhsbNR3aCOOiyPGGGNslCMtDctjKPbs2YP4+HgsX74cPj4+2L9/P8zMzPDWW2+NUJajBxdHjDHG2Gj3iC+rdXZ2oqysDGFhYUKbkZERwsLCUFxcPBIZjiq8ILuXngVrGnR975uRMsYYG7s06ALwaBY6D8ffpJ54W1paRO0ymQwymUzUdvPmTXR3d0OpVIralUolrly58v0CMQBcHPXS1NQEADiJz/UcCWOMMUPQ2toKKyurEdm3VCqFg4MDTqqH52+ShYUFJk2aJGpLSUnBli1bhmX/YwUXR73Y2NgAAOrq6kbsza4vLS0tmDRpEm7cuAG5XK7vcIYV52aYODfDxLndR0RobW2Fo6PjiMVjYmKCmpoadHZ2Dsv+iAgSiUTU1vusEQDY2tpi3LhxaGhoELU3NDTAwcFhWGIZzbg46sXI6P4yLCsrqzH3S99DLpdzbgaIczNMnJthGmxuj+I/0SYmJjAxMRnx4+iSSqXw9/fHsWPHEBUVBQDQarU4duwYEhISHmks+sDFEWOMMcb6SEpKQmxsLGbNmoWAgACkp6ejra0Ny5cv13doI46LI8YYY4z1sWTJEnzzzTdITk6GWq3GjBkzkJeX12eR9ljExVEvMpkMKSkp/V6DNXScm2Hi3AwT52aYxnJu30VCQsIP4jJabxLiL1thjDHGGBPwTSAZY4wxxnRwccQYY4wxpoOLI8YYY4wxHVwc6di7dy9cXV1hYmKCwMBAfP311/oOaci2bNkCiUQienh5eQn9HR0dWLNmDSZMmAALCwv86le/6nOTr9HixIkTeOqpp+Do6AiJRIJPPvlE1E9ESE5OhkqlgqmpKcLCwnDt2jXRmFu3biE6OhpyuRwKhQIrVqzA3bt3H2EW/XtYbnFxcX3mMSIiQjRmtOaWmpqKH//4x7C0tIS9vT2ioqJQWVkpGjOY92FdXR2efPJJmJmZwd7eHs899xw0Gs2jTKWPweQ2d+7cPnO3atUq0ZjRmNu+ffswffp04f4+QUFBOHz4sNBvqHMGPDw3Q50zNnK4OPqf7OxsJCUlISUlBWfOnIGvry/Cw8PR2Nio79CG7LHHHkN9fb3wOHnypNC3fv16fPrpp/joo49QWFiI//73v1i0aJEeox1YW1sbfH19sXfv3n7709LS8Je//AX79+9HSUkJzM3NER4ejo6ODmFMdHQ0Ll26hPz8fHz22Wc4ceIEVq5c+ahSGNDDcgOAiIgI0Ty+//77ov7RmlthYSHWrFmDU6dOIT8/H11dXZg/fz7a2tqEMQ97H3Z3d+PJJ59EZ2cnvvrqK7z99tvIzMxEcnKyPlISDCY3AIiPjxfNXVpamtA3WnNzcnLCzp07UVZWhtLSUvz85z9HZGQkLl26BMBw5wx4eG6AYc4ZG0HEiIgoICCA1qxZI2x3d3eTo6Mjpaam6jGqoUtJSSFfX99+++7cuUPGxsb00UcfCW0VFRUEgIqLix9RhN8NAMrNzRW2tVotOTg40K5du4S2O3fukEwmo/fff5+IiC5fvkwA6PTp08KYw4cPk0Qiof/85z+PLPaH6Z0bEVFsbCxFRkYO+BxDyY2IqLGxkQBQYWEhEQ3uffj555+TkZERqdVqYcy+fftILpfTvXv3Hm0CD9A7NyKikJAQSkxMHPA5hpIbEZG1tTW9+eabY2rOevTkRjS25owNDz5zBKCzsxNlZWUICwsT2oyMjBAWFobi4mI9RvbdXLt2DY6OjnB3d0d0dDTq6uoAAGVlZejq6hLl6eXlBWdnZ4PLs6amBmq1WpSLlZUVAgMDhVyKi4uhUCgwa9YsYUxYWBiMjIxQUlLyyGMeqoKCAtjb28PT0xOrV68WvhQZMKzcmpubAfz/9xYO5n1YXFyMadOmiW42Fx4ejpaWFtH/9vWtd249srKyYGtri6lTp2Lz5s1ob28X+gwht+7ubnzwwQdoa2tDUFDQmJqz3rn1MPQ5Y8OLbwIJ4ObNm+ju7u5z10+lUokrV67oKarvJjAwEJmZmfD09ER9fT22bt2Kn/70p7h48SLUajWkUikUCoXoOUqlEmq1Wj8Bf0c98fY3Zz19arUa9vb2ov7x48fDxsZm1OcbERGBRYsWwc3NDdXV1fjjH/+IBQsWoLi4GOPGjTOY3LRaLdatW4fg4GBMnToVAAb1PlSr1f3ObU/faNBfbgDwzDPPwMXFBY6Ojjh//jw2btyIyspK5OTkABjduV24cAFBQUHo6OiAhYUFcnNz4ePjg/LycoOfs4FyAwx7ztjI4OJojFmwYIHw8/Tp0xEYGAgXFxd8+OGHMDU11WNkbCiWLl0q/Dxt2jRMnz4dHh4eKCgoQGhoqB4jG5o1a9bg4sWLonVvY8VAuemu+5o2bRpUKhVCQ0NRXV0NDw+PRx3mkHh6eqK8vBzNzc34+OOPERsbi8LCQn2HNSwGys3Hx8eg54yNDL6sBsDW1hbjxo3r88mLhoYGODg46Cmq4aFQKPCjH/0IVVVVcHBwQGdnJ+7cuSMaY4h59sT7oDlzcHDos6Beo9Hg1q1bBpevu7s7bG1tUVVVBcAwcktISMBnn32GL774Ak5OTkL7YN6HDg4O/c5tT5++DZRbfwIDAwFANHejNTepVIrJkyfD398fqamp8PX1xWuvvTYm5myg3PpjSHPGRgYXR7j/S+Pv749jx44JbVqtFseOHRNdkzZEd+/eRXV1NVQqFfz9/WFsbCzKs7KyEnV1dQaXp5ubGxwcHES5tLS0oKSkRMglKCgId+7cQVlZmTDm+PHj0Gq1wj9+huLf//43mpqaoFKpAIzu3IgICQkJyM3NxfHjx+Hm5ibqH8z7MCgoCBcuXBAVgPn5+ZDL5cKlEH14WG79KS8vBwDR3I3G3Pqj1Wpx7949g56zgfTk1h9DnjM2TPS9Iny0+OCDD0gmk1FmZiZdvnyZVq5cSQqFQvTpBEPw7LPPUkFBAdXU1FBRURGFhYWRra0tNTY2EhHRqlWryNnZmY4fP06lpaUUFBREQUFBeo66f62trXT27Fk6e/YsAaA9e/bQ2bNnqba2loiIdu7cSQqFgg4dOkTnz5+nyMhIcnNzo2+//VbYR0REBM2cOZNKSkro5MmTNGXKFFq2bJm+UhI8KLfW1lbasGEDFRcXU01NDR09epT8/PxoypQp1NHRIexjtOa2evVqsrKyooKCAqqvrxce7e3twpiHvQ81Gg1NnTqV5s+fT+Xl5ZSXl0d2dna0efNmfaQkeFhuVVVVtG3bNiotLaWamho6dOgQubu705w5c4R9jNbcNm3aRIWFhVRTU0Pnz5+nTZs2kUQioX/+859EZLhzRvTg3Ax5ztjI4eJIx+uvv07Ozs4klUopICCATp06pe+QhmzJkiWkUqlIKpXSxIkTacmSJVRVVSX0f/vtt/T73/+erK2tyczMjBYuXEj19fV6jHhgX3zxBQHo84iNjSWi+x/nf/HFF0mpVJJMJqPQ0FCqrKwU7aOpqYmWLVtGFhYWJJfLafny5dTa2qqHbMQelFt7ezvNnz+f7OzsyNjYmFxcXCg+Pr5PoT5ac+svLwCUkZEhjBnM+/D69eu0YMECMjU1JVtbW3r22Wepq6vrEWcj9rDc6urqaM6cOWRjY0MymYwmT55Mzz33HDU3N4v2Mxpz+93vfkcuLi4klUrJzs6OQkNDhcKIyHDnjOjBuRnynLGRIyEienTnqRhjjDHGRjdec8QYY4wxpoOLI8YYY4wxHVwcMcYYY4zp4OKIMcYYY0wHF0eMMcYYYzq4OGKMMcYY08HFEWOMMcaYDi6OGGOMMcZ0cHHEftDmzp2LdevWjanjxsXFISoq6nvtw9XVFRKJBBKJpM+XjerKzMyEQqH4XscaK+Li4oTX7JNPPtF3OIyx74GLI8b0ICcnBy+99JKw7erqivT0dP0F1I9t27ahvr4eVlZW+g5F7zIzM4XCR/dhYmIijHnttddQX1+vxygZY8NlvL4DYOyHyMbGRt8hPJSlpSUcHBz0HQYAoKurC8bGxnqNQS6Xo7KyUtQmkUiEn62srLiQZGyM4DNHjOm4ffs2YmJiYG1tDTMzMyxYsADXrl0T+nsuIx05cgTe3t6wsLBARESE6IyBRqPB2rVroVAoMGHCBGzcuBGxsbGiS126l9Xmzp2L2tparF+/XjgjAQBbtmzBjBkzRPGlp6fD1dVV2O7u7kZSUpJwrOeffx69vy5Rq9UiNTUVbm5uMDU1ha+vLz7++OPv9PpkZmbC2dkZZmZmWLhwIZqamvqMOXToEPz8/GBiYgJ3d3ds3boVGo1G6L9y5Qpmz54NExMT+Pj44OjRo6JLUdevX4dEIkF2djZCQkJgYmKCrKwsAMCbb74Jb29vmJiYwMvLC3/9619Fx75x4wYWL14MhUIBGxsbREZG4vr160J/QUEBAgICYG5uDoVCgeDgYNTW1g4qd4lEAgcHB9FDqVQO8RVkjBkCLo4Y0xEXF4fS0lL8/e9/R3FxMYgITzzxBLq6uoQx7e3t2L17N959912cOHECdXV12LBhg9D/5z//GVlZWcjIyEBRURFaWloeuAYlJycHTk5OwmWsoVyaeeWVV5CZmYm33noLJ0+exK1bt5Cbmysak5qainfeeQf79+/HpUuXsH79evzmN79BYWHh4F8YACUlJVixYgUSEhJQXl6On/3sZ9i+fbtozJdffomYmBgkJibi8uXLOHDgADIzM7Fjxw4A94u5qKgomJmZoaSkBAcPHsSf/vSnfo+3adMmJCYmoqKiAuHh4cjKykJycjJ27NiBiooKvPzyy3jxxRfx9ttvA7h/dik8PByWlpb48ssvUVRUJBSvnZ2d0Gg0iIqKQkhICM6fP4/i4mKsXLlSdPaHMcYAAMTYD1hISAglJiYSEdHVq1cJABUVFQn9N2/eJFNTU/rwww+JiCgjI4MAUFVVlTBm7969pFQqhW2lUkm7du0StjUaDTk7O1NkZGS/xyUicnFxoVdffVUUW0pKCvn6+oraXn31VXJxcRG2VSoVpaWlCdtdXV3k5OQkHKujo4PMzMzoq6++Eu1nxYoVtGzZsgFfl/7iWbZsGT3xxBOitiVLlpCVlZWwHRoaSi+//LJozLvvvksqlYqIiA4fPkzjx4+n+vp6oT8/P58AUG5uLhER1dTUEABKT08X7cfDw4Pee+89UdtLL71EQUFBwnE8PT1Jq9UK/ffu3SNTU1M6cuQINTU1EQAqKCgYMO+B9My7ubm56BEREdFnrG4ujDHDxGuOGPufiooKjB8/HoGBgULbhAkT4OnpiYqKCqHNzMwMHh4ewrZKpUJjYyMAoLm5GQ0NDQgICBD6x40bB39/f2i12mGNt7m5GfX19aJ4x48fj1mzZgmX1qqqqtDe3o558+aJntvZ2YmZM2cO6XgVFRVYuHChqC0oKAh5eXnC9rlz51BUVCScKQLuny3q6OhAe3s7KisrMWnSJNFaJt3XStesWbOEn9va2lBdXY0VK1YgPj5eaNdoNMI6n3PnzqGqqgqWlpai/XR0dKC6uhrz589HXFwcwsPDMW/ePISFhWHx4sVQqVSDyt/S0hJnzpwRtZmamg7quYwxw8LFEWND1HthsEQi6bPOZzgYGRn12a/u5b3BuHv3LgDgH//4ByZOnCjqk8lk3y/AAY63detWLFq0qE+f7ie7BsPc3Fy0XwB44403RMUgcL/47Bnj7+8vrE/SZWdnBwDIyMjA2rVrkZeXh+zsbLzwwgvIz8/HT37yk4fGY2RkhMmTJw8pB8aYYeLiiLH/8fb2hkajQUlJCR5//HEAQFNTEyorK+Hj4zOofVhZWUGpVOL06dOYM2cOgPtnTs6cOdNncbUuqVSK7u5uUZudnR3UajWISFgXU15eLjqWSqVCSUmJcCyNRoOysjL4+fkBAHx8fCCTyVBXV4eQkJBB5TAQb29vlJSUiNpOnTol2vbz80NlZeWARYSnpydu3LiBhoYGYTHz6dOnH3pspVIJR0dH/Otf/0J0dHS/Y/z8/JCdnQ17e3vI5fIB9zVz5kzMnDkTmzdvRlBQEN57771BFUeMsR8OLo4Y+58pU6YgMjIS8fHxOHDgACwtLbFp0yZMnDgRkZGRg97PH/7wB6SmpmLy5Mnw8vLC66+/jtu3bz9w4a+rqytOnDiBpUuXQiaTwdbWFnPnzsU333yDtLQ0PP3008jLy8Phw4dFf/gTExOxc+dOTJkyBV5eXtizZ4/opo2WlpbYsGED1q9fD61Wi9mzZ6O5uRlFRUWQy+WIjY0ddF5r165FcHAwdu/ejcjISBw5ckR0SQ0AkpOT8Ytf/ALOzs54+umnYWRkhHPnzuHixYvYvn075s2bBw8PD8TGxiItLQ2tra144YUXAOChC6O3bt2KtWvXwsrKChEREbh37x5KS0tx+/ZtJCUlITo6Grt27UJkZCS2bdsGJycn1NbWIicnB88//zy6urpw8OBB/PKXv4SjoyMqKytx7do1xMTEDCp/IoJare7Tbm9vDyMj/mwLY2OKXlc8MaZnvRdG37p1i37729+SlZUVmZqaUnh4OF29elXoz8jIEC1AJiLKzc0l3V+lrq4uSkhIILlcTtbW1rRx40b69a9/TUuXLh3wuMXFxTR9+nSSyWSife3bt48mTZpE5ubmFBMTQzt27BAtyO7q6qLExESSy+WkUCgoKSmJYmJiRIu/tVotpaenk6enJxkbG5OdnR2Fh4dTYWHhgK9LfwuyiYj+9re/kZOTE5mamtJTTz1Fu3fv7vN65OXl0eOPP06mpqYkl8spICCADh48KPRXVFRQcHAwSaVS8vLyok8//ZQAUF5eHhH9/4Lss2fP9jl+VlYWzZgxg6RSKVlbW9OcOXMoJydH6K+vr6eYmBiytbUlmUxG7u7uFB8fT83NzaRWqykqKopUKhVJpVJycXGh5ORk6u7uHvB16NGzILu/h+7iciJekM3YWCAhGoHFEowxgVarhbe3NxYvXiy6K/Zo5urqinXr1j2Sr1YpKirC7NmzUVVVJVrobqgkEglyc3O/91e4MMb0h88FMzbMamtr8cYbb+Dq1au4cOECVq9ejZqaGjzzzDP6Dm1INm7cCAsLCzQ3Nw/rfnNzc5Gfn4/r16/j6NGjWLlyJYKDgw2+MFq1ahUsLCz0HQZjbBjwmSPGhtmNGzewdOlSXLx4EUSEqVOnYufOncKiaUNQW1srfDLO3d19WNfUvPPOO9i+fTvq6upga2uLsLAwvPLKK5gwYcKwHWOoHnvssQHvlH3gwIEBF4HramxsREtLC4D7t3fQ/bQdY8ywcHHEGPvB0y0Ge1MqlX3uncQYG9u4OGKMMcYY08FrjhhjjDHGdHBxxBhjjDGmg4sjxhhjjDEdXBwxxhhjjOng4ogxxhhjTAcXR4wxxhhjOrg4YowxxhjTwcURY4wxxpiO/wPmg/QeeL/DyQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds.mrso.mean(dim='time').plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "9212d429-8cd2-4ef6-a498-2fed900091d9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 00020101-00021231\n", + "1 00030101-00031231\n", + "2 00040101-00041231\n", + "3 00050101-00051231\n", + "4 00060101-00061231\n", + "5 00070101-00071231\n", + "6 00080101-00081231\n", + "7 00090101-00091231\n", + "8 00110101-00111231\n", + "9 00100101-00101231\n", + "Name: temporal_subset, dtype: object" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cat.df['temporal_subset'] " + ] + }, + { + "cell_type": "markdown", + "id": "06746aff-889b-4c67-b2d7-fb5ae821a678", + "metadata": {}, + "source": [ + "Can I please leverage CF? " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d7dadd5-7abd-4bf7-a6ca-e39d3c214b04", + "metadata": {}, + "outputs": [], + "source": [ + "pip install cf_xarray" + ] + }, + { + "cell_type": "markdown", + "id": "3f248b8e-2d65-469c-b41f-f1875fac7317", + "metadata": {}, + "source": [ + "#You may leverage the use of cf_xarray, xMIP etc to build your analyses from here. They all blend in." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "c47d02a6-c340-45f6-8f84-f26e691358ca", + "metadata": {}, + "outputs": [], + "source": [ + "import xarray as xr\n", + "import cf_xarray as cfxr" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "c6cb19f4-6409-4e32-9119-b0d51b42eb33", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 757MB\n",
+       "Dimensions:     (time: 3650, bnds: 2, lat: 180, lon: 288)\n",
+       "Coordinates:\n",
+       "    average_DT  (time) timedelta64[ns] 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
+       "    average_T1  (time) object 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
+       "    average_T2  (time) object 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
+       "  * bnds        (bnds) float64 16B 1.0 2.0\n",
+       "  * lat         (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n",
+       "    lat_bnds    (lat, bnds) float64 3kB dask.array<chunksize=(180, 2), meta=np.ndarray>\n",
+       "  * lon         (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n",
+       "    lon_bnds    (lon, bnds) float64 5kB dask.array<chunksize=(288, 2), meta=np.ndarray>\n",
+       "  * time        (time) object 29kB 0002-01-01 12:00:00 ... 0011-12-31 12:00:00\n",
+       "    time_bnds   (time, bnds) object 58kB dask.array<chunksize=(5, 2), meta=np.ndarray>\n",
+       "Data variables:\n",
+       "    mrso        (time, lat, lon) float32 757MB dask.array<chunksize=(5, 180, 288), meta=np.ndarray>\n",
+       "Attributes: (12/18)\n",
+       "    title:                            c96L65_am5f3b1r0_pdclim1850F\n",
+       "    grid_type:                        regular\n",
+       "    grid_tile:                        N/A\n",
+       "    code_release_version:             2023.01\n",
+       "    git_hash:                         unknown githash\n",
+       "    external_variables:               land_area\n",
+       "    ...                               ...\n",
+       "    intake_esm_attrs:variable_id:     mrso\n",
+       "    intake_esm_attrs:chunk_freq:      1yr\n",
+       "    intake_esm_attrs:platform:        gfdl.ncrc5-deploy-prod-openmp\n",
+       "    intake_esm_attrs:cell_methods:    ts\n",
+       "    intake_esm_attrs:_data_format_:   netcdf\n",
+       "    intake_esm_dataset_key:           am5.c96L65_am5f3b1r0_pdclim1850F.daily....
" + ], + "text/plain": [ + " Size: 757MB\n", + "Dimensions: (time: 3650, bnds: 2, lat: 180, lon: 288)\n", + "Coordinates:\n", + " average_DT (time) timedelta64[ns] 29kB dask.array\n", + " average_T1 (time) object 29kB dask.array\n", + " average_T2 (time) object 29kB dask.array\n", + " * bnds (bnds) float64 16B 1.0 2.0\n", + " * lat (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n", + " lat_bnds (lat, bnds) float64 3kB dask.array\n", + " * lon (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n", + " lon_bnds (lon, bnds) float64 5kB dask.array\n", + " * time (time) object 29kB 0002-01-01 12:00:00 ... 0011-12-31 12:00:00\n", + " time_bnds (time, bnds) object 58kB dask.array\n", + "Data variables:\n", + " mrso (time, lat, lon) float32 757MB dask.array\n", + "Attributes: (12/18)\n", + " title: c96L65_am5f3b1r0_pdclim1850F\n", + " grid_type: regular\n", + " grid_tile: N/A\n", + " code_release_version: 2023.01\n", + " git_hash: unknown githash\n", + " external_variables: land_area\n", + " ... ...\n", + " intake_esm_attrs:variable_id: mrso\n", + " intake_esm_attrs:chunk_freq: 1yr\n", + " intake_esm_attrs:platform: gfdl.ncrc5-deploy-prod-openmp\n", + " intake_esm_attrs:cell_methods: ts\n", + " intake_esm_attrs:_data_format_: netcdf\n", + " intake_esm_dataset_key: am5.c96L65_am5f3b1r0_pdclim1850F.daily...." + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xr.decode_cf(ds)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "0dc03c24-25b6-48f6-9c44-d8bb677244eb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'mrso' (time: 0, lat: 180, lon: 288)> Size: 0B\n",
+       "dask.array<getitem, shape=(0, 180, 288), dtype=float32, chunksize=(0, 180, 288), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "    average_DT  (time) float64 0B dask.array<chunksize=(0,), meta=np.ndarray>\n",
+       "    average_T1  (time) float64 0B dask.array<chunksize=(0,), meta=np.ndarray>\n",
+       "    average_T2  (time) float64 0B dask.array<chunksize=(0,), meta=np.ndarray>\n",
+       "  * lat         (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n",
+       "  * lon         (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n",
+       "  * time        (time) float64 0B \n",
+       "Attributes:\n",
+       "    units:            kg m-2\n",
+       "    long_name:        Total Soil Moisture Content\n",
+       "    cell_methods:     area: mean time: mean\n",
+       "    ocean_fillvalue:  0.0\n",
+       "    cell_measures:    area: land_area\n",
+       "    time_avg_info:    average_T1,average_T2,average_DT\n",
+       "    standard_name:    soil_moisture_content\n",
+       "    interp_method:    conserve_order1
" + ], + "text/plain": [ + " Size: 0B\n", + "dask.array\n", + "Coordinates:\n", + " average_DT (time) float64 0B dask.array\n", + " average_T1 (time) float64 0B dask.array\n", + " average_T2 (time) float64 0B dask.array\n", + " * lat (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n", + " * lon (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n", + " * time (time) float64 0B \n", + "Attributes:\n", + " units: kg m-2\n", + " long_name: Total Soil Moisture Content\n", + " cell_methods: area: mean time: mean\n", + " ocean_fillvalue: 0.0\n", + " cell_measures: area: land_area\n", + " time_avg_info: average_T1,average_T2,average_DT\n", + " standard_name: soil_moisture_content\n", + " interp_method: conserve_order1" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds.mrso.sel(time=slice(\"0002-01-01\",\"0004-01-01\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "4f443874-7a2d-4856-b687-84a8f02a0f83", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'time' (time: 3650)> Size: 29kB\n",
+       "array([ 365.5,  366.5,  367.5, ..., 4012.5, 4013.5, 4014.5])\n",
+       "Coordinates:\n",
+       "    average_DT  (time) float64 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
+       "    average_T1  (time) float64 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
+       "    average_T2  (time) float64 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
+       "  * time        (time) float64 29kB 365.5 366.5 367.5 ... 4.014e+03 4.014e+03\n",
+       "Attributes:\n",
+       "    units:          days since 0001-01-01 00:00:00\n",
+       "    long_name:      time\n",
+       "    axis:           T\n",
+       "    calendar_type:  NOLEAP\n",
+       "    calendar:       noleap\n",
+       "    bounds:         time_bnds\n",
+       "    cell_methods:   time: mean
" + ], + "text/plain": [ + " Size: 29kB\n", + "array([ 365.5, 366.5, 367.5, ..., 4012.5, 4013.5, 4014.5])\n", + "Coordinates:\n", + " average_DT (time) float64 29kB dask.array\n", + " average_T1 (time) float64 29kB dask.array\n", + " average_T2 (time) float64 29kB dask.array\n", + " * time (time) float64 29kB 365.5 366.5 367.5 ... 4.014e+03 4.014e+03\n", + "Attributes:\n", + " units: days since 0001-01-01 00:00:00\n", + " long_name: time\n", + " axis: T\n", + " calendar_type: NOLEAP\n", + " calendar: noleap\n", + " bounds: time_bnds\n", + " cell_methods: time: mean" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds.mrso.time" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a61e9c94-5d20-44d1-9a0a-6dab48dc444c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "intakebuilder", + "language": "python", + "name": "intakebuilder" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/catalogbuilder/scripts/gen_intake_gfdl_runner.py b/catalogbuilder/scripts/gen_intake_gfdl_runner.py new file mode 100755 index 0000000..920ede8 --- /dev/null +++ b/catalogbuilder/scripts/gen_intake_gfdl_runner.py @@ -0,0 +1,11 @@ +#!/usr/bin/env python + +from scripts import gen_intake_gfdl +import sys + +input_path = "/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" +output_path = "test" +sys.argv = ['INPUT_PATH', input_path, output_path] +print(sys.argv) +gen_intake_gfdl.main() + diff --git a/catalogbuilder/scripts/gen_intake_gfdl_runner_config.py b/catalogbuilder/scripts/gen_intake_gfdl_runner_config.py new file mode 100755 index 0000000..c7e019f --- /dev/null +++ b/catalogbuilder/scripts/gen_intake_gfdl_runner_config.py @@ -0,0 +1,9 @@ +#!/usr/bin/env python + +from scripts import gen_intake_gfdl +import sys + +sys.argv = ['input_path','--config', '/home/a1r/github/CatalogBuilder/scripts/configs/config-example.yml'] +print(sys.argv) +gen_intake_gfdl.main() + diff --git a/catalogbuilder/scripts/gen_intake_local.py b/catalogbuilder/scripts/gen_intake_local.py new file mode 100755 index 0000000..673cd16 --- /dev/null +++ b/catalogbuilder/scripts/gen_intake_local.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python + +import os +from intakebuilder import localcrawler, CSVwriter +import logging +logger = logging.getLogger('local') +hdlr = logging.FileHandler('/nbhome/a1r/logs/local.log') +logger.addHandler(hdlr) +logger.setLevel(logging.INFO) + +def main(): + #######INPUT HERE OR USE FROM A CONFIG FILE LATER###### +# project_dir = "/Users/ar46/data_cmip6/CMIP6/" # DRS COMPLIANT PROJECT DIR + project_dir = "/uda/CMIP6/"# + #CMIP/NOAA-GFDL/GFDL-ESM4/" + csvfile = "/nbhome/a1r/intakebuilder_cats/intake_local.csv" ##"/Users/ar46/PycharmProjects/CatalogBuilder/intakebuilder/test/intake_local.csv" + ####################################################### + ######### SEARCH FILTERS ########################### + dictFilter = {} + dictFilter["source_prefix"]= 'CMIP6/' #CMIP/CMCC/CMCC-CM2-SR5' #'CMIP6/CMIP/' #NOAA-GFDL/GFDL-CM4/' #/CMIP/NOAA-GFDL/GFDL-ESM4/' #Must specify something here, at least the project level + #COMMENT dictFilter["miptable"] = "Amon" #Remove this if you don't want to filter by miptable + #COMMENT dictFilter["varname"] = "tas" #Remove this if you don't want to filter by variable name + ######################################################### + dictInfo = {} + project_dir = project_dir.rstrip("/") + logger.info("Calling localcrawler.crawlLocal") + print("Calling localcrawler.crawlLocal") + list_files = localcrawler.crawlLocal(project_dir, dictFilter, logger) + headers = CSVwriter.getHeader() + if (not os.path.exists(csvfile)): + os.makedirs(os.path.dirname(csvfile), exist_ok=True) + CSVwriter.listdict_to_csv(list_files, headers, csvfile) + print("CSV generated at:", os.path.abspath(csvfile)) + logger.info("CSV generated at"+ os.path.abspath(csvfile)) +if __name__ == '__main__': + main() diff --git a/catalogbuilder/scripts/gen_intake_s3.py b/catalogbuilder/scripts/gen_intake_s3.py new file mode 100755 index 0000000..69a8afb --- /dev/null +++ b/catalogbuilder/scripts/gen_intake_s3.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +import os +from intakebuilder import getinfo, s3crawler, CSVwriter +import logging +logger = logging.getLogger('local') +hdlr = logging.FileHandler('/Users/ar46/logs/local.log') +logger.addHandler(hdlr) +logger.setLevel(logging.INFO) + +def main(): + #######INPUT HERE OR USE FROM A CONFIG FILE LATER###### + region = 'us-east-1' #which region is the bucket in? + project_root = 's3://esgf-world/CMIP6/' #DRS Compliant bucket + csvfile = "/Users/ar46/PycharmProjects/CatalogBuilder/intakebuilder/test/intake_s3.csv" + ######### SEARCH FILTERS ########################### + dictFilter = {} + dictFilter["source_prefix"]= 'CMIP6/' #/CMIP/NOAA-GFDL/GFDL-ESM4/' #Must specify something here, at least the project level + #COMMENT dictFilter["miptable"] = "Amon" #Remove this if you don't want to filter by miptable + #COMMENT dictFilter["varname"] = "tas" #Remove this if you don't want to filter by variable name + ####################################################### + project_bucket = project_root.split("/")[1].lstrip("/") + project_name = project_root.split("/")[2] + dictInfo = {} + print(project_root) + project_root = project_root.rstrip("/") + logger.info("Running s3crawler.sss_crawler") + list_files = s3crawler.sss_crawler(project_root,dictFilter, project_root,logger) + print(list_files) + #TODO make search strings a dict for later + #merge project_root and project_bucket as needed + headers = CSVwriter.getHeader() + if (not os.path.exists(csvfile)): + os.makedirs(os.path.dirname(csvfile), exist_ok=True) + CSVwriter.listdict_to_csv(list_files, headers, csvfile) + logger.info("CSV generated at"+ os.path.abspath(csvfile)) + +if __name__ == '__main__': + main() diff --git a/catalogbuilder/scripts/test_catalog.py b/catalogbuilder/scripts/test_catalog.py new file mode 100755 index 0000000..c52e8b6 --- /dev/null +++ b/catalogbuilder/scripts/test_catalog.py @@ -0,0 +1,70 @@ +#!/usr/bin/env python + +import click +import json +from jsondiff import diff +import pandas as pd +import sys + +@click.command() +@click.argument('json_path', nargs = 1 , required = True) +@click.argument('json_template_path', nargs = 1 , required = False) +@click.option('-tf', '--test-failure', is_flag=True, default = False, help="Errors are only printed. Program will not exit.") +def main(json_path,json_template_path,test_failure): + + """ This test ensures catalogs generated by the Catalog Builder tool are minimally valid. This means a few things: the generated catalog JSON file reflects the template it was generated with, the catalog CSV has atleast one row of values (not headers), and each required column exists without any empty values. If a test case is broken or expected to fail, the --test-failure/-tf flag can be used. This flag will simply print errors instead of doing a sys.exit. + + JSON_PATH: Path to generated schema to be tested + + JSON_TEMPLATE_PATH: Path of schema template. Without a given path, cats/gfdl_template.json will be used for comparison """ + + #Open JSON + j = json.load(open(json_path)) + if json_template_path: + json_template = json.load(open(json_template_path)) + else: + json_template = json.load(open('cats/gfdl_template.json')) + + #Validate JSON against JSON template + comp = (diff(j,json_template)) + for key in comp.keys(): + if key != 'catalog_file': + if test_failure: + print(key + ' section of JSON does not refect template') + else: + sys.exit(key + ' section of JSON does not refect template') + + #Get CSV from JSON and open it + csv_path = j["catalog_file"] + catalog = pd.read_csv(csv_path) + + if len(catalog.index) < 1: + if test_failure: + print("Catalog has no values") + else: + sys.exit("Catalog has no values") + + #Get required columns + req = (j["aggregation_control"]["groupby_attrs"]) + + #Check the csv headers for required columns/values + errors = 0 + for column in req: + if column not in catalog.columns: + print(f"The required column '{column}' does not exist in the csv. In other words, there is some inconsistency between the json and the csv file. Please check out info listed under aggregation_control and groupby_attrs in your json file and verify if those columns show up in the csv as well.") + errors += 1 + + if column in catalog.columns: + if(catalog[column].isnull().values.any()): + print(f"'{column}' contains empty values.") + errors += 1 + + if errors > 0: + if test_failure: + print(f"Found {errors} errors.") + else: + sys.exit(f"Found {errors} errors.") + +if __name__ == '__main__': + main() + From 5bdc2f0093e9da341f0a38cf56bb8351255d82e7 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 13:38:17 -0400 Subject: [PATCH 05/40] Update meta.yaml --- meta.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/meta.yaml b/meta.yaml index eb3e8d1..8cb6bc8 100644 --- a/meta.yaml +++ b/meta.yaml @@ -25,5 +25,7 @@ requirements: test: imports: - catalogbuilder + - catalogbuilder.scripts + - catalogbuilder.cats about: home: From 9d6048f9ba49ff5dfdae16a0d2a911000ea4d64c Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 13:42:09 -0400 Subject: [PATCH 06/40] Update publish-conda.yml --- .github/workflows/publish-conda.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/publish-conda.yml b/.github/workflows/publish-conda.yml index 1f70a17..c78f5e6 100644 --- a/.github/workflows/publish-conda.yml +++ b/.github/workflows/publish-conda.yml @@ -1,6 +1,6 @@ name: publish_conda on: - push: + pull_request: branches: - main jobs: From bdf63129b3ad5d361d25f5e31bf963a78fdd4254 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 13:45:49 -0400 Subject: [PATCH 07/40] Delete scripts/__init__.py check for failure points without removing it all --- scripts/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 scripts/__init__.py diff --git a/scripts/__init__.py b/scripts/__init__.py deleted file mode 100644 index e69de29..0000000 From 00fc5568fd65b4eabdde4532f0d17c9ed373603d Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 13:46:10 -0400 Subject: [PATCH 08/40] Delete intakebuilder/__init__.py checking for failure points --- intakebuilder/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 intakebuilder/__init__.py diff --git a/intakebuilder/__init__.py b/intakebuilder/__init__.py deleted file mode 100644 index e69de29..0000000 From b8175a0664d11b3d674be98c7761628c5380b049 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 13:48:13 -0400 Subject: [PATCH 09/40] Update publish-conda.yml --- .github/workflows/publish-conda.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/publish-conda.yml b/.github/workflows/publish-conda.yml index c78f5e6..5fa390d 100644 --- a/.github/workflows/publish-conda.yml +++ b/.github/workflows/publish-conda.yml @@ -2,7 +2,8 @@ name: publish_conda on: pull_request: branches: - - main + #for testing the restructuring, put back to main and on push only later. + - subpkgtest jobs: build_and_publish: runs-on: ubuntu-latest From 97283dd156253fe1bbb08871b0d794e597fdd1cf Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 13:51:29 -0400 Subject: [PATCH 10/40] Update create-gfdl-catalog.yml --- .github/workflows/create-gfdl-catalog.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/create-gfdl-catalog.yml b/.github/workflows/create-gfdl-catalog.yml index 24f05dc..28977ff 100644 --- a/.github/workflows/create-gfdl-catalog.yml +++ b/.github/workflows/create-gfdl-catalog.yml @@ -29,10 +29,10 @@ jobs: run: python tests/make_sample_data.py - name: 'Generate catalog' run: | - $CONDA/envs/catalogbuilder/bin/python scripts/gen_intake_gfdl.py archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp gfdl_autotest + $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/gen_intake_gfdl.py archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp gfdl_autotest - name: 'Generate catalog with yaml' run: | - $CONDA/envs/catalogbuilder/bin/python scripts/gen_intake_gfdl.py --config tests/test_config.yaml + $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/gen_intake_gfdl.py --config tests/test_config.yaml - name: upload-artifacts1 uses: actions/upload-artifact@v4 with: @@ -50,5 +50,5 @@ jobs: $CONDA/envs/catalogbuilder/bin/pytest -v --runxfail - name: Test for completeness run: | - $CONDA/envs/catalogbuilder/bin/python scripts/test_catalog.py -tf gfdl_autotest.json cats/gfdl_template.json - $CONDA/envs/catalogbuilder/bin/python scripts/test_catalog.py -tf cats/gfdl_autotest_from_yaml.json + $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/test_catalog.py -tf gfdl_autotest.json cats/gfdl_template.json + $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/test_catalog.py -tf cats/gfdl_autotest_from_yaml.json From 31e6e6ec1f457d62d76825278be4bdd936aba56f Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 13:54:42 -0400 Subject: [PATCH 11/40] Update publish-conda.yml --- .github/workflows/publish-conda.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/publish-conda.yml b/.github/workflows/publish-conda.yml index 5fa390d..580a588 100644 --- a/.github/workflows/publish-conda.yml +++ b/.github/workflows/publish-conda.yml @@ -2,8 +2,8 @@ name: publish_conda on: pull_request: branches: - #for testing the restructuring, put back to main and on push only later. - - subpkgtest + #for testing the restructuring, back on push only later. + - main jobs: build_and_publish: runs-on: ubuntu-latest From 839b7bf7536ce0fe52af950c55dde95fc160a127 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 14:07:18 -0400 Subject: [PATCH 12/40] Update meta.yaml --- meta.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/meta.yaml b/meta.yaml index 8cb6bc8..a16f1bf 100644 --- a/meta.yaml +++ b/meta.yaml @@ -3,7 +3,7 @@ package: version: 2.0.1 source: - git_url: https://github.com/aradhakrishnanGFDL/CatalogBuilder.git + git_url: https://github.com/NOAA-GFDL/CatalogBuilder/CatalogBuilder.git path: . build: From 6dd741088f3b8b2301cefd7c31a2b16423ccdad1 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 14:16:18 -0400 Subject: [PATCH 13/40] Delete scripts directory --- scripts/configs/config-example.yml | 2 - scripts/configs/config-template.yaml | 41 - scripts/gen_intake_gfdl.py | 112 - scripts/gen_intake_gfdl_notebook.ipynb | 4829 ---------------------- scripts/gen_intake_gfdl_runner.py | 11 - scripts/gen_intake_gfdl_runner_config.py | 9 - scripts/gen_intake_local.py | 36 - scripts/gen_intake_s3.py | 38 - scripts/test_catalog.py | 70 - 9 files changed, 5148 deletions(-) delete mode 100644 scripts/configs/config-example.yml delete mode 100644 scripts/configs/config-template.yaml delete mode 100755 scripts/gen_intake_gfdl.py delete mode 100644 scripts/gen_intake_gfdl_notebook.ipynb delete mode 100755 scripts/gen_intake_gfdl_runner.py delete mode 100755 scripts/gen_intake_gfdl_runner_config.py delete mode 100755 scripts/gen_intake_local.py delete mode 100755 scripts/gen_intake_s3.py delete mode 100755 scripts/test_catalog.py diff --git a/scripts/configs/config-example.yml b/scripts/configs/config-example.yml deleted file mode 100644 index 2013e59..0000000 --- a/scripts/configs/config-example.yml +++ /dev/null @@ -1,2 +0,0 @@ -input_path: "/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" #"ENTER INPUT PATH HERE" #Example: /Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" -output_path: "catalog" # ENTER NAME OF THE CSV AND JSON, THE SUFFIX ALONE. e.g catalog (the builder then generates catalog.csv and catalog.json. This can also be an absolute path) diff --git a/scripts/configs/config-template.yaml b/scripts/configs/config-template.yaml deleted file mode 100644 index 8d04a20..0000000 --- a/scripts/configs/config-template.yaml +++ /dev/null @@ -1,41 +0,0 @@ -#what kind of directory structure to expect? -#For a directory structure like /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp -# the output_path_template is set as follows. -#We have NA in those values that do not match up with any of the expected headerlist (CSV columns), otherwise we -#simply specify the associated header name in the appropriate place. E.g. The third directory in the PP path example -#above is the model (source_id), so the third list value in output_path_template is set to 'source_id'. We make sure -#this is a valid value in headerlist as well. -#The fourth directory is am5f3b1r0 which does not map to an existing header value. So we simply NA in output_path_template -#for the fourth value. - -#catalog headers -#The headerlist is expected column names in your catalog/csv file. This is usually determined by the users in conjuction -#with the ESM collection specification standards and the appropriate workflows. - -headerlist: ["activity_id", "institution_id", "source_id", "experiment_id", - "frequency", "modeling_realm", "table_id", - "member_id", "grid_label", "variable_id", - "temporal_subset", "chunk_freq","grid_label","platform","dimensions","cell_methods","path"] - -#what kind of directory structure to expect? -#For a directory structure like /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp -# the output_path_template is set as follows. -#We have NA in those values that do not match up with any of the expected headerlist (CSV columns), otherwise we -#simply specify the associated header name in the appropriate place. E.g. The third directory in the PP path example -#above is the model (source_id), so the third list value in output_path_template is set to 'source_id'. We make sure -#this is a valid value in headerlist as well. -#The fourth directory is am5f3b1r0 which does not map to an existing header value. So we simply NA in output_path_template -#for the fourth value. - -output_path_template: ['NA','NA','source_id','NA','experiment_id','platform','custom_pp','modeling_realm','cell_methods','frequency','chunk_freq'] - -output_file_template: ['modeling_realm','temporal_subset','variable_id'] - -#OUTPUT FILE INFO is currently passed as command-line argument. -#We will revisit adding a csvfile, jsonfile and logfile configuration to the builder configuration file in the future. -#csvfile = #jsonfile = #logfile = - -####################################################### - -input_path: "/Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" #"ENTER INPUT PATH HERE" #Example: /Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" -output_path: "catalog" # ENTER NAME OF THE CSV AND JSON, THE SUFFIX ALONE. e.g catalog (the builder then generates catalog.csv and catalog.json. This can also be an absolute path) diff --git a/scripts/gen_intake_gfdl.py b/scripts/gen_intake_gfdl.py deleted file mode 100755 index a99b667..0000000 --- a/scripts/gen_intake_gfdl.py +++ /dev/null @@ -1,112 +0,0 @@ -#!/usr/bin/env python - -import json -import sys -import click -import os -from pathlib import Path -import logging - -logger = logging.getLogger('local') -logger.setLevel(logging.INFO) - -try: - from intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser -except ModuleNotFoundError: - print("The module intakebuilder is not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") - print("Attempting again with adjusted sys.path ") - try: - sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) - except: - print("Unable to adjust sys.path") - #print(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) - try: - from intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser - except ModuleNotFoundError: - sys.exit("The module 'intakebuilder' is still not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") - -package_dir = os.path.dirname(os.path.abspath(__file__)) -template_path = os.path.join(package_dir, '../cats/gfdl_template.json') - -#Setting up argument parsing/flags -@click.command() -#TODO arguments dont have help message. So consider changing arguments to options? -@click.argument('input_path',required=False,nargs=1) -#,help='The directory path with the datasets to be cataloged. E.g a GFDL PP path till /pp') -@click.argument('output_path',required=False,nargs=1) -#,help='Specify output filename suffix only. e.g. catalog') -@click.option('--config',required=False,type=click.Path(exists=True),nargs=1,help='Path to your yaml config, Use the config_template in intakebuilder repo') -@click.option('--filter_realm', nargs=1) -@click.option('--filter_freq', nargs=1) -@click.option('--filter_chunk', nargs=1) -@click.option('--overwrite', is_flag=True, default=False) -@click.option('--append', is_flag=True, default=False) -def main(input_path=None, output_path=None, config=None, filter_realm=None, filter_freq=None, filter_chunk=None, - overwrite=False, append=False): - - configyaml = None - # TODO error catching - #print("input path: ",input_path, " output path: ", output_path) - if input_path is None or output_path is None: - print("No paths given, using yaml configuration") - configyaml = configparser.Config(config) - if configyaml.input_path is None or not configyaml.input_path : - sys.exit("Can't find paths, is yaml configured?") - - input_path = configyaml.input_path - output_path = configyaml.output_path - - if not os.path.exists(input_path): - sys.exit("Input path does not exist. Adjust configuration.") - if not os.path.exists(Path(output_path).parent.absolute()): - sys.exit("Output path parent directory does not exist. Adjust configuration.") - project_dir = input_path - csv_path = "{0}.csv".format(output_path) - json_path = "{0}.json".format(output_path) - - ######### SEARCH FILTERS ########################### - - dictFilter = {} - dictFilterIgnore = {} - if filter_realm: - dictFilter["modeling_realm"] = filter_realm - if filter_freq: - dictFilter["frequency"] = filter_freq - if filter_chunk: - dictFilter["chunk_freq"] = filter_chunk - - ''' Override config file if necessary for dev - project_dir = "/archive/oar.gfdl.cmip6/ESM4/DECK/ESM4_1pctCO2_D1/gfdl.ncrc4-intel16-prod-openmp/pp/" - #for dev csvfile = "/nbhome/$USER/intakebuilder_cats/intake_gfdl2.csv" - dictFilterIgnore = {} - dictFilter["modeling_realm"]= 'atmos_cmip' - dictFilter["frequency"] = "monthly" - dictFilter["chunk_freq"] = "5yr" - dictFilterIgnore["remove"]= 'DO_NOT_USE' - ''' - ######################################################### - dictInfo = {} - project_dir = project_dir.rstrip("/") - logger.info("Calling gfdlcrawler.crawlLocal") - list_files = gfdlcrawler.crawlLocal(project_dir, dictFilter, dictFilterIgnore, logger, configyaml) - #Grabbing data from template JSON, changing CSV path to match output path, and dumping data in new JSON - with open(template_path, "r") as jsonTemplate: - data = json.load(jsonTemplate) - data["catalog_file"] = os.path.abspath(csv_path) - jsonFile = open(json_path, "w") - json.dump(data, jsonFile, indent=2) - jsonFile.close() - headers = CSVwriter.getHeader(configyaml) - - # When we pass relative path or just the filename the following still needs to not choke - # so we check if it's a directory first - if os.path.isdir(os.path.dirname(csv_path)): - os.makedirs(os.path.dirname(csv_path), exist_ok=True) - CSVwriter.listdict_to_csv(list_files, headers, csv_path, overwrite, append) - print("JSON generated at:", os.path.abspath(json_path)) - print("CSV generated at:", os.path.abspath(csv_path)) - logger.info("CSV generated at" + os.path.abspath(csv_path)) - - -if __name__ == '__main__': - main() diff --git a/scripts/gen_intake_gfdl_notebook.ipynb b/scripts/gen_intake_gfdl_notebook.ipynb deleted file mode 100644 index 5ec2ff2..0000000 --- a/scripts/gen_intake_gfdl_notebook.ipynb +++ /dev/null @@ -1,4829 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "f39f9409-ee87-4431-9953-55607daba427", - "metadata": {}, - "source": [ - "This notebook was tested from a GFDL workstation.\n", - "This notebook is an example of using catalog builder from a notebook to generate data catalogs, a.k.a intake-esm catalogs.\n", - "\n", - "How to get here? \n", - "\n", - "Login to your workstation at GFDL.\n", - "module load python/3.9\n", - "conda activate intakebuilder \n", - "(For the above: Note that you can either install your own environment using the following or use an existing environment such as this: conda activate /nbhome/Aparna.Radhakrishnan/conda/envs/intakebuilder )\n", - "\n", - "conda create -n intakebuilder \n", - "conda install intakebuilder -c noaa-gfdl -n intakebuilder\n", - "\n", - "Now, we do a couple of things to make sure your environment is available to jupyter-lab as a kernel.\n", - "\n", - "pip install ipykernel \n", - "python -m ipykernel install --user --name=intakebuilder\n", - "\n", - "Now, start a jupyter-lab session from GFDL workstation: \n", - "\n", - "jupyter-lab \n", - "\n", - "This will give you the URL to the jupyter-lab session running on your localhost. Paste the URL in your web-browser (or via TigerVNC). Paste the notebook cells from this notebook, or locate the notebook from the path where you have downloaded or cloned it via git. Go to Kernel->Change Kernel-> Choose intakebuilder.\n", - "\n", - "Run the notebook and see the results! Extend it and share it with us via a github issue. \n" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "fb3010b8-170f-4462-ad2a-457d1d5415f7", - "metadata": {}, - "outputs": [ - { - "name": "stdin", - "output_type": "stream", - "text": [ - "Found existing file! Overwrite? (y/n) y\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "writing..\n", - "JSON generated at: /home/a1r/mycatalog.json\n", - "CSV generated at: /home/a1r/mycatalog.csv\n" - ] - } - ], - "source": [ - "from scripts import gen_intake_gfdl\n", - "import sys,os\n", - "\n", - "######USER input begins########\n", - "\n", - "#User provides the input directory for which a data catalog needs to be generated.\n", - "#Note that depending on the date and version of the tool, only time-series data are catalogued.\n", - "\n", - "input_path = \"/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/\"\n", - "\n", - "#USER inputs the output path. Based on the following setting, user can expect to see /home/a1r/mycatalog.csv and /home/a1r/mycatalog.json generated as output.\n", - "\n", - "output_path = \"/home/a1r/mycatalog\"\n", - "\n", - "####END OF user input ##########\n", - "sys.argv = ['--INPUT_PATH', input_path, output_path]\n", - "\n", - "try:\n", - " gen_intake_gfdl.main()\n", - "except SystemExit as e:\n", - " if e.code != 0:\n", - " raise" - ] - }, - { - "cell_type": "markdown", - "id": "626eaa1f-d801-4a7d-8fad-2851c9e81070", - "metadata": {}, - "source": [ - "Let's begin our analysis" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "id": "181913cc-4776-4b16-95d6-c6ea1b2cbdad", - "metadata": {}, - "outputs": [], - "source": [ - "import intake_esm, intake\n", - "import matplotlib #do a pip install of tools needed in your env or from the notebook\n", - "from matplotlib import pyplot as plt\n", - "%matplotlib inline\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6665a48b-a335-4fc2-8130-1a4902a428b0", - "metadata": {}, - "outputs": [], - "source": [ - "pip install matplotlib" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "0f83dbc3-3dda-4a43-82e9-fb8726b2cda8", - "metadata": {}, - "outputs": [], - "source": [ - "col_url = \"/home/a1r/mycatalog.json\"\n", - "col = intake.open_esm_datastore(col_url)" - ] - }, - { - "cell_type": "markdown", - "id": "344ada01-6716-4fbd-9cee-878ff815d7dd", - "metadata": {}, - "source": [ - "Explore the catalog" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "1ce0716e-6667-4aeb-8c4b-50a05643b87f", - "metadata": {}, - "outputs": [ - { - "data": { - "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", - "
activity_idinstitution_idsource_idexperiment_idfrequencymodeling_realmtable_idmember_idgrid_labelvariable_idtemporal_subsetchunk_freqgrid_label.1platformdimensionscell_methodspath
0devNaNam5c96L65_am5f3b1r0_pdclim1850F3hratmos_cmipNaNNaNNaNpr0002010100-00021231231yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
1devNaNam5c96L65_am5f3b1r0_pdclim1850F3hratmos_cmipNaNNaNNaNrlut0002010100-00021231231yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
2devNaNam5c96L65_am5f3b1r0_pdclim1850F3hratmos_cmipNaNNaNNaNpr0003010100-00031231231yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
3devNaNam5c96L65_am5f3b1r0_pdclim1850F3hratmos_cmipNaNNaNNaNrlut0003010100-00031231231yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
4devNaNam5c96L65_am5f3b1r0_pdclim1850F3hratmos_cmipNaNNaNNaNpr0004010100-00041231231yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
......................................................
6405devNaNam5c96L65_am5f3b1r0_pdclim1850Fmonthlyland_cmipNaNNaNNaNtreeFracNdlDcd001001-0010121yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
6406devNaNam5c96L65_am5f3b1r0_pdclim1850Fmonthlyland_cmipNaNNaNNaNtreeFracNdlEvg001001-0010121yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
6407devNaNam5c96L65_am5f3b1r0_pdclim1850Fmonthlyland_cmipNaNNaNNaNtsl001001-0010121yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
6408devNaNam5c96L65_am5f3b1r0_pdclim1850Fmonthlyland_cmipNaNNaNNaNvegFrac001001-0010121yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
6409devNaNam5c96L65_am5f3b1r0_pdclim1850Fmonthlyland_cmipNaNNaNNaNvegHeight001001-0010121yrNaNgfdl.ncrc5-deploy-prod-openmpNaNts/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd...
\n", - "

6410 rows × 17 columns

\n", - "
" - ], - "text/plain": [ - " activity_id institution_id source_id experiment_id \\\n", - "0 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", - "1 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", - "2 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", - "3 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", - "4 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", - "... ... ... ... ... \n", - "6405 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", - "6406 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", - "6407 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", - "6408 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", - "6409 dev NaN am5 c96L65_am5f3b1r0_pdclim1850F \n", - "\n", - " frequency modeling_realm table_id member_id grid_label \\\n", - "0 3hr atmos_cmip NaN NaN NaN \n", - "1 3hr atmos_cmip NaN NaN NaN \n", - "2 3hr atmos_cmip NaN NaN NaN \n", - "3 3hr atmos_cmip NaN NaN NaN \n", - "4 3hr atmos_cmip NaN NaN NaN \n", - "... ... ... ... ... ... \n", - "6405 monthly land_cmip NaN NaN NaN \n", - "6406 monthly land_cmip NaN NaN NaN \n", - "6407 monthly land_cmip NaN NaN NaN \n", - "6408 monthly land_cmip NaN NaN NaN \n", - "6409 monthly land_cmip NaN NaN NaN \n", - "\n", - " variable_id temporal_subset chunk_freq grid_label.1 \\\n", - "0 pr 0002010100-0002123123 1yr NaN \n", - "1 rlut 0002010100-0002123123 1yr NaN \n", - "2 pr 0003010100-0003123123 1yr NaN \n", - "3 rlut 0003010100-0003123123 1yr NaN \n", - "4 pr 0004010100-0004123123 1yr NaN \n", - "... ... ... ... ... \n", - "6405 treeFracNdlDcd 001001-001012 1yr NaN \n", - "6406 treeFracNdlEvg 001001-001012 1yr NaN \n", - "6407 tsl 001001-001012 1yr NaN \n", - "6408 vegFrac 001001-001012 1yr NaN \n", - "6409 vegHeight 001001-001012 1yr NaN \n", - "\n", - " platform dimensions cell_methods \\\n", - "0 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", - "1 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", - "2 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", - "3 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", - "4 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", - "... ... ... ... \n", - "6405 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", - "6406 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", - "6407 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", - "6408 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", - "6409 gfdl.ncrc5-deploy-prod-openmp NaN ts \n", - "\n", - " path \n", - "0 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", - "1 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", - "2 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", - "3 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", - "4 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", - "... ... \n", - "6405 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", - "6406 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", - "6407 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", - "6408 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", - "6409 /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pd... \n", - "\n", - "[6410 rows x 17 columns]" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "col.df" - ] - }, - { - "cell_type": "markdown", - "id": "613f8259-a92f-4be5-8268-dfbe225f0670", - "metadata": {}, - "source": [ - "Let's narrow down the search" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "62acbaec-573c-47f9-83bc-015790fd7983", - "metadata": {}, - "outputs": [], - "source": [ - "expname_filter = ['c96L65_am5f3b1r0_pdclim1850F']\n", - "modeling_realm = \"land_cmip\"\n", - "frequency = \"daily\"" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "7fa86782-3f7b-4dbf-80af-0f035003d57f", - "metadata": {}, - "outputs": [], - "source": [ - "cat = col.search(experiment_id=expname_filter,frequency=frequency,modeling_realm=modeling_realm)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "6fe2cf2f-e74a-4b50-a099-47c28541878d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'hflsLut', 'mrso', 'mrsos'}" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "set(cat.df[\"variable_id\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "aa216969-e335-4448-977c-d623a62a697e", - "metadata": {}, - "outputs": [], - "source": [ - "cat = cat.search(variable_id=\"mrso\") #Total Soil Moisture Content" - ] - }, - { - "cell_type": "markdown", - "id": "8542c4e8-07eb-48ba-b466-8e07d3405415", - "metadata": {}, - "source": [ - "dmget the files" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "5227091c-5d83-4b73-a340-22e92124e1f7", - "metadata": {}, - "outputs": [], - "source": [ - "#for simple dmget usage, just use this !dmget {file}\n", - "#use following to wrap the dmget call for each path in the catalog\n", - "def dmgetmagic(x):\n", - " cmd = 'dmget %s'% str(x) \n", - " return os.system(cmd)\n", - "\n", - "#OR refer to importing dmget , https://github.com/aradhakrishnanGFDL/canopy-cats/tree/main/notebooks/dmget.py" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "5eb6b01e-4d68-48ee-904f-dd285be7dee5", - "metadata": {}, - "outputs": [], - "source": [ - "dmstatus = cat.df[\"path\"].apply(dmgetmagic)" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "id": "8b50305d-aac1-4df5-add1-fbc9af7773ab", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "--> The keys in the returned dictionary of datasets are constructed as follows:\n", - "\t'source_id.experiment_id.frequency.modeling_realm.variable_id.chunk_freq'\n", - " |████████████████████████████████████████| 100.00% [1/1 00:00<00:00]\r" - ] - } - ], - "source": [ - "dset_dict = cat.to_dataset_dict(cdf_kwargs={'chunks': {'time':5}, 'decode_times': True})" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "id": "f1c27413-e9a7-4855-b9be-1c0b9cf7f4ac", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "am5.c96L65_am5f3b1r0_pdclim1850F.daily.land_cmip.mrso.1yr\n" - ] - } - ], - "source": [ - "for k in dset_dict.keys(): \n", - " print(k)" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "id": "9aae260f-87c8-4d2a-9b55-b9587c1f2309", - "metadata": {}, - "outputs": [], - "source": [ - "ds = dset_dict[\"am5.c96L65_am5f3b1r0_pdclim1850F.daily.land_cmip.mrso.1yr\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "id": "c650221c-714e-4f2e-a53f-ca937c6c38ae", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset> Size: 757MB\n",
-       "Dimensions:     (time: 3650, bnds: 2, lat: 180, lon: 288)\n",
-       "Coordinates:\n",
-       "    average_DT  (time) timedelta64[ns] 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
-       "    average_T1  (time) object 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
-       "    average_T2  (time) object 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
-       "  * bnds        (bnds) float64 16B 1.0 2.0\n",
-       "  * lat         (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n",
-       "    lat_bnds    (lat, bnds) float64 3kB dask.array<chunksize=(180, 2), meta=np.ndarray>\n",
-       "  * lon         (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n",
-       "    lon_bnds    (lon, bnds) float64 5kB dask.array<chunksize=(288, 2), meta=np.ndarray>\n",
-       "  * time        (time) object 29kB 0002-01-01 12:00:00 ... 0011-12-31 12:00:00\n",
-       "    time_bnds   (time, bnds) object 58kB dask.array<chunksize=(5, 2), meta=np.ndarray>\n",
-       "Data variables:\n",
-       "    mrso        (time, lat, lon) float32 757MB dask.array<chunksize=(5, 180, 288), meta=np.ndarray>\n",
-       "Attributes: (12/18)\n",
-       "    title:                            c96L65_am5f3b1r0_pdclim1850F\n",
-       "    grid_type:                        regular\n",
-       "    grid_tile:                        N/A\n",
-       "    code_release_version:             2023.01\n",
-       "    git_hash:                         unknown githash\n",
-       "    external_variables:               land_area\n",
-       "    ...                               ...\n",
-       "    intake_esm_attrs:variable_id:     mrso\n",
-       "    intake_esm_attrs:chunk_freq:      1yr\n",
-       "    intake_esm_attrs:platform:        gfdl.ncrc5-deploy-prod-openmp\n",
-       "    intake_esm_attrs:cell_methods:    ts\n",
-       "    intake_esm_attrs:_data_format_:   netcdf\n",
-       "    intake_esm_dataset_key:           am5.c96L65_am5f3b1r0_pdclim1850F.daily....
" - ], - "text/plain": [ - " Size: 757MB\n", - "Dimensions: (time: 3650, bnds: 2, lat: 180, lon: 288)\n", - "Coordinates:\n", - " average_DT (time) timedelta64[ns] 29kB dask.array\n", - " average_T1 (time) object 29kB dask.array\n", - " average_T2 (time) object 29kB dask.array\n", - " * bnds (bnds) float64 16B 1.0 2.0\n", - " * lat (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n", - " lat_bnds (lat, bnds) float64 3kB dask.array\n", - " * lon (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n", - " lon_bnds (lon, bnds) float64 5kB dask.array\n", - " * time (time) object 29kB 0002-01-01 12:00:00 ... 0011-12-31 12:00:00\n", - " time_bnds (time, bnds) object 58kB dask.array\n", - "Data variables:\n", - " mrso (time, lat, lon) float32 757MB dask.array\n", - "Attributes: (12/18)\n", - " title: c96L65_am5f3b1r0_pdclim1850F\n", - " grid_type: regular\n", - " grid_tile: N/A\n", - " code_release_version: 2023.01\n", - " git_hash: unknown githash\n", - " external_variables: land_area\n", - " ... ...\n", - " intake_esm_attrs:variable_id: mrso\n", - " intake_esm_attrs:chunk_freq: 1yr\n", - " intake_esm_attrs:platform: gfdl.ncrc5-deploy-prod-openmp\n", - " intake_esm_attrs:cell_methods: ts\n", - " intake_esm_attrs:_data_format_: netcdf\n", - " intake_esm_dataset_key: am5.c96L65_am5f3b1r0_pdclim1850F.daily...." - ] - }, - "execution_count": 79, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "id": "84071a21-5f29-4554-99cb-7c02bda9d1f7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray 'mrso' (time: 3650, lat: 180, lon: 288)> Size: 757MB\n",
-       "dask.array<concatenate, shape=(3650, 180, 288), dtype=float32, chunksize=(5, 180, 288), chunktype=numpy.ndarray>\n",
-       "Coordinates:\n",
-       "    average_DT  (time) timedelta64[ns] 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
-       "    average_T1  (time) object 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
-       "    average_T2  (time) object 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
-       "  * lat         (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n",
-       "  * lon         (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n",
-       "  * time        (time) object 29kB 0002-01-01 12:00:00 ... 0011-12-31 12:00:00\n",
-       "Attributes:\n",
-       "    units:            kg m-2\n",
-       "    long_name:        Total Soil Moisture Content\n",
-       "    cell_methods:     area: mean time: mean\n",
-       "    ocean_fillvalue:  0.0\n",
-       "    cell_measures:    area: land_area\n",
-       "    time_avg_info:    average_T1,average_T2,average_DT\n",
-       "    standard_name:    soil_moisture_content\n",
-       "    interp_method:    conserve_order1
" - ], - "text/plain": [ - " Size: 757MB\n", - "dask.array\n", - "Coordinates:\n", - " average_DT (time) timedelta64[ns] 29kB dask.array\n", - " average_T1 (time) object 29kB dask.array\n", - " average_T2 (time) object 29kB dask.array\n", - " * lat (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n", - " * lon (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n", - " * time (time) object 29kB 0002-01-01 12:00:00 ... 0011-12-31 12:00:00\n", - "Attributes:\n", - " units: kg m-2\n", - " long_name: Total Soil Moisture Content\n", - " cell_methods: area: mean time: mean\n", - " ocean_fillvalue: 0.0\n", - " cell_measures: area: land_area\n", - " time_avg_info: average_T1,average_T2,average_DT\n", - " standard_name: soil_moisture_content\n", - " interp_method: conserve_order1" - ] - }, - "execution_count": 80, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds[\"mrso\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "id": "d8e8cd0c-5502-4564-bb12-a269781415ad", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "mrso = ds.mrso.isel(time=1).plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "68b4a24c-0720-476b-8061-c42c84608e5d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 53, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ds.mrso.mean(dim='time').plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "id": "9212d429-8cd2-4ef6-a498-2fed900091d9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 00020101-00021231\n", - "1 00030101-00031231\n", - "2 00040101-00041231\n", - "3 00050101-00051231\n", - "4 00060101-00061231\n", - "5 00070101-00071231\n", - "6 00080101-00081231\n", - "7 00090101-00091231\n", - "8 00110101-00111231\n", - "9 00100101-00101231\n", - "Name: temporal_subset, dtype: object" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cat.df['temporal_subset'] " - ] - }, - { - "cell_type": "markdown", - "id": "06746aff-889b-4c67-b2d7-fb5ae821a678", - "metadata": {}, - "source": [ - "Can I please leverage CF? " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6d7dadd5-7abd-4bf7-a6ca-e39d3c214b04", - "metadata": {}, - "outputs": [], - "source": [ - "pip install cf_xarray" - ] - }, - { - "cell_type": "markdown", - "id": "3f248b8e-2d65-469c-b41f-f1875fac7317", - "metadata": {}, - "source": [ - "#You may leverage the use of cf_xarray, xMIP etc to build your analyses from here. They all blend in." - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "id": "c47d02a6-c340-45f6-8f84-f26e691358ca", - "metadata": {}, - "outputs": [], - "source": [ - "import xarray as xr\n", - "import cf_xarray as cfxr" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "id": "c6cb19f4-6409-4e32-9119-b0d51b42eb33", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset> Size: 757MB\n",
-       "Dimensions:     (time: 3650, bnds: 2, lat: 180, lon: 288)\n",
-       "Coordinates:\n",
-       "    average_DT  (time) timedelta64[ns] 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
-       "    average_T1  (time) object 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
-       "    average_T2  (time) object 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
-       "  * bnds        (bnds) float64 16B 1.0 2.0\n",
-       "  * lat         (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n",
-       "    lat_bnds    (lat, bnds) float64 3kB dask.array<chunksize=(180, 2), meta=np.ndarray>\n",
-       "  * lon         (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n",
-       "    lon_bnds    (lon, bnds) float64 5kB dask.array<chunksize=(288, 2), meta=np.ndarray>\n",
-       "  * time        (time) object 29kB 0002-01-01 12:00:00 ... 0011-12-31 12:00:00\n",
-       "    time_bnds   (time, bnds) object 58kB dask.array<chunksize=(5, 2), meta=np.ndarray>\n",
-       "Data variables:\n",
-       "    mrso        (time, lat, lon) float32 757MB dask.array<chunksize=(5, 180, 288), meta=np.ndarray>\n",
-       "Attributes: (12/18)\n",
-       "    title:                            c96L65_am5f3b1r0_pdclim1850F\n",
-       "    grid_type:                        regular\n",
-       "    grid_tile:                        N/A\n",
-       "    code_release_version:             2023.01\n",
-       "    git_hash:                         unknown githash\n",
-       "    external_variables:               land_area\n",
-       "    ...                               ...\n",
-       "    intake_esm_attrs:variable_id:     mrso\n",
-       "    intake_esm_attrs:chunk_freq:      1yr\n",
-       "    intake_esm_attrs:platform:        gfdl.ncrc5-deploy-prod-openmp\n",
-       "    intake_esm_attrs:cell_methods:    ts\n",
-       "    intake_esm_attrs:_data_format_:   netcdf\n",
-       "    intake_esm_dataset_key:           am5.c96L65_am5f3b1r0_pdclim1850F.daily....
" - ], - "text/plain": [ - " Size: 757MB\n", - "Dimensions: (time: 3650, bnds: 2, lat: 180, lon: 288)\n", - "Coordinates:\n", - " average_DT (time) timedelta64[ns] 29kB dask.array\n", - " average_T1 (time) object 29kB dask.array\n", - " average_T2 (time) object 29kB dask.array\n", - " * bnds (bnds) float64 16B 1.0 2.0\n", - " * lat (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n", - " lat_bnds (lat, bnds) float64 3kB dask.array\n", - " * lon (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n", - " lon_bnds (lon, bnds) float64 5kB dask.array\n", - " * time (time) object 29kB 0002-01-01 12:00:00 ... 0011-12-31 12:00:00\n", - " time_bnds (time, bnds) object 58kB dask.array\n", - "Data variables:\n", - " mrso (time, lat, lon) float32 757MB dask.array\n", - "Attributes: (12/18)\n", - " title: c96L65_am5f3b1r0_pdclim1850F\n", - " grid_type: regular\n", - " grid_tile: N/A\n", - " code_release_version: 2023.01\n", - " git_hash: unknown githash\n", - " external_variables: land_area\n", - " ... ...\n", - " intake_esm_attrs:variable_id: mrso\n", - " intake_esm_attrs:chunk_freq: 1yr\n", - " intake_esm_attrs:platform: gfdl.ncrc5-deploy-prod-openmp\n", - " intake_esm_attrs:cell_methods: ts\n", - " intake_esm_attrs:_data_format_: netcdf\n", - " intake_esm_dataset_key: am5.c96L65_am5f3b1r0_pdclim1850F.daily...." - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "xr.decode_cf(ds)" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "id": "0dc03c24-25b6-48f6-9c44-d8bb677244eb", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray 'mrso' (time: 0, lat: 180, lon: 288)> Size: 0B\n",
-       "dask.array<getitem, shape=(0, 180, 288), dtype=float32, chunksize=(0, 180, 288), chunktype=numpy.ndarray>\n",
-       "Coordinates:\n",
-       "    average_DT  (time) float64 0B dask.array<chunksize=(0,), meta=np.ndarray>\n",
-       "    average_T1  (time) float64 0B dask.array<chunksize=(0,), meta=np.ndarray>\n",
-       "    average_T2  (time) float64 0B dask.array<chunksize=(0,), meta=np.ndarray>\n",
-       "  * lat         (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n",
-       "  * lon         (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n",
-       "  * time        (time) float64 0B \n",
-       "Attributes:\n",
-       "    units:            kg m-2\n",
-       "    long_name:        Total Soil Moisture Content\n",
-       "    cell_methods:     area: mean time: mean\n",
-       "    ocean_fillvalue:  0.0\n",
-       "    cell_measures:    area: land_area\n",
-       "    time_avg_info:    average_T1,average_T2,average_DT\n",
-       "    standard_name:    soil_moisture_content\n",
-       "    interp_method:    conserve_order1
" - ], - "text/plain": [ - " Size: 0B\n", - "dask.array\n", - "Coordinates:\n", - " average_DT (time) float64 0B dask.array\n", - " average_T1 (time) float64 0B dask.array\n", - " average_T2 (time) float64 0B dask.array\n", - " * lat (lat) float64 1kB -89.5 -88.5 -87.5 -86.5 ... 87.5 88.5 89.5\n", - " * lon (lon) float64 2kB 0.625 1.875 3.125 4.375 ... 356.9 358.1 359.4\n", - " * time (time) float64 0B \n", - "Attributes:\n", - " units: kg m-2\n", - " long_name: Total Soil Moisture Content\n", - " cell_methods: area: mean time: mean\n", - " ocean_fillvalue: 0.0\n", - " cell_measures: area: land_area\n", - " time_avg_info: average_T1,average_T2,average_DT\n", - " standard_name: soil_moisture_content\n", - " interp_method: conserve_order1" - ] - }, - "execution_count": 74, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds.mrso.sel(time=slice(\"0002-01-01\",\"0004-01-01\"))" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "id": "4f443874-7a2d-4856-b687-84a8f02a0f83", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray 'time' (time: 3650)> Size: 29kB\n",
-       "array([ 365.5,  366.5,  367.5, ..., 4012.5, 4013.5, 4014.5])\n",
-       "Coordinates:\n",
-       "    average_DT  (time) float64 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
-       "    average_T1  (time) float64 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
-       "    average_T2  (time) float64 29kB dask.array<chunksize=(5,), meta=np.ndarray>\n",
-       "  * time        (time) float64 29kB 365.5 366.5 367.5 ... 4.014e+03 4.014e+03\n",
-       "Attributes:\n",
-       "    units:          days since 0001-01-01 00:00:00\n",
-       "    long_name:      time\n",
-       "    axis:           T\n",
-       "    calendar_type:  NOLEAP\n",
-       "    calendar:       noleap\n",
-       "    bounds:         time_bnds\n",
-       "    cell_methods:   time: mean
" - ], - "text/plain": [ - " Size: 29kB\n", - "array([ 365.5, 366.5, 367.5, ..., 4012.5, 4013.5, 4014.5])\n", - "Coordinates:\n", - " average_DT (time) float64 29kB dask.array\n", - " average_T1 (time) float64 29kB dask.array\n", - " average_T2 (time) float64 29kB dask.array\n", - " * time (time) float64 29kB 365.5 366.5 367.5 ... 4.014e+03 4.014e+03\n", - "Attributes:\n", - " units: days since 0001-01-01 00:00:00\n", - " long_name: time\n", - " axis: T\n", - " calendar_type: NOLEAP\n", - " calendar: noleap\n", - " bounds: time_bnds\n", - " cell_methods: time: mean" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds.mrso.time" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a61e9c94-5d20-44d1-9a0a-6dab48dc444c", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "intakebuilder", - "language": "python", - "name": "intakebuilder" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.2" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/scripts/gen_intake_gfdl_runner.py b/scripts/gen_intake_gfdl_runner.py deleted file mode 100755 index 920ede8..0000000 --- a/scripts/gen_intake_gfdl_runner.py +++ /dev/null @@ -1,11 +0,0 @@ -#!/usr/bin/env python - -from scripts import gen_intake_gfdl -import sys - -input_path = "/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" -output_path = "test" -sys.argv = ['INPUT_PATH', input_path, output_path] -print(sys.argv) -gen_intake_gfdl.main() - diff --git a/scripts/gen_intake_gfdl_runner_config.py b/scripts/gen_intake_gfdl_runner_config.py deleted file mode 100755 index c7e019f..0000000 --- a/scripts/gen_intake_gfdl_runner_config.py +++ /dev/null @@ -1,9 +0,0 @@ -#!/usr/bin/env python - -from scripts import gen_intake_gfdl -import sys - -sys.argv = ['input_path','--config', '/home/a1r/github/CatalogBuilder/scripts/configs/config-example.yml'] -print(sys.argv) -gen_intake_gfdl.main() - diff --git a/scripts/gen_intake_local.py b/scripts/gen_intake_local.py deleted file mode 100755 index 673cd16..0000000 --- a/scripts/gen_intake_local.py +++ /dev/null @@ -1,36 +0,0 @@ -#!/usr/bin/env python - -import os -from intakebuilder import localcrawler, CSVwriter -import logging -logger = logging.getLogger('local') -hdlr = logging.FileHandler('/nbhome/a1r/logs/local.log') -logger.addHandler(hdlr) -logger.setLevel(logging.INFO) - -def main(): - #######INPUT HERE OR USE FROM A CONFIG FILE LATER###### -# project_dir = "/Users/ar46/data_cmip6/CMIP6/" # DRS COMPLIANT PROJECT DIR - project_dir = "/uda/CMIP6/"# - #CMIP/NOAA-GFDL/GFDL-ESM4/" - csvfile = "/nbhome/a1r/intakebuilder_cats/intake_local.csv" ##"/Users/ar46/PycharmProjects/CatalogBuilder/intakebuilder/test/intake_local.csv" - ####################################################### - ######### SEARCH FILTERS ########################### - dictFilter = {} - dictFilter["source_prefix"]= 'CMIP6/' #CMIP/CMCC/CMCC-CM2-SR5' #'CMIP6/CMIP/' #NOAA-GFDL/GFDL-CM4/' #/CMIP/NOAA-GFDL/GFDL-ESM4/' #Must specify something here, at least the project level - #COMMENT dictFilter["miptable"] = "Amon" #Remove this if you don't want to filter by miptable - #COMMENT dictFilter["varname"] = "tas" #Remove this if you don't want to filter by variable name - ######################################################### - dictInfo = {} - project_dir = project_dir.rstrip("/") - logger.info("Calling localcrawler.crawlLocal") - print("Calling localcrawler.crawlLocal") - list_files = localcrawler.crawlLocal(project_dir, dictFilter, logger) - headers = CSVwriter.getHeader() - if (not os.path.exists(csvfile)): - os.makedirs(os.path.dirname(csvfile), exist_ok=True) - CSVwriter.listdict_to_csv(list_files, headers, csvfile) - print("CSV generated at:", os.path.abspath(csvfile)) - logger.info("CSV generated at"+ os.path.abspath(csvfile)) -if __name__ == '__main__': - main() diff --git a/scripts/gen_intake_s3.py b/scripts/gen_intake_s3.py deleted file mode 100755 index 69a8afb..0000000 --- a/scripts/gen_intake_s3.py +++ /dev/null @@ -1,38 +0,0 @@ -#!/usr/bin/env python3 -import os -from intakebuilder import getinfo, s3crawler, CSVwriter -import logging -logger = logging.getLogger('local') -hdlr = logging.FileHandler('/Users/ar46/logs/local.log') -logger.addHandler(hdlr) -logger.setLevel(logging.INFO) - -def main(): - #######INPUT HERE OR USE FROM A CONFIG FILE LATER###### - region = 'us-east-1' #which region is the bucket in? - project_root = 's3://esgf-world/CMIP6/' #DRS Compliant bucket - csvfile = "/Users/ar46/PycharmProjects/CatalogBuilder/intakebuilder/test/intake_s3.csv" - ######### SEARCH FILTERS ########################### - dictFilter = {} - dictFilter["source_prefix"]= 'CMIP6/' #/CMIP/NOAA-GFDL/GFDL-ESM4/' #Must specify something here, at least the project level - #COMMENT dictFilter["miptable"] = "Amon" #Remove this if you don't want to filter by miptable - #COMMENT dictFilter["varname"] = "tas" #Remove this if you don't want to filter by variable name - ####################################################### - project_bucket = project_root.split("/")[1].lstrip("/") - project_name = project_root.split("/")[2] - dictInfo = {} - print(project_root) - project_root = project_root.rstrip("/") - logger.info("Running s3crawler.sss_crawler") - list_files = s3crawler.sss_crawler(project_root,dictFilter, project_root,logger) - print(list_files) - #TODO make search strings a dict for later - #merge project_root and project_bucket as needed - headers = CSVwriter.getHeader() - if (not os.path.exists(csvfile)): - os.makedirs(os.path.dirname(csvfile), exist_ok=True) - CSVwriter.listdict_to_csv(list_files, headers, csvfile) - logger.info("CSV generated at"+ os.path.abspath(csvfile)) - -if __name__ == '__main__': - main() diff --git a/scripts/test_catalog.py b/scripts/test_catalog.py deleted file mode 100755 index c52e8b6..0000000 --- a/scripts/test_catalog.py +++ /dev/null @@ -1,70 +0,0 @@ -#!/usr/bin/env python - -import click -import json -from jsondiff import diff -import pandas as pd -import sys - -@click.command() -@click.argument('json_path', nargs = 1 , required = True) -@click.argument('json_template_path', nargs = 1 , required = False) -@click.option('-tf', '--test-failure', is_flag=True, default = False, help="Errors are only printed. Program will not exit.") -def main(json_path,json_template_path,test_failure): - - """ This test ensures catalogs generated by the Catalog Builder tool are minimally valid. This means a few things: the generated catalog JSON file reflects the template it was generated with, the catalog CSV has atleast one row of values (not headers), and each required column exists without any empty values. If a test case is broken or expected to fail, the --test-failure/-tf flag can be used. This flag will simply print errors instead of doing a sys.exit. - - JSON_PATH: Path to generated schema to be tested - - JSON_TEMPLATE_PATH: Path of schema template. Without a given path, cats/gfdl_template.json will be used for comparison """ - - #Open JSON - j = json.load(open(json_path)) - if json_template_path: - json_template = json.load(open(json_template_path)) - else: - json_template = json.load(open('cats/gfdl_template.json')) - - #Validate JSON against JSON template - comp = (diff(j,json_template)) - for key in comp.keys(): - if key != 'catalog_file': - if test_failure: - print(key + ' section of JSON does not refect template') - else: - sys.exit(key + ' section of JSON does not refect template') - - #Get CSV from JSON and open it - csv_path = j["catalog_file"] - catalog = pd.read_csv(csv_path) - - if len(catalog.index) < 1: - if test_failure: - print("Catalog has no values") - else: - sys.exit("Catalog has no values") - - #Get required columns - req = (j["aggregation_control"]["groupby_attrs"]) - - #Check the csv headers for required columns/values - errors = 0 - for column in req: - if column not in catalog.columns: - print(f"The required column '{column}' does not exist in the csv. In other words, there is some inconsistency between the json and the csv file. Please check out info listed under aggregation_control and groupby_attrs in your json file and verify if those columns show up in the csv as well.") - errors += 1 - - if column in catalog.columns: - if(catalog[column].isnull().values.any()): - print(f"'{column}' contains empty values.") - errors += 1 - - if errors > 0: - if test_failure: - print(f"Found {errors} errors.") - else: - sys.exit(f"Found {errors} errors.") - -if __name__ == '__main__': - main() - From 6e8ae71f55d8e0cb0d162ee546852eee5f5bb2cf Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 14:16:31 -0400 Subject: [PATCH 14/40] Delete intakebuilder directory --- intakebuilder/CSVwriter.py | 98 ---------------- intakebuilder/builderconfig.py | 50 -------- intakebuilder/catalogcols.py | 4 - intakebuilder/config.yaml | 41 ------- intakebuilder/configparser.py | 33 ------ intakebuilder/getinfo.py | 206 --------------------------------- intakebuilder/gfdlcrawler.py | 78 ------------- intakebuilder/localcrawler.py | 57 --------- intakebuilder/s3crawler.py | 59 ---------- intakebuilder/table.yaml | 9 -- 10 files changed, 635 deletions(-) delete mode 100644 intakebuilder/CSVwriter.py delete mode 100644 intakebuilder/builderconfig.py delete mode 100644 intakebuilder/catalogcols.py delete mode 100644 intakebuilder/config.yaml delete mode 100644 intakebuilder/configparser.py delete mode 100644 intakebuilder/getinfo.py delete mode 100644 intakebuilder/gfdlcrawler.py delete mode 100644 intakebuilder/localcrawler.py delete mode 100644 intakebuilder/s3crawler.py delete mode 100644 intakebuilder/table.yaml diff --git a/intakebuilder/CSVwriter.py b/intakebuilder/CSVwriter.py deleted file mode 100644 index 9a6a33f..0000000 --- a/intakebuilder/CSVwriter.py +++ /dev/null @@ -1,98 +0,0 @@ -import os.path -import csv -from csv import writer -from intakebuilder import builderconfig, configparser - -def getHeader(configyaml): - ''' - returns header that is the first line in the csv file, refers builderconfig.py - :return: headerlist with all columns - ''' - if configyaml: - return configyaml.headerlist - else: - return builderconfig.headerlist - -def writeHeader(csvfile): - ''' - writing header for the csv - :param csvfile: pass csvfile absolute path - :return: csv writer object - ''' - # list containing header values - # inputting these headers into a csv - with open(csvfile, "w+", newline="") as f: - writerobject = csv.writer(f) - writerobject.writerow(builderconfig.headerlist) - -def file_appender(dictinputs, csvfile): - ''' - creating function that puts values in dictionary into the csv - :param dictinputs: - :param csvfile: - :return: - ''' - # opening file in append mode - with open(csvfile, 'a', newline='') as write_obj: - # Create a writer object from csv module - csv_writer = writer(write_obj) - # add contents of list as last row in the csv file - csv_writer.writerow(dictinputs) - -def listdict_to_csv(dict_info,headerlist, csvfile, overwrite, append): - try: - #Open the CSV file in write mode and add any data with atleast 3 values associated with it - if overwrite: - with open(csvfile, 'w') as csvfile: - writer = csv.DictWriter(csvfile, fieldnames=headerlist) - print("writing..") - writer.writeheader() - for data in dict_info: - if len(data.keys()) > 2: - writer.writerow(data) - #Open the CSV file in append mode and add any data with atleast 3 values associated with it - if append: - with open(csvfile, 'a') as csvfile: - writer = csv.DictWriter(csvfile, fieldnames=headerlist) - print("writing (without header)..") - for data in dict_info: - if len(data.keys()) > 2: - writer.writerow(data) - #If neither overwrite nor append flags are found, check if a csv file already exists. If so, prompt user on what to do. If not, write to the file. - if not any((overwrite, append)): - if os.path.isfile(csvfile): - user_input = '' - while True: - user_input = input('Found existing file! Overwrite? (y/n)') - - if user_input.lower() == 'y': - with open(csvfile, 'w') as csvfile: - writer = csv.DictWriter(csvfile, fieldnames=headerlist) - print("writing..") - writer.writeheader() - for data in dict_info: - if len(data.keys()) > 2: - writer.writerow(data) - break - - elif user_input.lower() == 'n': - with open(csvfile, 'a') as csvfile: - writer = csv.DictWriter(csvfile, fieldnames=headerlist) - print("appending (without header) to existing file...") - for data in dict_info: - if len(data.keys()) > 2: - writer.writerow(data) - break - #If the user types anything besides y/n, keep asking - else: - print('Type y/n') - else: - with open(csvfile, 'w') as csvfile: - writer = csv.DictWriter(csvfile, fieldnames=headerlist) - print("writing..") - writer.writeheader() - for data in dict_info: - if len(data.keys()) > 2: - writer.writerow(data) - except IOError: - print("I/O error") diff --git a/intakebuilder/builderconfig.py b/intakebuilder/builderconfig.py deleted file mode 100644 index 2eb95ef..0000000 --- a/intakebuilder/builderconfig.py +++ /dev/null @@ -1,50 +0,0 @@ -#what kind of directory structure to expect? -#For a directory structure like /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp -# the output_path_template is set as follows. -#We have NA in those values that do not match up with any of the expected headerlist (CSV columns), otherwise we -#simply specify the associated header name in the appropriate place. E.g. The third directory in the PP path example -#above is the model (source_id), so the third list value in output_path_template is set to 'source_id'. We make sure -#this is a valid value in headerlist as well. -#The fourth directory is am5f3b1r0 which does not map to an existing header value. So we simply NA in output_path_template -#for the fourth value. - -#catalog headers -#The headerlist is expected column names in your catalog/csv file. This is usually determined by the users in conjuction -#with the ESM collection specification standards and the appropriate workflows. - -headerlist = ["activity_id", "institution_id", "source_id", "experiment_id", - "frequency", "realm", "table_id", - "member_id", "grid_label", "variable_id", - "temporal_subset", "chunk_freq","grid_label","platform","dimensions","cell_methods","path"] - -#what kind of directory structure to expect? -#For a directory structure like /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp -# the output_path_template is set as follows. -#We have NA in those values that do not match up with any of the expected headerlist (CSV columns), otherwise we -#simply specify the associated header name in the appropriate place. E.g. The third directory in the PP path example -#above is the model (source_id), so the third list value in output_path_template is set to 'source_id'. We make sure -#this is a valid value in headerlist as well. -#The fourth directory is am5f3b1r0 which does not map to an existing header value. So we simply NA in output_path_template -#for the fourth value. - - -output_path_template = ['NA','NA','source_id','NA','experiment_id','platform','custom_pp','realm','cell_methods','frequency','chunk_freq'] -output_file_template = ['realm','temporal_subset','variable_id'] - -#OUTPUT FILE INFO is currently passed as command-line argument. -#We will revisit adding a csvfile, jsonfile and logfile configuration to the builder configuration file in the future. -#csvfile = #jsonfile = #logfile = - -####################################################### - -input_path = "" # ENTER INPUT PATH HERE" #Example: /Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" -output_path = "" # ENTER NAME OF THE CSV AND JSON, THE SUFFIX ALONE. e.g catalog (the builder then generates catalog.csv and catalog.json. This can also be an absolute path) - -######### ADDITIONAL SEARCH FILTERS ########################### - -dictFilter = {} -dictFilterIgnore = {} -dictFilter["realm"]= 'atmos_cmip' -dictFilter["frequency"] = "monthly" -dictFilter["chunk_freq"] = "5yr" -dictFilterIgnore["remove"]= 'DO_NOT_USE' diff --git a/intakebuilder/catalogcols.py b/intakebuilder/catalogcols.py deleted file mode 100644 index 6064a4c..0000000 --- a/intakebuilder/catalogcols.py +++ /dev/null @@ -1,4 +0,0 @@ -headerlist = ["activity_id", "institution_id", "source_id", "experiment_id", - "frequency", "realm", "table_id", - "member_id", "grid_label", "variable_id", - "temporal_subset", "chunk_freq","grid_label","platform","dimensions","cell_methods","path"] diff --git a/intakebuilder/config.yaml b/intakebuilder/config.yaml deleted file mode 100644 index a964aca..0000000 --- a/intakebuilder/config.yaml +++ /dev/null @@ -1,41 +0,0 @@ -#what kind of directory structure to expect? -#For a directory structure like /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp -# the output_path_template is set as follows. -#We have NA in those values that do not match up with any of the expected headerlist (CSV columns), otherwise we -#simply specify the associated header name in the appropriate place. E.g. The third directory in the PP path example -#above is the model (source_id), so the third list value in output_path_template is set to 'source_id'. We make sure -#this is a valid value in headerlist as well. -#The fourth directory is am5f3b1r0 which does not map to an existing header value. So we simply NA in output_path_template -#for the fourth value. - -#catalog headers -#The headerlist is expected column names in your catalog/csv file. This is usually determined by the users in conjuction -#with the ESM collection specification standards and the appropriate workflows. - -headerlist: ["activity_id", "institution_id", "source_id", "experiment_id", - "frequency", "realm", "table_id", - "member_id", "grid_label", "variable_id", - "temporal_subset", "chunk_freq","grid_label","platform","dimensions","cell_methods","path"] - -#what kind of directory structure to expect? -#For a directory structure like /archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp -# the output_path_template is set as follows. -#We have NA in those values that do not match up with any of the expected headerlist (CSV columns), otherwise we -#simply specify the associated header name in the appropriate place. E.g. The third directory in the PP path example -#above is the model (source_id), so the third list value in output_path_template is set to 'source_id'. We make sure -#this is a valid value in headerlist as well. -#The fourth directory is am5f3b1r0 which does not map to an existing header value. So we simply NA in output_path_template -#for the fourth value. - -output_path_template: ['NA','NA','source_id','NA','experiment_id','platform','custom_pp','realm','cell_methods','frequency','chunk_freq'] - -output_file_template: ['realm','temporal_subset','variable_id'] - -#OUTPUT FILE INFO is currently passed as command-line argument. -#We will revisit adding a csvfile, jsonfile and logfile configuration to the builder configuration file in the future. -#csvfile = #jsonfile = #logfile = - -####################################################### - -input_path: "/Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" #"ENTER INPUT PATH HERE" #Example: /Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" -output_path: "catalog" # ENTER NAME OF THE CSV AND JSON, THE SUFFIX ALONE. e.g catalog (the builder then generates catalog.csv and catalog.json. This can also be an absolute path) diff --git a/intakebuilder/configparser.py b/intakebuilder/configparser.py deleted file mode 100644 index e64bedc..0000000 --- a/intakebuilder/configparser.py +++ /dev/null @@ -1,33 +0,0 @@ -import yaml -import os -class Config: - def __init__(self, config): - self.config = config - with open(self.config, 'r') as file: - configfile = yaml.safe_load(file) - try: - self.input_path = configfile['input_path'] - print("input_path :",self.input_path) - except: - raise KeyError("input_path does not exist in config") - try: - self.output_path = configfile['output_path'] - print("output_path :",self.output_path) - except: - raise KeyError("output_path does not exist in config") - try: - self.headerlist = configfile['headerlist'] - print("headerlist :",self.headerlist) - except: - raise KeyError("headerlist does not exist in config") - try: - self.output_path_template = configfile['output_path_template'] - print("output_path_template :",self.output_path_template) - except: - raise KeyError("output_path_template does not exist in config") - try: - self.output_file_template = configfile['output_file_template'] - print("output_file_template :", self.output_file_template) - except: - raise KeyError("output_file_template does not exist in config") - diff --git a/intakebuilder/getinfo.py b/intakebuilder/getinfo.py deleted file mode 100644 index d974c29..0000000 --- a/intakebuilder/getinfo.py +++ /dev/null @@ -1,206 +0,0 @@ -import sys -import pandas as pd -import csv -from csv import writer -import os -import xarray as xr -from intakebuilder import builderconfig, configparser - - -''' -getinfo.py provides helper functions to get information (from filename, DRS, file/global attributes) needed to populate the catalog -''' -def getProject(projectdir,dictInfo): - ''' - return Project name from the project directory input - :type dictInfo: object - :param drsstructure: - :return: dictionary with project key - ''' - if ("archive" in projectdir or "pp" in projectdir): - project = "dev" - dictInfo["activity_id"]=project - return dictInfo - -def getinfoFromYAML(dictInfo,yamlfile,miptable=None): - import yaml - with open(yamlfile) as f: - mappings = yaml.load(f, Loader=yaml.FullLoader) - #print(mappings) - #for k, v in mappings.items(): - #print(k, "->", v) - if(miptable): - try: - dictInfo["frequency"] = mappings[miptable]["frequency"] - except KeyError: - dictInfo["frequency"] = "NA" - try: - dictInfo["realm"] = mappings[miptable]["realm"] - except KeyError: - dictInfo["realm"] = "NA" - return(dictInfo) - -def getStem(dirpath,projectdir): - ''' - return stem from the project directory passed and the files crawled within - :param dirpath: - :param projectdir: - :param stem directory: - :return: - ''' - stemdir = dirpath.split(projectdir)[1].split("/") # drsstructure is the root - return stemdir - - -def getInfoFromFilename(filename,dictInfo,logger): - # 5 AR: WE need to rework this, not being used in gfdl set up get the following from the netCDF filename e.g.rlut_Amon_GFDL-ESM4_histSST_r1i1p1f1_gr1_195001-201412.nc - #print(filename) - if(filename.endswith(".nc")): - ncfilename = filename.split(".")[0].split("_") - varname = ncfilename[0] - dictInfo["variable"] = varname - miptable = ncfilename[1] - dictInfo["mip_table"] = miptable - modelname = ncfilename[2] - dictInfo["model"] = modelname - expname = ncfilename[3] - dictInfo["experiment_id"] = expname - ens = ncfilename[4] - dictInfo["ensemble_member"] = ens - grid = ncfilename[5] - dictInfo["grid_label"] = grid - try: - tsubset = ncfilename[6] - except IndexError: - tsubset = "null" #For fx fields - dictInfo["temporal_subset"] = tsubset - else: - logger.debug("Filename not compatible with this version of the builder:"+filename) - return dictInfo - -#adding this back to trace back some old errors -def getInfoFromGFDLFilename(filename,dictInfo,logger): - # 5 AR: get the following from the netCDF filename e.g. atmos.200501-200912.t_ref.nc - if(filename.endswith(".nc")): #and not filename.startswith(".")): - ncfilename = filename.split(".") - varname = ncfilename[-2] - dictInfo["variable_id"] = varname - #miptable = "" #ncfilename[1] - #dictInfo["mip_table"] = miptable - #modelname = ncfilename[2] - #dictInfo["model"] = modelname - #expname = ncfilename[3] - #dictInfo["experiment_id"] = expname - #ens = ncfilename[4] - #dictInfo["ensemble_member"] = ens - #grid = ncfilename[5] - #dictInfo["grid_label"] = grid - try: - tsubset = ncfilename[1] - except IndexError: - tsubset = "null" #For fx fields - dictInfo["temporal_subset"] = tsubset - else: - logger.debug("Filename not compatible with this version of the builder:"+filename) - return dictInfo - -def getInfoFromGFDLDRS(dirpath,projectdir,dictInfo,configyaml): - ''' - Returns info from project directory and the DRS path to the file - :param dirpath: - :param drsstructure: - :return: - ''' - # we need thise dict keys "project", "institute", "model", "experiment_id", - # "frequency", "realm", "mip_table", - # "ensemble_member", "grid_label", "variable", - # "temporal subset", "version", "path"] - - #Grab values based on their expected position in path - stemdir = dirpath.split("/") - # adding back older versions to ensure we get info from builderconfig - stemdir = dirpath.split("/") - - #lets go backwards and match given input directory to the template, add things to dictInfo - j = -1 - cnt = 1 - if configyaml: - output_path_template = configyaml.output_path_template - else: - try: - output_path_template = builderconfig.output_path_template - except: - sys.exit("No output_path_template found in builderconfig.py. Check configuration.") - - nlen = len(output_path_template) - for i in range(nlen-1,0,-1): - try: - if(output_path_template[i] != "NA"): - try: - dictInfo[output_path_template[i]] = stemdir[(j)] - except IndexError: - print("Check configuration. Is output path template set correctly?") - exit() - except IndexError: - sys.exit("oops in getInfoFromGFDLDRS"+str(i)+str(j)+output_path_template[i]+stemdir[j]) - j = j - 1 - cnt = cnt + 1 - # WE do not want to work with anythi:1 - # ng that's not time series - #TODO have verbose option to print message - if "cell_methods" in dictInfo.keys(): - if (dictInfo["cell_methods"] != "ts"): - #print("Skipping non-timeseries data") - return {} - return dictInfo - -def getInfoFromDRS(dirpath,projectdir,dictInfo): - ''' - Returns info from project directory and the DRS path to the file - :param dirpath: - :param drsstructure: - :return: - ''' - #stemdir = getStem(dirpath, projectdir) - stemdir = dirpath.split(projectdir)[1].split("/") # drsstructure is the root - try: - institute = stemdir[2] - except: - institute = "NA" - try: - version = stemdir[9] - except: - version = "NA" - dictInfo["institute"] = institute - dictInfo["version"] = version - return dictInfo -def return_xr(fname): - filexr = (xr.open_dataset(fname)) - filexra = filexr.attrs - return filexra -def getInfoFromGlobalAtts(fname,dictInfo,filexra=None): - ''' - Returns info from the filename and xarray dataset object - :param fname: DRS compliant filename - :param filexr: Xarray dataset object - :return: dictInfo with institution_id version realm frequency and product - ''' - filexra = return_xr(fname) - if dictInfo["institute"] == "NA": - try: - institute = filexra["institution_id"] - except KeyError: - institute = "NA" - dictInfo["institute"] = institute - if dictInfo["version"] == "NA": - try: - version = filexra["version"] - except KeyError: - version = "NA" - dictInfo["version"] = version - realm = filexra["realm"] - dictInfo["realm"] = realm - frequency = filexra["frequency"] - dictInfo["frequency"] = frequency - return dictInfo - diff --git a/intakebuilder/gfdlcrawler.py b/intakebuilder/gfdlcrawler.py deleted file mode 100644 index dd81c04..0000000 --- a/intakebuilder/gfdlcrawler.py +++ /dev/null @@ -1,78 +0,0 @@ -import os -from intakebuilder import getinfo, builderconfig -import sys -import re -import operator as op -''' -localcrawler crawls through the local file path, then calls helper functions in the package to getinfo. -It finally returns a list of dict. eg {'project': 'CMIP6', 'path': '/uda/CMIP6/CDRMIP/NCC/NorESM2-LM/esm-pi-cdr-pulse/r1i1p1f1/Emon/zg/gn/v20191108/zg_Emon_NorESM2-LM_esm-pi-cdr-pulse_r1i1p1f1_gn_192001-192912.nc', 'variable': 'zg', 'mip_table': 'Emon', 'model': 'NorESM2-LM', 'experiment_id': 'esm-pi-cdr-pulse', 'ensemble_member': 'r1i1p1f1', 'grid_label': 'gn', 'temporal subset': '192001-192912', 'institute': 'NCC', 'version': 'v20191108'} - -''' -def crawlLocal(projectdir, dictFilter,dictFilterIgnore,logger,configyaml): - ''' - Craw through the local directory and run through the getInfo.. functions - :param projectdir: - :return:listfiles which has a dictionary of all key/value pairs for each file to be added to the csv - ''' - listfiles = [] - pat = None - if("realm" in dictFilter.keys()) & (("frequency") in dictFilter.keys()): - pat = re.compile('({}/{}/{}/{})'.format(dictFilter["realm"],"ts",dictFilter["frequency"],dictFilter["chunk_freq"])) - - orig_pat = pat - - #TODO INCLUDE filter in traversing through directories at the top - for dirpath, dirs, files in os.walk(projectdir): - searchpath = dirpath - if (orig_pat is None): - pat = dirpath #we assume matching entire path - if(pat is not None): - m = re.search(pat, searchpath) - for filename in files: - # get info from filename - filepath = os.path.join(dirpath,filename) # 1 AR: Bugfix: this needs to join dirpath and filename to get the full path to the file - - #if filename.startswith("."): - # logger.debug("Skipping hidden file", filepath) - # continue - if not filename.endswith(".nc"): - logger.debug("FILE does not end with .nc. Skipping", filepath) - continue - logger.info(dirpath+"/"+filename) - dictInfo = {} - dictInfo = getinfo.getProject(projectdir, dictInfo) - # get info from filename - #filepath = os.path.join(dirpath,filename) # 1 AR: Bugfix: this needs to join dirpath and filename to get the full path to the file - dictInfo["path"]=filepath - if (op.countOf(filename,".") == 1): - dictInfo = getinfo.getInfoFromFilename(filename,dictInfo, logger) - else: - dictInfo = getinfo.getInfoFromGFDLFilename(filename,dictInfo, logger) - dictInfo = getinfo.getInfoFromGFDLDRS(dirpath, projectdir, dictInfo,configyaml) - list_bad_modellabel = ["","piControl","land-hist","piClim-SO2","abrupt-4xCO2","hist-piAer","hist-piNTCF","piClim-ghg","piClim-OC","hist-GHG","piClim-BC","1pctCO2"] - list_bad_chunklabel = ['DO_NOT_USE'] - if "source_id" in dictInfo: - if(dictInfo["source_id"] in list_bad_modellabel): - logger.debug("Found experiment name in model column, skipping this possibly bad DRS filename",filepath) - # continue - if "chunk_freq" in dictInfo: - if(dictInfo["chunk_freq"] in list_bad_chunklabel): - logger.debug("Found bad chunk, skipping this possibly bad DRS filename",filepath) - continue - - if configyaml: - headerlist = configyaml.headerlist - else: - headerlist = builderconfig.headerlist - # remove those keys that are not CSV headers - # move it so its one time - rmkeys = [] - for dkeys in dictInfo.keys(): - if dkeys not in headerlist: - rmkeys.append(dkeys) - rmkeys = list(set(rmkeys)) - - for k in rmkeys: dictInfo.pop(k,None) - - listfiles.append(dictInfo) - return listfiles diff --git a/intakebuilder/localcrawler.py b/intakebuilder/localcrawler.py deleted file mode 100644 index ac43810..0000000 --- a/intakebuilder/localcrawler.py +++ /dev/null @@ -1,57 +0,0 @@ -import os -from intakebuilder import getinfo -import re -''' -localcrawler crawls through the local file path, then calls helper functions in the package to getinfo. -It finally returns a list of dict -''' -def crawlLocal(projectdir, dictFilter,logger): - ''' - Craw through the local directory and run through the getInfo.. functions - :param projectdir: - :return:listfiles which has a dictionary of all key/value pairs for each file to be added to the csv - ''' - listfiles = [] - pat = None - if("miptable" in dictFilter.keys()) & (("varname") in dictFilter.keys()): - pat = re.compile('({}/{}/)'.format(dictFilter["miptable"],dictFilter["varname"])) - elif("miptable" in dictFilter.keys()): - pat = re.compile('({}/)'.format(dictFilter["miptable"])) - elif(("varname") in dictFilter.keys()): - pat = re.compile('({}/)'.format(dictFilter["varname"])) - orig_pat = pat - #TODO INCLUDE filter in traversing through directories at the top - for dirpath, dirs, files in os.walk(projectdir): - #print(dirpath, dictFilter["source_prefix"]) - if dictFilter["source_prefix"] in dirpath: #TODO improved filtering - searchpath = dirpath - if (orig_pat is None): - pat = dirpath #we assume matching entire path - # print("Search filters applied", dictFilter["source_prefix"], "and", pat) - if(pat is not None): - m = re.search(pat, searchpath) - for filename in files: - logger.info(dirpath+"/"+filename) - dictInfo = {} - dictInfo = getinfo.getProject(projectdir, dictInfo) - # get info from filename - #print(filename) - filepath = os.path.join(dirpath,filename) # 1 AR: Bugfix: this needs to join dirpath and filename to get the full path to the file - if not filename.endswith(".nc"): - logger.debug("FILE does not end with .nc. Skipping", filepath) - continue - dictInfo["path"]=filepath -# print("Callin:g getinfo.getInfoFromFilename(filename, dictInfo)..") - dictInfo = getinfo.getInfoFromFilename(filename, dictInfo,logger) -# print("Calling getinfo.getInfoFromDRS(dirpath, projectdir, dictInfo)") - dictInfo = getinfo.getInfoFromDRS(dirpath, projectdir, dictInfo) -# print("Calling getinfo.getInfoFromGlobalAtts(filepath, dictInfo)") -# dictInfo = getinfo.getInfoFromGlobalAtts(filepath, dictInfo) - #eliminate bad DRS filenames spotted - list_bad_modellabel = ["","piControl","land-hist","piClim-SO2","abrupt-4xCO2","hist-piAer","hist-piNTCF","piClim-ghg","piClim-OC","hist-GHG","piClim-BC","1pctCO2"] - if(dictInfo["model"] in list_bad_modellabel): - logger.debug("Found experiment name in model column, skipping this possibly bad DRS filename", dictInfo["experiment"],filepath) - continue - listfiles.append(dictInfo) - #print(listfiles) - return listfiles diff --git a/intakebuilder/s3crawler.py b/intakebuilder/s3crawler.py deleted file mode 100644 index e55d676..0000000 --- a/intakebuilder/s3crawler.py +++ /dev/null @@ -1,59 +0,0 @@ -import re -import boto3 -import botocore -from intakebuilder import getinfo - -''' -s3 crawler crawls through the S3 bucket, passes the bucket path to the helper functions to getinfo. -Finally it returns a list of dictionaries. -''' -def sss_crawler(projectdir,dictFilter,project_root, logger): - region = 'us-west-2' - s3client = boto3.client('s3', region_name=region, - config=botocore.client.Config(signature_version=botocore.UNSIGNED)) - - s3prefix = "s3:/" - filetype = ".nc" - project_bucket = projectdir.split("/")[2] - ####################################################### - listfiles = [] - pat = None - logger.debug(dictFilter.keys()) - if("miptable" in dictFilter.keys()) & (("varname") in dictFilter.keys()): - pat = re.compile('({}/{}/)'.format(dictFilter["miptable"],dictFilter["varname"])) - elif("miptable" in dictFilter.keys()): - pat = re.compile('({}/)'.format(dictFilter["miptable"])) - elif(("varname") in dictFilter.keys()): - pat = re.compile('({}/)'.format(dictFilter["varname"])) - orig_pat = pat - paginator = s3client.get_paginator('list_objects') - for result in paginator.paginate(Bucket=project_bucket, Prefix=dictFilter["source_prefix"], Delimiter=filetype): - for prefixes in result.get('CommonPrefixes'): - dictInfo = {} - dictInfo = getinfo.getProject(project_root, dictInfo) - commonprefix = prefixes.get('Prefix') - searchpath = commonprefix - if (orig_pat is None): - pat = commonprefix #we assume matching entire path - #filepath = '{}/{}/{}'.format(s3prefix,project_bucket,commonprefix) - # print("Search filters applied", dictFilter["source_prefix"], "and", pat) - if(pat is not None): - m = re.search(pat, searchpath) - if m is not None: - #print(commonprefix) - #print('{}/{}/{}'.format(s3prefix,project_bucket,commonprefix)) - filepath = '{}/{}/{}'.format(s3prefix,project_bucket,commonprefix) - #TODO if filepath already exists in csv we skip - dictInfo["path"]=filepath - logger.debug(filepath) - filename = filepath.split("/")[-1] - dirpath = "/".join(filepath.split("/")[0:-1]) - #projectdird passed to sss_crawler should be s3://bucket/project - dictInfo = getinfo.getInfoFromFilename(filename, dictInfo,logger) - dictInfo = getinfo.getInfoFromDRS(dirpath, projectdir, dictInfo) - #Using YAML instead of this to get frequency and modeling_realm dictInfo = getinfo.getInfoFromGlobalAtts(filepath, dictInfo) - #TODO YAML for all mip_tables - dictInfo = getinfo.getinfoFromYAML(dictInfo,"table.yaml",miptable=dictInfo["mip_table"]) - listfiles.append(dictInfo) - logger.debug(dictInfo) - return listfiles diff --git a/intakebuilder/table.yaml b/intakebuilder/table.yaml deleted file mode 100644 index bdae363..0000000 --- a/intakebuilder/table.yaml +++ /dev/null @@ -1,9 +0,0 @@ -Amon: - frequency: mon - realm: atmos -Omon: - frequency: mon - realm: ocean -3hr: - frequency: 3hr - realm: na From 1fa7910420527dec2e7d44ea72ee05ca6f8731dd Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 14:17:35 -0400 Subject: [PATCH 15/40] Update test_config.yaml --- tests/test_config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_config.yaml b/tests/test_config.yaml index 03f7806..803f1b8 100644 --- a/tests/test_config.yaml +++ b/tests/test_config.yaml @@ -38,4 +38,4 @@ output_file_template: ['modeling_realm','temporal_subset','variable_id'] ####################################################### input_path: "archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" #"ENTER INPUT PATH HERE" #Example: /Users/ar46/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" -output_path: "cats/gfdl_autotest_from_yaml" # ENTER NAME OF THE CSV AND JSON, THE SUFFIX ALONE. e.g catalog (the builder then generates catalog.csv and catalog.json. This can also be an absolute path) +output_path: "catalogbuilder/cats/gfdl_autotest_from_yaml" # ENTER NAME OF THE CSV AND JSON, THE SUFFIX ALONE. e.g catalog (the builder then generates catalog.csv and catalog.json. This can also be an absolute path) From 6521d68bd82054aa03ecd9aca443b7ff407794f2 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 14:23:42 -0400 Subject: [PATCH 16/40] Update meta.yaml --- meta.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/meta.yaml b/meta.yaml index a16f1bf..7cb757b 100644 --- a/meta.yaml +++ b/meta.yaml @@ -3,7 +3,7 @@ package: version: 2.0.1 source: - git_url: https://github.com/NOAA-GFDL/CatalogBuilder/CatalogBuilder.git + git_url: https://github.com/NOAA-GFDL/CatalogBuilder.git path: . build: From 91752a9a8a591e474bc966f7ad6f3839a8535365 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 14:25:08 -0400 Subject: [PATCH 17/40] Update test_catalog.py --- catalogbuilder/scripts/test_catalog.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/catalogbuilder/scripts/test_catalog.py b/catalogbuilder/scripts/test_catalog.py index c52e8b6..ed44d95 100755 --- a/catalogbuilder/scripts/test_catalog.py +++ b/catalogbuilder/scripts/test_catalog.py @@ -23,7 +23,7 @@ def main(json_path,json_template_path,test_failure): if json_template_path: json_template = json.load(open(json_template_path)) else: - json_template = json.load(open('cats/gfdl_template.json')) + json_template = json.load(open('catalogbuilder/cats/gfdl_template.json')) #Validate JSON against JSON template comp = (diff(j,json_template)) From ef86c6d26e439a5e5e0bfee50ee41113aaa4f85e Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 14:25:53 -0400 Subject: [PATCH 18/40] Update test_ingestion.py --- tests/test_ingestion.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_ingestion.py b/tests/test_ingestion.py index 38f6b41..13b6aec 100755 --- a/tests/test_ingestion.py +++ b/tests/test_ingestion.py @@ -21,7 +21,7 @@ def load_cat(catspec=None): return cat def test_loadcat(): #TODO generate csv on the fly, check if its readable etc - catspec = pathlib.Path(os.path.dirname(__file__)).parent / 'cats/gfdl_template.json' + catspec = pathlib.Path(os.path.dirname(__file__)).parent / 'catalogbuilder/cats/gfdl_template.json' #TODO generate test catalog on the fly, push spec to the test directory cat = load_cat((str(catspec))) try: From 78897ff0fe24a0a48952b0308bffdf8b4ba5bf46 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 14:49:25 -0400 Subject: [PATCH 19/40] Update test_import.py --- tests/test_import.py | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-) diff --git a/tests/test_import.py b/tests/test_import.py index 794b49a..916037c 100644 --- a/tests/test_import.py +++ b/tests/test_import.py @@ -1,10 +1,26 @@ def check_import(): try: - from intakebuilder import getinfo, localcrawler, CSVwriter - print("Imported intakebuilder and getinfo, localcrawler, CSVwriter ") - except ImportError: - raise ImportError('Error importing intakebuilder and other packages') - return -97 - return True + from intakebuilder import gfdlcrawler, CSVwriter, configparser + print("Imported intakebuilder, gfdlcrawler, CSVwriter, configparser") + return True + except ModuleNotFoundError: + print("The module intakebuilder is not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") + print("Attempting again with adjusted sys.path ") + try: + sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + except: + print("Unable to adjust sys.path") + #print(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + try: + from intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser + print("Imported, and relied on sys.path") + return True + except ModuleNotFoundError: + sys.exit("The module 'intakebuilder' is still not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") + raise ImportError('Error importing intakebuilder and other packages') + return -97 + def test_import(): assert check_import() == True + + From cf332508223d5ed14b1243d4be801092c2ed6a44 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 14:59:22 -0400 Subject: [PATCH 20/40] Update test_import.py --- tests/test_import.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_import.py b/tests/test_import.py index 916037c..3869836 100644 --- a/tests/test_import.py +++ b/tests/test_import.py @@ -16,7 +16,7 @@ def check_import(): print("Imported, and relied on sys.path") return True except ModuleNotFoundError: - sys.exit("The module 'intakebuilder' is still not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") + print("The module 'intakebuilder' is still not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") raise ImportError('Error importing intakebuilder and other packages') return -97 From f13771b0e3391fda6e2c57662420db6941b156b7 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 15:18:10 -0400 Subject: [PATCH 21/40] Update meta.yaml --- meta.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/meta.yaml b/meta.yaml index 7cb757b..ea3d764 100644 --- a/meta.yaml +++ b/meta.yaml @@ -4,6 +4,7 @@ package: source: git_url: https://github.com/NOAA-GFDL/CatalogBuilder.git + git_branch: subpkgtest path: . build: From dfa46297b9e81fa22e3df66690cc2346d09b00e5 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 15:36:20 -0400 Subject: [PATCH 22/40] Update test_import.py --- tests/test_import.py | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) diff --git a/tests/test_import.py b/tests/test_import.py index 3869836..9b658ec 100644 --- a/tests/test_import.py +++ b/tests/test_import.py @@ -1,24 +1,17 @@ +import os,sys def check_import(): try: from intakebuilder import gfdlcrawler, CSVwriter, configparser - print("Imported intakebuilder, gfdlcrawler, CSVwriter, configparser") - return True - except ModuleNotFoundError: + except ImportError: print("The module intakebuilder is not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") print("Attempting again with adjusted sys.path ") try: - sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))+"/catalogbuilder") + from intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser except: print("Unable to adjust sys.path") - #print(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) - try: - from intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser - print("Imported, and relied on sys.path") - return True - except ModuleNotFoundError: - print("The module 'intakebuilder' is still not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") - raise ImportError('Error importing intakebuilder and other packages') - return -97 + raise ImportError('Error importing intakebuilder and other packages') + return -97 def test_import(): assert check_import() == True From d72f4064c86f4012576316290473f7e6f397140d Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 15:37:49 -0400 Subject: [PATCH 23/40] Update test_import.py --- tests/test_import.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_import.py b/tests/test_import.py index 9b658ec..3084f0e 100644 --- a/tests/test_import.py +++ b/tests/test_import.py @@ -6,6 +6,7 @@ def check_import(): print("The module intakebuilder is not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") print("Attempting again with adjusted sys.path ") try: + #candobetter with actual conda package built before this, but this is a decent test for those that do not use conda package sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))+"/catalogbuilder") from intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser except: From 50944f387edbc95ffd94d90c17762559a349b5cb Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 15:41:54 -0400 Subject: [PATCH 24/40] Update test_import.py --- tests/test_import.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_import.py b/tests/test_import.py index 3084f0e..e5d5213 100644 --- a/tests/test_import.py +++ b/tests/test_import.py @@ -13,6 +13,7 @@ def check_import(): print("Unable to adjust sys.path") raise ImportError('Error importing intakebuilder and other packages') return -97 + return True def test_import(): assert check_import() == True From 8c87b1d0752d0a9233e13472c252f2ed51243ad4 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 15:46:41 -0400 Subject: [PATCH 25/40] Update create-gfdl-catalog.yml --- .github/workflows/create-gfdl-catalog.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/create-gfdl-catalog.yml b/.github/workflows/create-gfdl-catalog.yml index 28977ff..7961673 100644 --- a/.github/workflows/create-gfdl-catalog.yml +++ b/.github/workflows/create-gfdl-catalog.yml @@ -50,5 +50,5 @@ jobs: $CONDA/envs/catalogbuilder/bin/pytest -v --runxfail - name: Test for completeness run: | - $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/test_catalog.py -tf gfdl_autotest.json cats/gfdl_template.json - $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/test_catalog.py -tf cats/gfdl_autotest_from_yaml.json + $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/test_catalog.py -tf gfdl_autotest.json catalogbuilder/cats/gfdl_template.json + $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/test_catalog.py -tf catalogbuilder/cats/gfdl_autotest_from_yaml.json From 167f7b6bf13edb9eb2a98acc5eeb4702cc7e41d9 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 15:50:48 -0400 Subject: [PATCH 26/40] Update gen_intake_gfdl_runner.py --- catalogbuilder/scripts/gen_intake_gfdl_runner.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/catalogbuilder/scripts/gen_intake_gfdl_runner.py b/catalogbuilder/scripts/gen_intake_gfdl_runner.py index 920ede8..2f487b9 100755 --- a/catalogbuilder/scripts/gen_intake_gfdl_runner.py +++ b/catalogbuilder/scripts/gen_intake_gfdl_runner.py @@ -1,6 +1,7 @@ #!/usr/bin/env python -from scripts import gen_intake_gfdl +#TODO test after conda pkg is published and make changes as needed +from catalogbuilder.scripts import gen_intake_gfdl import sys input_path = "/archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp/" From 1b7dadfcd97259657ac8fa5f6364d83464615991 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 15:51:20 -0400 Subject: [PATCH 27/40] Update gen_intake_gfdl_notebook.ipynb --- catalogbuilder/scripts/gen_intake_gfdl_notebook.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/catalogbuilder/scripts/gen_intake_gfdl_notebook.ipynb b/catalogbuilder/scripts/gen_intake_gfdl_notebook.ipynb index 5ec2ff2..ef4115d 100644 --- a/catalogbuilder/scripts/gen_intake_gfdl_notebook.ipynb +++ b/catalogbuilder/scripts/gen_intake_gfdl_notebook.ipynb @@ -56,7 +56,7 @@ } ], "source": [ - "from scripts import gen_intake_gfdl\n", + "from catalogbuilder.scripts import gen_intake_gfdl\n", "import sys,os\n", "\n", "######USER input begins########\n", From 5cf5b9eef1533f2e499d9588f9e395f87b50ae95 Mon Sep 17 00:00:00 2001 From: Aparna Radhakrishnan Date: Fri, 19 Jul 2024 15:51:35 -0400 Subject: [PATCH 28/40] Update gen_intake_gfdl_runner_config.py --- catalogbuilder/scripts/gen_intake_gfdl_runner_config.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/catalogbuilder/scripts/gen_intake_gfdl_runner_config.py b/catalogbuilder/scripts/gen_intake_gfdl_runner_config.py index c7e019f..86fb91f 100755 --- a/catalogbuilder/scripts/gen_intake_gfdl_runner_config.py +++ b/catalogbuilder/scripts/gen_intake_gfdl_runner_config.py @@ -1,6 +1,6 @@ #!/usr/bin/env python -from scripts import gen_intake_gfdl +from catalogbuilder.scripts import gen_intake_gfdl import sys sys.argv = ['input_path','--config', '/home/a1r/github/CatalogBuilder/scripts/configs/config-example.yml'] From 9c923fc89a61b2e994e4a1e6190c6ca7b534e4d5 Mon Sep 17 00:00:00 2001 From: Ian Laflotte Date: Mon, 22 Jul 2024 13:48:46 -0400 Subject: [PATCH 29/40] tweak meta.yaml, setup.py for requirements. --- meta.yaml | 7 ++++--- setup.py | 5 +++-- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/meta.yaml b/meta.yaml index ea3d764..87791fa 100644 --- a/meta.yaml +++ b/meta.yaml @@ -17,12 +17,13 @@ requirements: - pip run: - python + - pytest - click - - pandas - xarray - - pytest - - conda-forge::intake-esm=2023.7.7 + - pandas - jsondiff + - conda-forge::intake-esm=2023.7.7 + - boto3 test: imports: - catalogbuilder diff --git a/setup.py b/setup.py index 3231e20..110a25d 100644 --- a/setup.py +++ b/setup.py @@ -14,8 +14,9 @@ 'click', 'xarray', 'pandas', - 'boto3', - 'botocore' + 'jsondiff', + 'intake-esm', + 'boto3' ] ) From f1ab693756da5c302d98ba1533d8101fa5407a4f Mon Sep 17 00:00:00 2001 From: Ian Laflotte Date: Mon, 22 Jul 2024 15:42:34 -0400 Subject: [PATCH 30/40] fixup import things. breakup some long lines. --- catalogbuilder/intakebuilder/CSVwriter.py | 2 +- catalogbuilder/intakebuilder/getinfo.py | 2 +- catalogbuilder/intakebuilder/gfdlcrawler.py | 2 +- catalogbuilder/scripts/gen_intake_gfdl.py | 23 +++++++-------------- catalogbuilder/scripts/gen_intake_local.py | 16 +++++++++----- catalogbuilder/scripts/gen_intake_s3.py | 4 ++-- catalogbuilder/scripts/test_catalog.py | 21 ++++++++++++++----- environment.yml | 2 +- 8 files changed, 41 insertions(+), 31 deletions(-) diff --git a/catalogbuilder/intakebuilder/CSVwriter.py b/catalogbuilder/intakebuilder/CSVwriter.py index 9a6a33f..7819f17 100644 --- a/catalogbuilder/intakebuilder/CSVwriter.py +++ b/catalogbuilder/intakebuilder/CSVwriter.py @@ -1,7 +1,7 @@ import os.path import csv from csv import writer -from intakebuilder import builderconfig, configparser +from . import builderconfig, configparser def getHeader(configyaml): ''' diff --git a/catalogbuilder/intakebuilder/getinfo.py b/catalogbuilder/intakebuilder/getinfo.py index d974c29..53e1185 100644 --- a/catalogbuilder/intakebuilder/getinfo.py +++ b/catalogbuilder/intakebuilder/getinfo.py @@ -4,7 +4,7 @@ from csv import writer import os import xarray as xr -from intakebuilder import builderconfig, configparser +from . import builderconfig, configparser ''' diff --git a/catalogbuilder/intakebuilder/gfdlcrawler.py b/catalogbuilder/intakebuilder/gfdlcrawler.py index dd81c04..d8f871a 100644 --- a/catalogbuilder/intakebuilder/gfdlcrawler.py +++ b/catalogbuilder/intakebuilder/gfdlcrawler.py @@ -1,5 +1,5 @@ import os -from intakebuilder import getinfo, builderconfig +from . import getinfo, builderconfig import sys import re import operator as op diff --git a/catalogbuilder/scripts/gen_intake_gfdl.py b/catalogbuilder/scripts/gen_intake_gfdl.py index a99b667..8a2f6ae 100755 --- a/catalogbuilder/scripts/gen_intake_gfdl.py +++ b/catalogbuilder/scripts/gen_intake_gfdl.py @@ -11,22 +11,14 @@ logger.setLevel(logging.INFO) try: - from intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser -except ModuleNotFoundError: - print("The module intakebuilder is not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") - print("Attempting again with adjusted sys.path ") - try: - sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) - except: - print("Unable to adjust sys.path") - #print(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) - try: - from intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser - except ModuleNotFoundError: - sys.exit("The module 'intakebuilder' is still not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") + from catalogbuilder.intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser +except ModuleNotFoundError as exc: + raise Exception(f"import problems!!!") from exc package_dir = os.path.dirname(os.path.abspath(__file__)) -template_path = os.path.join(package_dir, '../cats/gfdl_template.json') + +import catalogbuilder.cats +template_path = catalogbuilder.cats.__path__[0] + '/gfdl_template.json' #Setting up argument parsing/flags @click.command() @@ -35,7 +27,8 @@ #,help='The directory path with the datasets to be cataloged. E.g a GFDL PP path till /pp') @click.argument('output_path',required=False,nargs=1) #,help='Specify output filename suffix only. e.g. catalog') -@click.option('--config',required=False,type=click.Path(exists=True),nargs=1,help='Path to your yaml config, Use the config_template in intakebuilder repo') +@click.option('--config',required=False,type=click.Path(exists=True),nargs=1, + help='Path to your yaml config, Use the config_template in intakebuilder repo') @click.option('--filter_realm', nargs=1) @click.option('--filter_freq', nargs=1) @click.option('--filter_chunk', nargs=1) diff --git a/catalogbuilder/scripts/gen_intake_local.py b/catalogbuilder/scripts/gen_intake_local.py index 673cd16..ad06b57 100755 --- a/catalogbuilder/scripts/gen_intake_local.py +++ b/catalogbuilder/scripts/gen_intake_local.py @@ -10,17 +10,22 @@ def main(): #######INPUT HERE OR USE FROM A CONFIG FILE LATER###### -# project_dir = "/Users/ar46/data_cmip6/CMIP6/" # DRS COMPLIANT PROJECT DIR + #project_dir = "/Users/ar46/data_cmip6/CMIP6/" # DRS COMPLIANT PROJECT DIR project_dir = "/uda/CMIP6/"# #CMIP/NOAA-GFDL/GFDL-ESM4/" - csvfile = "/nbhome/a1r/intakebuilder_cats/intake_local.csv" ##"/Users/ar46/PycharmProjects/CatalogBuilder/intakebuilder/test/intake_local.csv" + ##"/Users/ar46/PycharmProjects/CatalogBuilder/intakebuilder/test/intake_local.csv" + csvfile = "/nbhome/a1r/intakebuilder_cats/intake_local.csv" ####################################################### + ######### SEARCH FILTERS ########################### dictFilter = {} - dictFilter["source_prefix"]= 'CMIP6/' #CMIP/CMCC/CMCC-CM2-SR5' #'CMIP6/CMIP/' #NOAA-GFDL/GFDL-CM4/' #/CMIP/NOAA-GFDL/GFDL-ESM4/' #Must specify something here, at least the project level - #COMMENT dictFilter["miptable"] = "Amon" #Remove this if you don't want to filter by miptable - #COMMENT dictFilter["varname"] = "tas" #Remove this if you don't want to filter by variable name + dictFilter["source_prefix"]= 'CMIP6/' + #CMIP/CMCC/CMCC-CM2-SR5' #'CMIP6/CMIP/' + #NOAA-GFDL/GFDL-CM4/' #/CMIP/NOAA-GFDL/GFDL-ESM4/' #Must specify something here, at least the project level + #COMMENT dictFilter["miptable"] = "Amon" #Remove this if you don't want to filter by miptable + #COMMENT dictFilter["varname"] = "tas" #Remove this if you don't want to filter by variable name ######################################################### + dictInfo = {} project_dir = project_dir.rstrip("/") logger.info("Calling localcrawler.crawlLocal") @@ -32,5 +37,6 @@ def main(): CSVwriter.listdict_to_csv(list_files, headers, csvfile) print("CSV generated at:", os.path.abspath(csvfile)) logger.info("CSV generated at"+ os.path.abspath(csvfile)) + if __name__ == '__main__': main() diff --git a/catalogbuilder/scripts/gen_intake_s3.py b/catalogbuilder/scripts/gen_intake_s3.py index 69a8afb..8eccc60 100755 --- a/catalogbuilder/scripts/gen_intake_s3.py +++ b/catalogbuilder/scripts/gen_intake_s3.py @@ -15,8 +15,8 @@ def main(): ######### SEARCH FILTERS ########################### dictFilter = {} dictFilter["source_prefix"]= 'CMIP6/' #/CMIP/NOAA-GFDL/GFDL-ESM4/' #Must specify something here, at least the project level - #COMMENT dictFilter["miptable"] = "Amon" #Remove this if you don't want to filter by miptable - #COMMENT dictFilter["varname"] = "tas" #Remove this if you don't want to filter by variable name + #COMMENT dictFilter["miptable"] = "Amon" #Remove this if you don't want to filter by miptable + #COMMENT dictFilter["varname"] = "tas" #Remove this if you don't want to filter by variable name ####################################################### project_bucket = project_root.split("/")[1].lstrip("/") project_name = project_root.split("/")[2] diff --git a/catalogbuilder/scripts/test_catalog.py b/catalogbuilder/scripts/test_catalog.py index ed44d95..1d838da 100755 --- a/catalogbuilder/scripts/test_catalog.py +++ b/catalogbuilder/scripts/test_catalog.py @@ -9,14 +9,22 @@ @click.command() @click.argument('json_path', nargs = 1 , required = True) @click.argument('json_template_path', nargs = 1 , required = False) -@click.option('-tf', '--test-failure', is_flag=True, default = False, help="Errors are only printed. Program will not exit.") +@click.option('-tf', '--test-failure', is_flag=True, default = False, + help="Errors are only printed. Program will not exit.") def main(json_path,json_template_path,test_failure): - """ This test ensures catalogs generated by the Catalog Builder tool are minimally valid. This means a few things: the generated catalog JSON file reflects the template it was generated with, the catalog CSV has atleast one row of values (not headers), and each required column exists without any empty values. If a test case is broken or expected to fail, the --test-failure/-tf flag can be used. This flag will simply print errors instead of doing a sys.exit. + """ This test ensures catalogs generated by the Catalog Builder tool are minimally valid. + This means a few things: the generated catalog JSON file reflects the template it was + generated with, the catalog CSV has atleast one row of values (not headers), and each + required column exists without any empty values. If a test case is broken or expected to + fail, the --test-failure/-tf flag can be used. This flag will simply print errors + instead of doing a sys.exit. - JSON_PATH: Path to generated schema to be tested + JSON_PATH: Path to generated schema to be tested - JSON_TEMPLATE_PATH: Path of schema template. Without a given path, cats/gfdl_template.json will be used for comparison """ + JSON_TEMPLATE_PATH: Path of schema template. Without a given path, cats/gfdl_template.json + will be used for comparison + """ #Open JSON j = json.load(open(json_path)) @@ -51,7 +59,10 @@ def main(json_path,json_template_path,test_failure): errors = 0 for column in req: if column not in catalog.columns: - print(f"The required column '{column}' does not exist in the csv. In other words, there is some inconsistency between the json and the csv file. Please check out info listed under aggregation_control and groupby_attrs in your json file and verify if those columns show up in the csv as well.") + print(f"The required column '{column}' does not exist in the csv. In other words, " + "there is some inconsistency between the json and the csv file. Please check " + "out info listed under aggregation_control and groupby_attrs in your json file" + " and verify if those columns show up in the csv as well." ) errors += 1 if column in catalog.columns: diff --git a/environment.yml b/environment.yml index 9c0683c..47bf473 100644 --- a/environment.yml +++ b/environment.yml @@ -4,7 +4,7 @@ channels: - default dependencies: - conda - - python=3.7 + - python - conda-env - conda-build - conda-verify From 6965b94070c45ecf734c1f811b8c830119385cbe Mon Sep 17 00:00:00 2001 From: Ian Date: Mon, 22 Jul 2024 15:53:45 -0400 Subject: [PATCH 31/40] Update create-gfdl-catalog.yml `catalogbuilder.intakebuilder` not found in pipeline. b.c. the package isnt installed into the created environment. adding `pip install .` to check --- .github/workflows/create-gfdl-catalog.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/create-gfdl-catalog.yml b/.github/workflows/create-gfdl-catalog.yml index 7961673..768ec70 100644 --- a/.github/workflows/create-gfdl-catalog.yml +++ b/.github/workflows/create-gfdl-catalog.yml @@ -25,6 +25,7 @@ jobs: - name: Install dependencies run: | conda env create -f environment.yml --name catalogbuilder + pip install . - name: Make sample data run: python tests/make_sample_data.py - name: 'Generate catalog' From 6b70e568eb669b746352db6523833a58c54a4724 Mon Sep 17 00:00:00 2001 From: Ian Laflotte Date: Mon, 22 Jul 2024 16:29:28 -0400 Subject: [PATCH 32/40] ... is it because github CI/CD doesn't preserve things between steps like one always expects? .... wouldnt totally suprise me. --- .github/workflows/create-gfdl-catalog.yml | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/.github/workflows/create-gfdl-catalog.yml b/.github/workflows/create-gfdl-catalog.yml index 768ec70..6f10f39 100644 --- a/.github/workflows/create-gfdl-catalog.yml +++ b/.github/workflows/create-gfdl-catalog.yml @@ -28,12 +28,14 @@ jobs: pip install . - name: Make sample data run: python tests/make_sample_data.py - - name: 'Generate catalog' + - name: Generate catalog run: | + pip install . $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/gen_intake_gfdl.py archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp gfdl_autotest - - name: 'Generate catalog with yaml' + - name: Generate catalog with yaml run: | - $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/gen_intake_gfdl.py --config tests/test_config.yaml + pip install . + $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/gen_intake_gfdl.py --config tests/test_config.yaml - name: upload-artifacts1 uses: actions/upload-artifact@v4 with: @@ -50,6 +52,7 @@ jobs: conda install pytest $CONDA/envs/catalogbuilder/bin/pytest -v --runxfail - name: Test for completeness - run: | + run: | + pip install . $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/test_catalog.py -tf gfdl_autotest.json catalogbuilder/cats/gfdl_template.json $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/test_catalog.py -tf catalogbuilder/cats/gfdl_autotest_from_yaml.json From be073ac2e5e7aec64fd11c18e767de5f8e56ace5 Mon Sep 17 00:00:00 2001 From: Ian Laflotte Date: Mon, 22 Jul 2024 16:33:35 -0400 Subject: [PATCH 33/40] one more idea... --- catalogbuilder/scripts/gen_intake_gfdl.py | 1 + 1 file changed, 1 insertion(+) diff --git a/catalogbuilder/scripts/gen_intake_gfdl.py b/catalogbuilder/scripts/gen_intake_gfdl.py index 8a2f6ae..1d13e8b 100755 --- a/catalogbuilder/scripts/gen_intake_gfdl.py +++ b/catalogbuilder/scripts/gen_intake_gfdl.py @@ -10,6 +10,7 @@ logger = logging.getLogger('local') logger.setLevel(logging.INFO) +import catalogbuilder try: from catalogbuilder.intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser except ModuleNotFoundError as exc: From e9766e511bd01b11f30ff4b65a1788de46f3cd28 Mon Sep 17 00:00:00 2001 From: Ian Laflotte Date: Mon, 22 Jul 2024 17:01:44 -0400 Subject: [PATCH 34/40] ONE LAST IDEA i swear. we 1) ask github CI/CD to setup a python3.10 we 2) ask conda to create an env with a python, but the package is NOT installed. i tried "pip install .", but that didnt work... because it used the first python, i imagine. now i will try calling the explicit pip of the CONDA python to install the package, before calling the test. --- .github/workflows/create-gfdl-catalog.yml | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/.github/workflows/create-gfdl-catalog.yml b/.github/workflows/create-gfdl-catalog.yml index 6f10f39..abd8460 100644 --- a/.github/workflows/create-gfdl-catalog.yml +++ b/.github/workflows/create-gfdl-catalog.yml @@ -18,24 +18,29 @@ jobs: uses: actions/setup-python@v3 with: python-version: '3.10' + - name: Add conda to system path run: | # $CONDA is an environment variable pointing to the root of the miniconda directory echo $CONDA/bin >> $GITHUB_PATH + - name: Install dependencies run: | conda env create -f environment.yml --name catalogbuilder - pip install . + - name: Make sample data run: python tests/make_sample_data.py + - name: Generate catalog run: | - pip install . + $CONDA/envs/catalogbuilder/bin/python -m pip install . $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/gen_intake_gfdl.py archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp gfdl_autotest + - name: Generate catalog with yaml run: | pip install . $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/gen_intake_gfdl.py --config tests/test_config.yaml + - name: upload-artifacts1 uses: actions/upload-artifact@v4 with: @@ -45,12 +50,15 @@ jobs: gfdl_autotest.json cats/gfdl_autotest_from_yaml.csv cats/gfdl_autotest_from_yaml.json + - name: Download all workflow run artifacts uses: actions/download-artifact@v4 + - name: Test with pytest run: | conda install pytest $CONDA/envs/catalogbuilder/bin/pytest -v --runxfail + - name: Test for completeness run: | pip install . From 49dc0afd3b5cc7cb431cd069cc3d3bf296861514 Mon Sep 17 00:00:00 2001 From: Ian Laflotte Date: Mon, 22 Jul 2024 17:12:53 -0400 Subject: [PATCH 35/40] OK so there's a few things happening in the workflows. sometimes the environment is built with environemtn.yml, which has a slightly diff array of depencdencies in the yaml file, when compared to the conda-build target, meta.yaml./ --- environment.yml | 22 +++++----------------- 1 file changed, 5 insertions(+), 17 deletions(-) diff --git a/environment.yml b/environment.yml index 47bf473..797e830 100644 --- a/environment.yml +++ b/environment.yml @@ -3,23 +3,11 @@ channels: - conda-forge - default dependencies: - - conda - python - - conda-env - - conda-build - - conda-verify - - _ipyw_jlab_nb_ext_conf - - anaconda==2020.02=py37_0 - - anaconda-navigator - - navigator-updater - - gcsfs - - zarr - - cftime - - cartopy - - xgcm - - pandas - - xarray + - pytest - click - - intake-esm - - pyyaml + - xarray + - pandas - jsondiff + - intake-esm + - boto3 From c12f60c81f2040618e717a36556a1170b4bfc2a9 Mon Sep 17 00:00:00 2001 From: Ian Laflotte Date: Mon, 22 Jul 2024 17:17:39 -0400 Subject: [PATCH 36/40] .... should prob activate the created conda env... --- .github/workflows/create-gfdl-catalog.yml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/.github/workflows/create-gfdl-catalog.yml b/.github/workflows/create-gfdl-catalog.yml index abd8460..3b2f389 100644 --- a/.github/workflows/create-gfdl-catalog.yml +++ b/.github/workflows/create-gfdl-catalog.yml @@ -33,8 +33,9 @@ jobs: - name: Generate catalog run: | - $CONDA/envs/catalogbuilder/bin/python -m pip install . - $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/gen_intake_gfdl.py archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp gfdl_autotest + conda activate catalogbuilder + pip install . + python catalogbuilder/scripts/gen_intake_gfdl.py archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp gfdl_autotest - name: Generate catalog with yaml run: | From 14352041990fc1cfa1af3727530d82ad52cb0802 Mon Sep 17 00:00:00 2001 From: Ian Laflotte Date: Mon, 22 Jul 2024 17:19:44 -0400 Subject: [PATCH 37/40] conda init before conda activate... --- .github/workflows/create-gfdl-catalog.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/create-gfdl-catalog.yml b/.github/workflows/create-gfdl-catalog.yml index 3b2f389..b9acbfc 100644 --- a/.github/workflows/create-gfdl-catalog.yml +++ b/.github/workflows/create-gfdl-catalog.yml @@ -33,6 +33,7 @@ jobs: - name: Generate catalog run: | + conda init conda activate catalogbuilder pip install . python catalogbuilder/scripts/gen_intake_gfdl.py archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp gfdl_autotest From a328d8c7193834a10dbbdae854273df00d2e58e9 Mon Sep 17 00:00:00 2001 From: Ian Laflotte Date: Mon, 22 Jul 2024 17:35:31 -0400 Subject: [PATCH 38/40] use miniconda3 docker image, auto-activate catalogbuilder env created from environment.yaml --- .github/workflows/create-gfdl-catalog.yml | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/.github/workflows/create-gfdl-catalog.yml b/.github/workflows/create-gfdl-catalog.yml index b9acbfc..2ad4227 100644 --- a/.github/workflows/create-gfdl-catalog.yml +++ b/.github/workflows/create-gfdl-catalog.yml @@ -12,6 +12,8 @@ on: jobs: catalog-upload: runs-on: ubuntu-latest + container: + image: continuumio/miniconda3:latest steps: - uses: actions/checkout@v3 - name: Set up Python 3.10 @@ -29,12 +31,12 @@ jobs: conda env create -f environment.yml --name catalogbuilder - name: Make sample data - run: python tests/make_sample_data.py + run: | + python tests/make_sample_data.py - name: Generate catalog + activate-environment: catalogbuilder run: | - conda init - conda activate catalogbuilder pip install . python catalogbuilder/scripts/gen_intake_gfdl.py archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp gfdl_autotest From 59e72b19e182d73a4f24d055eb45bb1c287f6489 Mon Sep 17 00:00:00 2001 From: Ian Laflotte Date: Mon, 22 Jul 2024 17:38:03 -0400 Subject: [PATCH 39/40] oops --- .github/workflows/create-gfdl-catalog.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/create-gfdl-catalog.yml b/.github/workflows/create-gfdl-catalog.yml index 2ad4227..ac23dda 100644 --- a/.github/workflows/create-gfdl-catalog.yml +++ b/.github/workflows/create-gfdl-catalog.yml @@ -35,7 +35,8 @@ jobs: python tests/make_sample_data.py - name: Generate catalog - activate-environment: catalogbuilder + with: + activate-environment: catalogbuilder run: | pip install . python catalogbuilder/scripts/gen_intake_gfdl.py archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp gfdl_autotest From a82f5897e14679ee7a8aa6590fac0e1267dcfa0e Mon Sep 17 00:00:00 2001 From: Ian Laflotte Date: Mon, 22 Jul 2024 18:45:31 -0400 Subject: [PATCH 40/40] revert to last working state before i broke it --- .github/workflows/create-gfdl-catalog.yml | 29 +++++---------------- catalogbuilder/intakebuilder/CSVwriter.py | 2 +- catalogbuilder/intakebuilder/getinfo.py | 2 +- catalogbuilder/intakebuilder/gfdlcrawler.py | 2 +- catalogbuilder/scripts/gen_intake_gfdl.py | 24 ++++++++++------- catalogbuilder/scripts/gen_intake_local.py | 16 ++++-------- catalogbuilder/scripts/gen_intake_s3.py | 4 +-- catalogbuilder/scripts/test_catalog.py | 21 ++++----------- environment.yml | 24 ++++++++++++----- 9 files changed, 54 insertions(+), 70 deletions(-) diff --git a/.github/workflows/create-gfdl-catalog.yml b/.github/workflows/create-gfdl-catalog.yml index ac23dda..7961673 100644 --- a/.github/workflows/create-gfdl-catalog.yml +++ b/.github/workflows/create-gfdl-catalog.yml @@ -12,40 +12,27 @@ on: jobs: catalog-upload: runs-on: ubuntu-latest - container: - image: continuumio/miniconda3:latest steps: - uses: actions/checkout@v3 - name: Set up Python 3.10 uses: actions/setup-python@v3 with: python-version: '3.10' - - name: Add conda to system path run: | # $CONDA is an environment variable pointing to the root of the miniconda directory echo $CONDA/bin >> $GITHUB_PATH - - name: Install dependencies run: | conda env create -f environment.yml --name catalogbuilder - - name: Make sample data + run: python tests/make_sample_data.py + - name: 'Generate catalog' run: | - python tests/make_sample_data.py - - - name: Generate catalog - with: - activate-environment: catalogbuilder - run: | - pip install . - python catalogbuilder/scripts/gen_intake_gfdl.py archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp gfdl_autotest - - - name: Generate catalog with yaml + $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/gen_intake_gfdl.py archive/am5/am5/am5f3b1r0/c96L65_am5f3b1r0_pdclim1850F/gfdl.ncrc5-deploy-prod-openmp/pp gfdl_autotest + - name: 'Generate catalog with yaml' run: | - pip install . - $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/gen_intake_gfdl.py --config tests/test_config.yaml - + $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/gen_intake_gfdl.py --config tests/test_config.yaml - name: upload-artifacts1 uses: actions/upload-artifact@v4 with: @@ -55,17 +42,13 @@ jobs: gfdl_autotest.json cats/gfdl_autotest_from_yaml.csv cats/gfdl_autotest_from_yaml.json - - name: Download all workflow run artifacts uses: actions/download-artifact@v4 - - name: Test with pytest run: | conda install pytest $CONDA/envs/catalogbuilder/bin/pytest -v --runxfail - - name: Test for completeness - run: | - pip install . + run: | $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/test_catalog.py -tf gfdl_autotest.json catalogbuilder/cats/gfdl_template.json $CONDA/envs/catalogbuilder/bin/python catalogbuilder/scripts/test_catalog.py -tf catalogbuilder/cats/gfdl_autotest_from_yaml.json diff --git a/catalogbuilder/intakebuilder/CSVwriter.py b/catalogbuilder/intakebuilder/CSVwriter.py index 7819f17..9a6a33f 100644 --- a/catalogbuilder/intakebuilder/CSVwriter.py +++ b/catalogbuilder/intakebuilder/CSVwriter.py @@ -1,7 +1,7 @@ import os.path import csv from csv import writer -from . import builderconfig, configparser +from intakebuilder import builderconfig, configparser def getHeader(configyaml): ''' diff --git a/catalogbuilder/intakebuilder/getinfo.py b/catalogbuilder/intakebuilder/getinfo.py index 53e1185..d974c29 100644 --- a/catalogbuilder/intakebuilder/getinfo.py +++ b/catalogbuilder/intakebuilder/getinfo.py @@ -4,7 +4,7 @@ from csv import writer import os import xarray as xr -from . import builderconfig, configparser +from intakebuilder import builderconfig, configparser ''' diff --git a/catalogbuilder/intakebuilder/gfdlcrawler.py b/catalogbuilder/intakebuilder/gfdlcrawler.py index d8f871a..dd81c04 100644 --- a/catalogbuilder/intakebuilder/gfdlcrawler.py +++ b/catalogbuilder/intakebuilder/gfdlcrawler.py @@ -1,5 +1,5 @@ import os -from . import getinfo, builderconfig +from intakebuilder import getinfo, builderconfig import sys import re import operator as op diff --git a/catalogbuilder/scripts/gen_intake_gfdl.py b/catalogbuilder/scripts/gen_intake_gfdl.py index 1d13e8b..a99b667 100755 --- a/catalogbuilder/scripts/gen_intake_gfdl.py +++ b/catalogbuilder/scripts/gen_intake_gfdl.py @@ -10,16 +10,23 @@ logger = logging.getLogger('local') logger.setLevel(logging.INFO) -import catalogbuilder try: - from catalogbuilder.intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser -except ModuleNotFoundError as exc: - raise Exception(f"import problems!!!") from exc + from intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser +except ModuleNotFoundError: + print("The module intakebuilder is not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") + print("Attempting again with adjusted sys.path ") + try: + sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + except: + print("Unable to adjust sys.path") + #print(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + try: + from intakebuilder import gfdlcrawler, CSVwriter, builderconfig, configparser + except ModuleNotFoundError: + sys.exit("The module 'intakebuilder' is still not installed. Do you have intakebuilder in your sys.path or have you activated the conda environment with the intakebuilder package in it? ") package_dir = os.path.dirname(os.path.abspath(__file__)) - -import catalogbuilder.cats -template_path = catalogbuilder.cats.__path__[0] + '/gfdl_template.json' +template_path = os.path.join(package_dir, '../cats/gfdl_template.json') #Setting up argument parsing/flags @click.command() @@ -28,8 +35,7 @@ #,help='The directory path with the datasets to be cataloged. E.g a GFDL PP path till /pp') @click.argument('output_path',required=False,nargs=1) #,help='Specify output filename suffix only. e.g. catalog') -@click.option('--config',required=False,type=click.Path(exists=True),nargs=1, - help='Path to your yaml config, Use the config_template in intakebuilder repo') +@click.option('--config',required=False,type=click.Path(exists=True),nargs=1,help='Path to your yaml config, Use the config_template in intakebuilder repo') @click.option('--filter_realm', nargs=1) @click.option('--filter_freq', nargs=1) @click.option('--filter_chunk', nargs=1) diff --git a/catalogbuilder/scripts/gen_intake_local.py b/catalogbuilder/scripts/gen_intake_local.py index ad06b57..673cd16 100755 --- a/catalogbuilder/scripts/gen_intake_local.py +++ b/catalogbuilder/scripts/gen_intake_local.py @@ -10,22 +10,17 @@ def main(): #######INPUT HERE OR USE FROM A CONFIG FILE LATER###### - #project_dir = "/Users/ar46/data_cmip6/CMIP6/" # DRS COMPLIANT PROJECT DIR +# project_dir = "/Users/ar46/data_cmip6/CMIP6/" # DRS COMPLIANT PROJECT DIR project_dir = "/uda/CMIP6/"# #CMIP/NOAA-GFDL/GFDL-ESM4/" - ##"/Users/ar46/PycharmProjects/CatalogBuilder/intakebuilder/test/intake_local.csv" - csvfile = "/nbhome/a1r/intakebuilder_cats/intake_local.csv" + csvfile = "/nbhome/a1r/intakebuilder_cats/intake_local.csv" ##"/Users/ar46/PycharmProjects/CatalogBuilder/intakebuilder/test/intake_local.csv" ####################################################### - ######### SEARCH FILTERS ########################### dictFilter = {} - dictFilter["source_prefix"]= 'CMIP6/' - #CMIP/CMCC/CMCC-CM2-SR5' #'CMIP6/CMIP/' - #NOAA-GFDL/GFDL-CM4/' #/CMIP/NOAA-GFDL/GFDL-ESM4/' #Must specify something here, at least the project level - #COMMENT dictFilter["miptable"] = "Amon" #Remove this if you don't want to filter by miptable - #COMMENT dictFilter["varname"] = "tas" #Remove this if you don't want to filter by variable name + dictFilter["source_prefix"]= 'CMIP6/' #CMIP/CMCC/CMCC-CM2-SR5' #'CMIP6/CMIP/' #NOAA-GFDL/GFDL-CM4/' #/CMIP/NOAA-GFDL/GFDL-ESM4/' #Must specify something here, at least the project level + #COMMENT dictFilter["miptable"] = "Amon" #Remove this if you don't want to filter by miptable + #COMMENT dictFilter["varname"] = "tas" #Remove this if you don't want to filter by variable name ######################################################### - dictInfo = {} project_dir = project_dir.rstrip("/") logger.info("Calling localcrawler.crawlLocal") @@ -37,6 +32,5 @@ def main(): CSVwriter.listdict_to_csv(list_files, headers, csvfile) print("CSV generated at:", os.path.abspath(csvfile)) logger.info("CSV generated at"+ os.path.abspath(csvfile)) - if __name__ == '__main__': main() diff --git a/catalogbuilder/scripts/gen_intake_s3.py b/catalogbuilder/scripts/gen_intake_s3.py index 8eccc60..69a8afb 100755 --- a/catalogbuilder/scripts/gen_intake_s3.py +++ b/catalogbuilder/scripts/gen_intake_s3.py @@ -15,8 +15,8 @@ def main(): ######### SEARCH FILTERS ########################### dictFilter = {} dictFilter["source_prefix"]= 'CMIP6/' #/CMIP/NOAA-GFDL/GFDL-ESM4/' #Must specify something here, at least the project level - #COMMENT dictFilter["miptable"] = "Amon" #Remove this if you don't want to filter by miptable - #COMMENT dictFilter["varname"] = "tas" #Remove this if you don't want to filter by variable name + #COMMENT dictFilter["miptable"] = "Amon" #Remove this if you don't want to filter by miptable + #COMMENT dictFilter["varname"] = "tas" #Remove this if you don't want to filter by variable name ####################################################### project_bucket = project_root.split("/")[1].lstrip("/") project_name = project_root.split("/")[2] diff --git a/catalogbuilder/scripts/test_catalog.py b/catalogbuilder/scripts/test_catalog.py index 1d838da..ed44d95 100755 --- a/catalogbuilder/scripts/test_catalog.py +++ b/catalogbuilder/scripts/test_catalog.py @@ -9,22 +9,14 @@ @click.command() @click.argument('json_path', nargs = 1 , required = True) @click.argument('json_template_path', nargs = 1 , required = False) -@click.option('-tf', '--test-failure', is_flag=True, default = False, - help="Errors are only printed. Program will not exit.") +@click.option('-tf', '--test-failure', is_flag=True, default = False, help="Errors are only printed. Program will not exit.") def main(json_path,json_template_path,test_failure): - """ This test ensures catalogs generated by the Catalog Builder tool are minimally valid. - This means a few things: the generated catalog JSON file reflects the template it was - generated with, the catalog CSV has atleast one row of values (not headers), and each - required column exists without any empty values. If a test case is broken or expected to - fail, the --test-failure/-tf flag can be used. This flag will simply print errors - instead of doing a sys.exit. + """ This test ensures catalogs generated by the Catalog Builder tool are minimally valid. This means a few things: the generated catalog JSON file reflects the template it was generated with, the catalog CSV has atleast one row of values (not headers), and each required column exists without any empty values. If a test case is broken or expected to fail, the --test-failure/-tf flag can be used. This flag will simply print errors instead of doing a sys.exit. - JSON_PATH: Path to generated schema to be tested + JSON_PATH: Path to generated schema to be tested - JSON_TEMPLATE_PATH: Path of schema template. Without a given path, cats/gfdl_template.json - will be used for comparison - """ + JSON_TEMPLATE_PATH: Path of schema template. Without a given path, cats/gfdl_template.json will be used for comparison """ #Open JSON j = json.load(open(json_path)) @@ -59,10 +51,7 @@ def main(json_path,json_template_path,test_failure): errors = 0 for column in req: if column not in catalog.columns: - print(f"The required column '{column}' does not exist in the csv. In other words, " - "there is some inconsistency between the json and the csv file. Please check " - "out info listed under aggregation_control and groupby_attrs in your json file" - " and verify if those columns show up in the csv as well." ) + print(f"The required column '{column}' does not exist in the csv. In other words, there is some inconsistency between the json and the csv file. Please check out info listed under aggregation_control and groupby_attrs in your json file and verify if those columns show up in the csv as well.") errors += 1 if column in catalog.columns: diff --git a/environment.yml b/environment.yml index 797e830..9c0683c 100644 --- a/environment.yml +++ b/environment.yml @@ -3,11 +3,23 @@ channels: - conda-forge - default dependencies: - - python - - pytest - - click - - xarray + - conda + - python=3.7 + - conda-env + - conda-build + - conda-verify + - _ipyw_jlab_nb_ext_conf + - anaconda==2020.02=py37_0 + - anaconda-navigator + - navigator-updater + - gcsfs + - zarr + - cftime + - cartopy + - xgcm - pandas + - xarray + - click + - intake-esm + - pyyaml - jsondiff - - intake-esm - - boto3