def getCPPCookies(self): # reads cookies from client
if environ.has_key('HTTP_COOKIE'):
for eachCookie in map(strip, \
split(environ['HTTP_COOKIE'], ';')):
if len(eachCookie) > 6 and \
eachCookie[:3] == 'CPP':
tag = eachCookie[3:7]
try:
self.cookies[tag] = \
eval(unquote(eachCookie[8:]))
except (NameError, SyntaxError):
self.cookies[tag] = \
unquote(eachCookie[8:])
else:
self.cookies['info'] = self.cookies['user'] = ''
if self.cookies['info'] != '':
self.who, langStr, self.fn = \
split(self.cookies['info'], ':')
self.langs = split(langStr, ',')
else:
self.who = self.fn = ''
self.langs = ['Python']
python类has_key()的实例源码
def showForm(self): # show fill-out form
self.getCPPCookies()
langStr = ''
for eachLang in AdvCGI.langSet:
if eachLang in self.langs:
langStr = langStr + AdvCGI.langItem % \
(eachLang, ' CHECKED', eachLang)
else:
langStr = langStr + AdvCGI.langItem % \
(eachLang, '', eachLang)
if not self.cookies.has_key('user') or \
self.cookies['user'] == '':
cookieStatus = '<I>(cookie has not been set yet)</I>'
userCook = ''
else:
userCook = cookieStatus = self.cookies['user']
print AdvCGI.header + AdvCGI.formhtml % (AdvCGI.url,
cookieStatus, userCook, self.who, langStr, self.fn)
def getCPPCookies(self):
if environ.has_key('HTTP_COOKIE'):
#s('reading cookies from server...\n')
for eachCookie in map(strip, split(environ['HTTP_COOKIE'], ';')):
if len(eachCookie) > 6 and eachCookie[:3] == 'CPP':
tag = eachCookie[3:7]
try:
self.cookies[tag] = eval(unquote(eachCookie[8:]))
except (NameError, SyntaxError):
self.cookies[tag] = unquote(eachCookie[8:])
else:
#s('no cookies on server...\n')
self.cookies['info'] = self.cookies['user'] = ''
#s('cookies: %s\n' % str(self.cookies))
if self.cookies['info'] != '':
self.who, langStr, self.fn = split(self.cookies['info'], ':')
self.langs = split(langStr, ',')
else:
self.who = self.fn = ''
self.langs = ['Python']
def showForm(self):
self.getCPPCookies() # get cookies
# put together lang checkboxes
langStr = ''
for eachLang in AdvCGI.langSet:
if eachLang in self.langs:
langStr = langStr + AdvCGI.langItem % (eachLang, ' CHECKED', eachLang)
else:
langStr = langStr + AdvCGI.langItem % (eachLang, '', eachLang)
# see if user cookie set up yet
if not self.cookies.has_key('user') or self.cookies['user'] == '':
cookieStatus = '<I>(cookie has not been set yet)</I>'
userCook = ''
else:
userCook = cookieStatus = self.cookies['user']
# output results
#s('filename: ' + self.fn + '\n')
print AdvCGI.header + AdvCGI.formhtml % (AdvCGI.url, cookieStatus, userCook, self.who, langStr, self.fn)
#print AdvCGI.header + AdvCGI.formhtml % (AdvCGI.url, cookieStatus, userCook, self.who, langStr)
def restrictParameters(self) :
# Initialise allowed parameters
allowed_parameters = {}
for group_code in self.parameter_group_codes :
allowed_parameters[group_code] = self.parameter_via_group_codes[group_code][:]
# Resolve any restrictions based on data type
data_type = self.data_type_text.get()
if self.parameter_restricted_via_data_type.has_key(data_type) :
for group_code in self.parameter_group_codes :
if self.parameter_restricted_via_data_type[data_type].has_key(group_code) :
allowed_parameters[group_code] = self.parameter_restricted_via_data_type[data_type][group_code]
# Enable/disable parameter selections appropriately
allowed_groups = []
for i, group_code in enumerate(self.parameter_group_codes) :
if allowed_parameters[group_code] :
allowed_groups.append(group_code)
self.parameter_group_menu['menu'].entryconfigure(i, state=tk.NORMAL)
for j, parameter_code in enumerate(self.parameter_via_group_codes[group_code]) :
if len(self.parameter_via_group_codes[group_code]) > 1 or self.parameter_via_group_codes[group_code][0] != group_code :
if parameter_code in allowed_parameters[group_code] :
self.parameter_via_group_menu[group_code]['menu'].entryconfigure(j, state=tk.NORMAL)
else :
self.parameter_via_group_menu[group_code]['menu'].entryconfigure(j, state=tk.DISABLED)
else :
self.parameter_group_menu['menu'].entryconfigure(i, state=tk.DISABLED)
# Select another parameter/group if the current selection is not allowed
selected_group = self.parameter_group_selection_map[self.parameter_group_text.get()]
if selected_group not in allowed_groups :
self.selectParameterGroup(allowed_groups[0])
else :
selected_parameter = self.parameter_via_group_selection_map[selected_group][self.parameter_via_group_text[selected_group].get()]
if selected_parameter not in allowed_parameters[selected_group] :
self.selectParameter(selected_group, allowed_parameters[selected_group][0])
# Step 2 Method: Restrict Time Unit Via Data Type and/or Parameter
def restrictTimeUnit(self) :
# Initialise allowed time units
allowed_time_units = self.time_unit_selection[:]
# Resolve any restrictions based on data type
data_type = self.data_type_text.get()
if self.time_unit_restricted_via_data_type.has_key(data_type) :
allowed_time_units = self.time_unit_restricted_via_data_type[data_type][:]
# Resolve any restrictions based on parameter
group_code = self.parameter_group_selection_map[self.parameter_group_text.get()]
if self.time_unit_restricted_via_parameter.has_key(group_code) :
parameter_code = self.parameter_via_group_selection_map[group_code][self.parameter_via_group_text[group_code].get()]
if self.time_unit_restricted_via_parameter[group_code].has_key(parameter_code) :
for time_unit in allowed_time_units[:] :
if time_unit not in self.time_unit_restricted_via_parameter[group_code][parameter_code] :
allowed_time_units.remove(time_unit)
# Enable/disable time unit selections appropriately
for i, selection in enumerate(self.time_unit_selection) :
if selection in allowed_time_units :
self.time_unit_menu['menu'].entryconfigure(i, state=tk.NORMAL)
else :
self.time_unit_menu['menu'].entryconfigure(i, state=tk.DISABLED)
# Select another time unit if the current selection is not allowed
if self.time_unit_text.get() not in allowed_time_units :
self.selectTimeUnit(allowed_time_units[0])
# Step 2 Method: Select Time Unit: the user selects an option
def doResults(self):
MAXBYTES = 1024
langlist = ''
for eachLang in self.langs:
langlist = langlist + '<LI>%s<BR>' % eachLang
filedata = ''
while len(filedata) < MAXBYTES: # read file chunks
data = self.fp.readline()
if data == '': break
filedata = filedata + data
else: # truncate if too long
filedata = filedata + \
'... <B><I>(file truncated due to size)</I></B>'
self.fp.close()
if filedata == '':
filedata = \
'<B><I>(file upload error or file not given)</I></B>'
filename = self.fn
if not self.cookies.has_key('user') or \
self.cookies['user'] == '':
cookieStatus = '<I>(cookie has not been set yet)</I>'
userCook = ''
else:
userCook = cookieStatus = self.cookies['user']
self.cookies['info'] = join([self.who, \
join(self.langs, ','), filename], ':')
self.setCPPCookies()
print AdvCGI.header + AdvCGI.reshtml % \
(cookieStatus, self.who, langlist,
filename, filedata, AdvCGI.url)
def doResults(self):
MAXBYTES = 1024
langlist = ''
for eachLang in self.langs:
langlist = langlist + '<LI>%s<BR>' % eachLang
filedata = ''
while len(filedata) < MAXBYTES:
data = self.fp.readline()
if data == '': break
filedata = filedata + data
else:
filedata = filedata + '... <B><I>(file truncated due to size)</I></B>'
self.fp.close()
if filedata == '':
filedata = '<B><I>(file upload error or file not given)</I></B>'
filename = self.fn
# see if user cookie set up yet
if not self.cookies.has_key('user') or self.cookies['user'] == '':
cookieStatus = '<I>(cookie has not been set yet)</I>'
userCook = ''
else:
userCook = cookieStatus = self.cookies['user']
# set cookies
self.cookies['info'] = join([self.who, join(self.langs, ','), filename], ':')
self.setCPPCookies()
# output page
print AdvCGI.header + AdvCGI.reshtml % (cookieStatus, self.who, langlist, filename, filedata, AdvCGI.url)
def getCPPCookies(self):
if environ.has_key('HTTP_COOKIE'):
#s('reading cookies from server...\n')
#for eachCookie in map(strip, split(environ['HTTP_COOKIE'], ';')):
cookies = [x.strip() for x in environ['HTTP_COOKIE'].split(';')]
for eachCookie in cookies:
if len(eachCookie) > 6 and eachCookie[:3] == 'CPP':
tag = eachCookie[3:7]
try:
self.cookies[tag] = eval(unquote(eachCookie[8:]))
except (NameError, SyntaxError):
self.cookies[tag] = unquote(eachCookie[8:])
if not self.cookies.has_key('info'):
self.cookies['info'] = ''
if not self.cookies.has_key('user'):
self.cookies['user'] = ''
else:
#s('no cookies on server...\n')
self.cookies['info'] = self.cookies['user'] = ''
#s('cookies: %s\n' % str(self.cookies))
if self.cookies['info'] != '':
self.who, langStr, self.fn = self.cookies['info'].split(':')
self.langs = langStr.split(',')
else:
self.who = self.fn = ''
self.langs = ['Python']
def doResults(self):
MAXBYTES = 1024
langlist = ''
for eachLang in self.langs:
langlist = langlist + '<LI>%s<BR>' % eachLang
filedata = ''
while len(filedata) < MAXBYTES:
data = self.fp.readline()
if data == '': break
filedata = filedata + data
else:
filedata = filedata + '... <B><I>(file truncated due to size)</I></B>'
self.fp.close()
if filedata == '':
filedata = '<B><I>(file upload error or file not given)</I></B>'
filename = self.fn
# see if user cookie set up yet
if not self.cookies.has_key('user') or self.cookies['user'] == '':
cookieStatus = '<I>(cookie has not been set yet)</I>'
userCook = ''
else:
userCook = cookieStatus = self.cookies['user']
# set cookies
self.cookies['info'] = ':'.join([self.who, ','.join(self.langs), filename])
self.setCPPCookies()
# output page
print AdvCGI.header + AdvCGI.reshtml % (cookieStatus, self.who, langlist, filename, filedata, AdvCGI.url)
def fpaste_it(inputdata, lang='text', author=None, password=None, private='no', expire=28, project=None, url='http://paste.fedoraproject.org'):
"""Submit a new paste to fedora project pastebin."""
# Establish critical params
params = {
'paste_data': inputdata,
'paste_lang': lang,
'api_submit': 'true',
'mode': 'json',
'paste_private': private,
'paste_expire': str(expire*24*60*60),
}
# Add optional params
if password:
params['paste_password'] = password
if project:
params['paste_project'] = project
if author:
# If author is too long, truncate
if len(author) > 50:
author = author[0:47] + "..."
params['paste_user'] = author
# Check size of what we're about to post and raise exception if too big
# FIXME: Figure out how to do this in requests without wasteful call to urllib.urlencode()
from urllib import urlencode
p = urlencode(params)
pasteSizeKiB = len(p)/1024.0
if pasteSizeKiB >= 512:
raise ValueError("Fedora Pastebin client WARN: paste size ({0:.1f} KiB) too large (max size: 512 KiB)".format(pasteSizeKiB))
# Print status, then connect
logger.log(25, "Fedora Pastebin client uploading {0:.1f} KiB...".format(pasteSizeKiB))
r = requests.post(url, params)
r.raise_for_status()
try:
j = r.json()
except:
# If no json returned, we've hit some weird error
from tempfile import NamedTemporaryFile
tmp = NamedTemporaryFile(delete=False)
print(r.content, file=tmp)
tmp.flush()
raise ValueError("Fedora Pastebin client ERROR: Didn't receive expected JSON response (saved to '{0}' for debugging)".format(tmp.name))
# Error keys adapted from Jason Farrell's fpaste
if j.has_key('error'):
err = j['error']
if err == 'err_spamguard_php':
raise ValueError("Fedora Pastebin server ERROR: Poster's IP rejected as malicious")
elif err == 'err_spamguard_noflood':
raise ValueError("Fedora Pastebin server ERROR: Poster's IP rejected as trying to flood")
elif err == 'err_spamguard_stealth':
raise ValueError("Fedora Pastebin server ERROR: Paste input triggered spam filter")
elif err == 'err_spamguard_ipban':
raise ValueError("Fedora Pastebin server ERROR: Poster's IP rejected as permanently banned")
elif err == 'err_author_numeric':
raise ValueError("Fedora Pastebin server ERROR: Poster's author should be alphanumeric")
else:
raise ValueError("Fedora Pastebin server ERROR: '{0}'".format(err))
# Put together URL with optional hash if requested
pasteUrl = '{0}/{1}'.format(url, j['result']['id'])
if 'yes' in private and j['result'].has_key('hash'):
pasteUrl += '/{0}'.format(j['result']['hash'])
return pasteUrl
def selectClimateDataDirectory(self) :
# Use existing Climate Data Directory if it exists
current_dir = self.climate_data_directory_text.get()
if path.exists(current_dir) :
initial_directory = current_dir
elif MAC_VERSION and environ.has_key('HOME') and path.exists(environ['HOME']) :
initial_directory = environ['HOME']
elif environ.has_key('USERPROFILE') and path.exists(environ['USERPROFILE']) : # PC version
initial_directory = environ['USERPROFILE']
else :
initial_directory = getcwd()
# Open file selection dialog
climate_data_directory_path = askdirectory(title='Select the directory containing the climate data', initialdir=initial_directory)
if climate_data_directory_path : # Directory selected
# Create directory if it doesn't already exist
if not path.exists(climate_data_directory_path) :
try :
climate_data_directory_path = self.data_file_helper.createDirectoryPath(climate_data_directory_path)
except Exception, e :
directory_name = self.data_file_helper.splitPath(climate_data_directory_path)['name']
showerror('Directory Error', 'Error loading or creating directory \"'+directory_name+'\". Check file permissions.')
print >> sys.stderr, 'Error loading or creating directory:', e
# Set the climate data directory appropriately
climate_data_directory_path = path.normpath(str(climate_data_directory_path))
previous_path = self.data_file_helper.getClimateDataDirectoryPath()
self.data_file_helper.setClimateDataDirectory(climate_data_directory_path)
if hasattr(self, 'config_climate_data_location_window') and self.config_climate_data_location_window.children :
# Does it contain the climate data?
if self.data_file_helper.climateDataIsPresent() :
self.climate_data_directory_text.set(climate_data_directory_path)
self.setToolOptions({ 'climate_data_directory' : climate_data_directory_path })
# Reset focus to config window
self.config_climate_data_location_window.focus_set()
else :
showwarning('Climate data not found', 'None of the expected climate data was not found in ' + climate_data_directory_path)
self.data_file_helper.setClimateDataDirectory(previous_path)
elif hasattr(self, 'download_climate_data_window') and self.download_climate_data_window.children :
self.climate_data_directory_text.set(climate_data_directory_path)
self.setToolOptions({ 'climate_data_directory' : climate_data_directory_path })
# Reset focus to download window
self.download_climate_data_window.focus_set()
# Menu Method: Configure Default File Generation Directory
def selectDefaultFileGenerationDirectory(self) :
# Get current config tool options
tool_option_values = self.getToolOptions()
# Use existing Default File Generation Directory if it exists
if path.exists(tool_option_values['default_file_generation_directory']) :
initial_directory = tool_option_values['default_file_generation_directory']
elif MAC_VERSION and environ.has_key('HOME') and path.exists(environ['HOME']) :
initial_directory = environ['HOME']
elif environ.has_key('USERPROFILE') and path.exists(environ['USERPROFILE']) : # PC version
initial_directory = environ['USERPROFILE']
else :
initial_directory = getcwd()
# Open file selection dialog
default_file_generation_directory_path = askdirectory(title='Select the default directory for output files', initialdir=initial_directory)
if default_file_generation_directory_path : # Directory selected
# Create directory if it doesn't already exist
if not path.exists(default_file_generation_directory_path) :
try :
default_file_generation_directory_path = self.data_file_helper.createDirectoryPath(default_file_generation_directory_path)
except Exception, e :
directory_name = self.data_file_helper.splitPath(default_file_generation_directory_path)['name']
showerror('Directory Error', 'Error loading or creating directory \"'+directory_name+'\". Check file permissions.')
print >> sys.stderr, 'Error loading or creating directory:', e
# Set the directory
default_file_generation_directory_path = path.normpath(str(default_file_generation_directory_path))
self.data_file_helper.setFileGenerationDirectory(default_file_generation_directory_path)
location_descr = 'File generation in \"' + self.data_file_helper.getFileGenerationDirectoryName() + '\"'
self.generation_directory_label_text.set(location_descr)
self.default_file_generation_directory_location.set(default_file_generation_directory_path)
self.setToolOptions({ 'default_file_generation_directory' : default_file_generation_directory_path, 'default_file_generation_directory_set' : True })
# Enable the generate button
self.generate_button.configure(state=tk.NORMAL)
# Reset focus to config window
self.config_default_file_generation_directory_window.focus_set()
# Menu Method: Download Climate Data
def downloadSelectedClimateData(self) :
# Override URL and proxy
self.setClimateDataLocation(download=True)
# Get download data parameters and intervals required
data_parameters_selected = []
for data_parameter in self.data_file_helper.getDataParameters() :
if self.climate_data_parameter_int.has_key(data_parameter) and self.climate_data_parameter_int[data_parameter].get() :
data_parameters_selected.append(data_parameter)
download_intervals_selected = []
for download_interval in self.data_file_helper.getClimateDataDownloadIntervals() :
if self.climate_download_interval_int.has_key(download_interval) and self.climate_download_interval_int[download_interval].get() :
download_intervals_selected.append(download_interval)
# Download and unpack NetCDF files
if self.data_file_helper.getClimateDataUrl() and self.data_file_helper.getClimateDataDirectoryPath() and data_parameters_selected and download_intervals_selected :
for data_parameter in data_parameters_selected :
for download_interval in download_intervals_selected :
overwrite_ok = True
if self.data_file_helper.climateDataDownloadIntervalPresent(data_parameter, download_interval) :
overwrite_ok = askyesno('Data already present: overwrite?',
'The data for '+data_parameter.replace('_',' ').title()+' interval '+download_interval+' is already present in the directory selected.\n\n'+
'Do you wish to download again and overwrite the existing file?', parent=self.download_climate_data_window)
if overwrite_ok :
self.climate_data_download_button.configure(state=tk.DISABLED)
self.climate_data_download_status_text.set('Downloading ' + data_parameter.replace('_',' ').title() + ' ' + download_interval + ' ...')
self.climate_data_download_status_bar['maximum'] = 1
self.climate_data_download_status_bar['value'] = 0
self.climate_data_download_status_bar.grid()
self.update() # .update_idletasks()
try :
self.data_file_helper.downloadClimateDataInterval(data_parameter, download_interval, delimiter='')
except Exception, e :
if hasattr(self, 'download_climate_data_window') and self.download_climate_data_window.children :
showerror('Data download error', str(e), parent=self.download_climate_data_window)
print >> sys.stderr, 'Data download error:', e
if self.download_climate_data_window.children :
self.climate_data_download_status_text.set('')
self.climate_data_download_status_bar.grid_remove()
self.climate_data_download_button.configure(state=tk.NORMAL)
self.update() # .update_idletasks()
else :
if not self.data_file_helper.getClimateDataUrl() :
showinfo('Download from URL not defined', 'Please enter the URL location of the climate data download(s).', parent=self.download_climate_data_window)
elif not self.data_file_helper.getClimateDataDirectoryPath() :
showinfo('Download to Directory not defined', 'Please select the directory destination for the climate data download(s).', parent=self.download_climate_data_window)
elif not (data_parameters_selected and download_intervals_selected) :
showinfo('Download Selection not fully defined', 'Please select the climate data parameters and intervals to download.', parent=self.download_climate_data_window)
## Step 1: Data Type Methods ################################################################################################################################################
# Step 1 Method: Select data type: the user selects an option
def selectGenerationDirectory(self) :
# Place focus on select directory button
self.generation_directory_button.focus_set()
# Reset generation
self.resetGeneration()
# Get current config tool options
tool_option_values = self.getToolOptions()
# Use existing/last used generation directory if it exists otherwise use default directory
if self.data_file_helper.getFileGenerationDirectoryPath() and path.exists(self.data_file_helper.getFileGenerationDirectoryPath()) :
initial_directory = self.data_file_helper.getFileGenerationDirectoryPath()
elif tool_option_values['default_file_generation_directory'] and path.exists(tool_option_values['default_file_generation_directory']) :
initial_directory = tool_option_values['default_file_generation_directory']
elif MAC_VERSION and environ.has_key('HOME') and path.exists(environ['HOME']) :
initial_directory = environ['HOME']
elif environ.has_key('USERPROFILE') and path.exists(environ['USERPROFILE']) : # PC version
initial_directory = environ['USERPROFILE']
else :
initial_directory = getcwd()
# Open file selection dialog
generation_directory_path = askdirectory(title='Select the directory to generate files', initialdir=initial_directory)
if generation_directory_path : # Directory selected
# Create directory if it doesn't already exist
if not path.exists(generation_directory_path) :
try :
generation_directory_path = self.data_file_helper.createDirectoryPath(generation_directory_path)
except Exception, e :
directory_name = self.data_file_helper.splitPath(generation_directory_path)['name']
showerror('Directory Error', 'Error loading or creating directory \"'+directory_name+'\". Check file permissions.')
print >> sys.stderr, 'Error loading or creating directory:', e
# Set path
generation_directory_path = path.normpath(str(generation_directory_path))
self.data_file_helper.setFileGenerationDirectory(generation_directory_path)
location_descr = 'File generation in \"' + self.data_file_helper.getFileGenerationDirectoryName() + '\"'
self.generation_directory_label_text.set(location_descr)
# Set default when not already set via config options
if not tool_option_values['default_file_generation_directory'] or not path.exists(tool_option_values['default_file_generation_directory']) or not tool_option_values['default_file_generation_directory_set'] :
self.setToolOptions({ 'default_file_generation_directory' : generation_directory_path })
# Enable the generate button
self.generate_button.configure(state=tk.NORMAL)
# Step 7 Method: Generate Data Files
def calculateColourSchemeBoundaries(self) :
# Find minimum and maximum data values and colour scheme interval
if self.map_colour_scheme == '90%_range' :
data_5th_percentile = min(self.grid_plot_statistics['region']['percentile_5th'])
data_95th_percentile = max(self.grid_plot_statistics['region']['percentile_95th'])
scheme_interval = (data_95th_percentile - data_5th_percentile)/9
data_min = data_5th_percentile - scheme_interval
data_max = data_95th_percentile + scheme_interval
else : # fixed_range
# Resolve selected parameter/group codes
parameter_group_code = self.parameter_group_selection_map[self.parameter_group_text.get()]
parameter_code = self.parameter_via_group_selection_map[parameter_group_code][self.parameter_via_group_text[parameter_group_code].get()]
# Select fixed colour scheme via parameter codes and delta settings
if self.utilise_delta.get() :
if self.delta_as_percent.get() and self.parameter_fixed_range_colour_scheme[parameter_group_code][parameter_code].has_key('%delta') :
fixed_range_colour_scheme = self.parameter_fixed_range_colour_scheme[parameter_group_code][parameter_code]['%delta']
else :
fixed_range_colour_scheme = self.parameter_fixed_range_colour_scheme[parameter_group_code][parameter_code]['delta']
else :
fixed_range_colour_scheme = self.parameter_fixed_range_colour_scheme[parameter_group_code][parameter_code]['value']
# Prioritise min/max then first/last boundaries, use statistical min/max when neither provided
if fixed_range_colour_scheme['min'] != None :
data_min = fixed_range_colour_scheme['min']
elif fixed_range_colour_scheme['first_boundary'] != None :
data_min = None
else :
data_min = min(self.grid_plot_statistics['region']['minimum'])
if fixed_range_colour_scheme['max'] != None :
data_max = fixed_range_colour_scheme['max']
elif fixed_range_colour_scheme['last_boundary'] != None :
data_max = None
else :
data_max = max(self.grid_plot_statistics['region']['maximum'])
# Resolve scheme interval and unresolved min/max
if data_min == None and data_max == None :
scheme_interval = (fixed_range_colour_scheme['last_boundary'] - fixed_range_colour_scheme['first_boundary'])/9.0
data_min = fixed_range_colour_scheme['first_boundary'] - scheme_interval
data_max = fixed_range_colour_scheme['last_boundary'] + scheme_interval
elif data_min == None :
scheme_interval = (data_max - fixed_range_colour_scheme['first_boundary'])/10.0
data_min = fixed_range_colour_scheme['first_boundary'] - scheme_interval
elif data_max == None :
scheme_interval = (fixed_range_colour_scheme['last_boundary'] - data_min)/10.0
data_max = fixed_range_colour_scheme['last_boundary'] + scheme_interval
else :
scheme_interval = (data_max - data_min)/11.0
# Return colour scheme boundary values
if scheme_interval :
return np.arange(data_min, data_max+0.1*scheme_interval, scheme_interval)
else :
return np.arange(data_min-1.0, data_max+1.2, 0.2)
# Shared Method: Adjust Colour Scheme Zero Boundaries (used in menu colour edit and grid plot methods)
def adjustColourSchemeZeroBoundaries(self, colour_scheme_boundaries) :
if self.map_colour_scheme == '90%_range' : # shift left method
colour_scheme_boundaries_zero_index = (colour_scheme_boundaries >= 0).nonzero()[0][0]
colour_scheme_boundaries -= colour_scheme_boundaries[colour_scheme_boundaries_zero_index]
else : # fixed_range: minimal stretch method
# Resolve selected parameter/group codes
parameter_group_code = self.parameter_group_selection_map[self.parameter_group_text.get()]
parameter_code = self.parameter_via_group_selection_map[parameter_group_code][self.parameter_via_group_text[parameter_group_code].get()]
# Select fixed colour scheme via parameter codes and delta settings
if self.utilise_delta.get() :
if self.delta_as_percent.get() and self.parameter_fixed_range_colour_scheme[parameter_group_code][parameter_code].has_key('%delta') :
fixed_range_colour_scheme = self.parameter_fixed_range_colour_scheme[parameter_group_code][parameter_code]['%delta']
else :
fixed_range_colour_scheme = self.parameter_fixed_range_colour_scheme[parameter_group_code][parameter_code]['delta']
else :
fixed_range_colour_scheme = self.parameter_fixed_range_colour_scheme[parameter_group_code][parameter_code]['value']
# Resolve colour scheme zero boundaries
first_index = int(fixed_range_colour_scheme['first_boundary'] != None and fixed_range_colour_scheme['min'] == None)
last_index = 11 - int(fixed_range_colour_scheme['last_boundary'] != None and fixed_range_colour_scheme['max'] == None)
if colour_scheme_boundaries.round(12).min() >= 0 :
data_min = 0.0
scheme_interval = (colour_scheme_boundaries[last_index] - data_min)/last_index
data_max = colour_scheme_boundaries[last_index] + scheme_interval*(11 - last_index)
colour_scheme_boundaries_zero_index = 0
elif colour_scheme_boundaries.round(12).max() <= 0 :
data_max = 0.0
scheme_interval = (data_max - colour_scheme_boundaries[first_index])/(11 - first_index)
data_min = colour_scheme_boundaries[first_index] - scheme_interval*first_index
colour_scheme_boundaries_zero_index = 11
else :
first_positive_index = (colour_scheme_boundaries >= 0).nonzero()[0][0]
lower_stretch = None
upper_stretch = None
if first_positive_index < last_index :
lower_stretch = (last_index - first_index)*colour_scheme_boundaries[first_positive_index]/(last_index - first_positive_index)
if first_positive_index > first_index + 1 :
upper_stretch = (last_index - first_index)*colour_scheme_boundaries[first_positive_index - 1]/(first_index - first_positive_index + 1)
if upper_stretch == None or (lower_stretch != None and round(lower_stretch, 12) <= round(upper_stretch, 12)) :
colour_scheme_boundaries[first_index] -= lower_stretch
colour_scheme_boundaries_zero_index = first_positive_index
else :
colour_scheme_boundaries[last_index] += upper_stretch
colour_scheme_boundaries_zero_index = first_positive_index - 1
scheme_interval = (colour_scheme_boundaries[last_index] - colour_scheme_boundaries[first_index])/(last_index - first_index)
data_min = colour_scheme_boundaries[first_index] - scheme_interval*first_index
data_max = colour_scheme_boundaries[last_index] + scheme_interval*(11 - last_index)
colour_scheme_boundaries = np.arange(data_min, data_max+0.1*scheme_interval, scheme_interval).round(12)
return (colour_scheme_boundaries_zero_index, colour_scheme_boundaries)
## Generic Methods ####################################################################################################################################################
# Generic Method: Ensures menu selection triggers entry field validation focusout events
def go(self): # determine which page to return
self.cookies = {}
self.error = ''
form = FieldStorage()
if form.keys() == []:
self.showForm()
return
if form.has_key('person'):
self.who = capwords(strip(form['person'].value))
if self.who == '':
self.error = 'Your name is required. (blank)'
else:
self.error = 'Your name is required. (missing)'
if form.has_key('cookie'):
self.cookies['user'] = unquote(strip( \
form['cookie'].value))
else:
self.cookies['user'] = ''
self.langs = []
if form.has_key('lang'):
langdata = form['lang']
if type(langdata) == type([]):
for eachLang in langdata:
self.langs.append(eachLang.value)
else:
self.langs.append(langdata.value)
else:
self.error = 'At least one language required.'
if form.has_key('upfile'):
upfile = form["upfile"]
self.fn = upfile.filename or ''
if upfile.file:
self.fp = upfile.file
else:
self.fp = StringIO('(no data)')
else:
self.fp = StringIO('(no file)')
self.fn = ''
if not self.error:
self.doResults()
else:
self.showError()
def go(self):
self.error = ''
form = FieldStorage()
if form.keys() == []:
#s('calling showForm()\n')
self.showForm()
return
if form.has_key('person'):
self.who = capwords(strip(form['person'].value))
if self.who == '':
self.error = 'Your name is required. (blank)'
else:
self.error = 'Your name is required. (missing)'
if form.has_key('cookie'):
self.cookies['user'] = unquote(strip(form['cookie'].value))
else:
self.cookies['user'] = ''
self.langs = []
if form.has_key('lang'):
langdata = form['lang']
if type(langdata) == type([]):
for eachLang in langdata:
self.langs.append(eachLang.value)
else:
self.langs.append(langdata.value)
else:
self.error = 'At least one language required.'
if form.has_key('upfile'):
upfile = form["upfile"]
self.fn = upfile.filename or ''
#s('filename is %s??\n' % self.fn)
if upfile.file:
self.fp = upfile.file
else:
self.fp = StringIO('(no data)')
else:
self.fp = StringIO('(no file)')
self.fn = ''
if not self.error:
#s('calling doResults()\n')
self.doResults()
else:
#s('calling showError()\n')
self.showError()
