+ try: return lst[_get_keys(lst).index(key)]

+ except ValueError: raise ValueError, 'Key "%s" not found in %s.'%(key, _get_keys(lst))

+ def __init__(self, param, n):

+ Element.__init__(self, param)

+ self._name = n.find('name')

+ self._key = n.find('key')

+ self._opts = dict()

+ opts = n.findall('opt')

+ #test against opts when non enum

+ if not self.get_parent().is_enum() and opts:

+ raise Exception, 'Options for non-enum types cannot have sub-options'

+ #extract opts

+ for opt in opts:

+ #separate the key:value

+ try: key, value = opt.split(':')

+ except: raise Exception, 'Error separating "%s" into key:value'%opt

+ #test against repeated keys

+ if self._opts.has_key(key):

+ raise Exception, 'Key "%s" already exists in option'%key

+ #store the option

+ self._opts[key] = value

+

+ def __str__(self): return 'Option %s(%s)'%(self.get_name(), self.get_key())

+ def get_name(self): return self._name

+ def get_key(self): return self._key

+

+ ##############################################

+ # Access Opts

+ ##############################################

+ def get_opt_keys(self): return self._opts.keys()

+ def get_opt(self, key): return self._opts[key]

+ def get_opts(self): return self._opts.values()

+ def __init__(self, block, n):

+ """

+ Make a new param from nested data.

+

+ Args:

+ block: the parent element

+ n: the nested odict

+ """

+ #grab the data

+ self._name = n.find('name')

+ self._key = n.find('key')

+ value = n.find('value') or ''

+ self._type = n.find('type')

+ self._hide = n.find('hide') or ''

+ #build the param

+ Element.__init__(self, block)

+ #create the Option objects from the n data

+ self._options = list()

+ for option in map(lambda o: Option(param=self, n=o), n.findall('option')):

+ key = option.get_key()

+ #test against repeated keys

+ if key in self.get_option_keys():

+ raise Exception, 'Key "%s" already exists in options'%key

+ #store the option

+ self.get_options().append(option)

+ #test the enum options

+ if self.is_enum():

+ #test against options with identical keys

+ if len(set(self.get_option_keys())) != len(self.get_options()):

+ raise Exception, 'Options keys "%s" are not unique.'%self.get_option_keys()

+ #test against inconsistent keys in options

+ opt_keys = self.get_options()[0].get_opt_keys()

+ for option in self.get_options():

+ if set(opt_keys) != set(option.get_opt_keys()):

+ raise Exception, 'Opt keys "%s" are not identical across all options.'%opt_keys

+ #if a value is specified, it must be in the options keys

+ self._value = value if value or value in self.get_option_keys() else self.get_option_keys()[0]

+ if self.get_value() not in self.get_option_keys():

+ raise Exception, 'The value "%s" is not in the possible values of "%s".'%(self.get_value(), self.get_option_keys())

+ else: self._value = value or ''

+

+ def validate(self):

+ """

+ Validate the param.

+ The value must be evaluated and type must a possible type.

+ """

+ Element.validate(self)

+ if self.get_type() not in self.get_types():

+ self.add_error_message('Type "%s" is not a possible type.'%self.get_type())

+

+ def get_evaluated(self): raise NotImplementedError

+

+ def to_code(self):

+ """

+ Convert the value to code.

+ @throw NotImplementedError

+ """

+ raise NotImplementedError

+

+ def get_types(self):

+ """

+ Get a list of all possible param types.

+ @throw NotImplementedError

+ """

+ raise NotImplementedError

+

+ def get_color(self): return '#FFFFFF'

+ def __str__(self): return 'Param - %s(%s)'%(self.get_name(), self.get_key())

+ def is_param(self): return True

+ def get_name(self): return self._name

+ def get_key(self): return self._key

+ def get_hide(self): return self.get_parent().resolve_dependencies(self._hide).strip()

+

+ def get_value(self):

+ value = self._value

+ if self.is_enum() and value not in self.get_option_keys():

+ value = self.get_option_keys()[0]

+ self.set_value(value)

+ return value

+

+ def set_value(self, value): self._value = str(value) #must be a string

+

+ def get_type(self): return self.get_parent().resolve_dependencies(self._type)

+ def is_enum(self): return self._type == 'enum'

+

+ def __repr__(self):

+ """

+ Get the repr (nice string format) for this param.

+ Just return the value (special case enum).

+ Derived classes can handle complex formatting.

+

+ Returns:

+ the string representation

+ """

+ if self.is_enum(): return self.get_option(self.get_value()).get_name()

+ return self.get_value()

+

+ ##############################################

+ # Access Options

+ ##############################################

+ def get_option_keys(self): return _get_keys(self.get_options())

+ def get_option(self, key): return _get_elem(self.get_options(), key)

+ def get_options(self): return self._options

+

+ ##############################################

+ # Access Opts

+ ##############################################

+ def get_opt_keys(self): return self.get_option(self.get_value()).get_opt_keys()

+ def get_opt(self, key): return self.get_option(self.get_value()).get_opt(key)

+ def get_opts(self): return self.get_option(self.get_value()).get_opts()

+

+ ##############################################

+ ## Import/Export Methods

+ ##############################################

+ def export_data(self):

+ """

+ Export this param's key/value.

+

+ Returns:

+ a nested data odict

+ """

+ n = odict()

+ n['key'] = self.get_key()

+ n['value'] = self.get_value()

+ return n