def _make_unique(self, k, args): if k not in self: return args cur = conv.to_list(self[k]) new_args = [] for v in args: if v not in cur: new_args.append(v) return new_args
def make_file_names(name, prefixes=[], suffixes=[]): """Combine prefixes and suffixes with a name. Returns a list with all combinations.""" # If we weren't given any prefixes or suffixes add an empty # string to each. This way we will at least check for the name # which should be the default behavior. if not prefixes: prefixes = [''] else: prefixes = conv.to_list(prefixes) if not suffixes: suffixes = [''] else: suffixes = conv.to_list(suffixes) for p in prefixes: for s in suffixes: yield p + name + s
def gather(self, args): d = {} for a in args: if isinstance(a, tuple) and len(a) == 2: if a[0] in d: if not isinstance(d[a[0]], list): d[a[0]] = conv.to_list(d[a[0]]) d[a[0]].append(a[1]) else: d[a[0]] = a[1] return d
def _enum_to_str(self, val): val = conv.to_list(val) s = [] for v in val: e = self.enum.get(v, None) if e is None: if v not in self.enum.values(): raise "Invalid enumerated option." e = v s.append(e) return self._str_to_str(self._pref_delim.join(s))
def add_option(self, opts, *args): opts = conv.to_list(opts) opts += args for o in opts: if o.name in self.options: raise RuntimeError, "Duplicate option name %s." % repr(o.name) self.options[o.name] = o self._order.append(o.name) for f in o._flg_to_var.iterkeys(): if f in self._flg_to_opt: raise "Duplicate option flag in OptionSet." self._flg_to_opt[f] = o self._expr = None
def add_option(self, opts, *args): opts = conv.to_list(opts) opts += args for o in opts: if o.name in self.options: raise RuntimeError, "Duplicate option name %s."%repr(o.name) self.options[o.name] = o self._order.append(o.name) for f in o._flg_to_var.iterkeys(): if f in self._flg_to_opt: raise "Duplicate option flag in OptionSet." self._flg_to_opt[f] = o self._expr = None
def prepend(self, k, *args, **kw): args = conv.flatten(list(args)) args = [a for a in args if a != ""] if k in self: if not isinstance(self[k], list): self[k] = conv.to_list(self[k]) self[k] = list(args) + self[k] elif len(args) == 1: if kw.get("make_list", False): self[k] = [args[0]] else: self[k] = args[0] elif len(args) > 1: self[k] = list(args)
def model_fill(obj, info_dict): all_fields = obj._meta.fields + obj._meta.many_to_many for field in all_fields: if field.name in ['id', 'pk']: continue if field.name not in info_dict: continue name = field.name cur_val = getattr(obj, field.name) if isinstance(field, ManyToManyField): for val in conv.to_list(info_dict[field.name]): if not cur_val.filter(pk=val.pk).exists(): cur_val.add(val) else: if not cur_val: setattr(obj, field.name, info_dict[field.name])
def append(self, k, *args, **kw): args = conv.flatten(list(args)) args = [a for a in args if a != ""] if isinstance(k, (dict, Environment)): self._handle_dict(k, self.append, **kw) else: if k in self: if not isinstance(self[k], list): self[k] = conv.to_list(self[k]) self[k] += list(args) elif len(args) == 1: if kw.get("make_list", False): self[k] = [args[0]] else: self[k] = args[0] elif len(args) > 1: self[k] = list(args)
def __init__(self, name, *args, **kw): self.name = name # If we were given a 'variants' keyword then take that as # one or a list of OptionVariant instances. vars = kw.get("variants", None) if vars is None: # Otherwise all the parameters we were given are to create # a new OptionVariant. vars = OptionVariant(*args, **kw) self.variants = conv.to_list(vars) # We take the type of the first variant to be the type of # this option. self.type = self.variants[0].type # This mapping is for moving from a flag string to the variant # that represents it. self._flg_to_var = {} for v in self.variants: # Make sure we don't have multiple types in the variants. if self.type != v.type: raise "Inconsistent OptionVariant types." for f in v.flags: # Make sure we don't have multiple variants trying to # represent the same flag. if f in self._flg_to_var: raise "Duplicate option flags in Option." # Inser the flag/variant into the mapping. self._flg_to_var[f] = v self.help = kw.get("help", None) self.default = kw.get("default", None)
def find(name, dirs=[], prefixes=[], suffixes=[], max=0): """Try to locate a file system entry by combining prefixes and suffixes with a name, then searching a set of provided directories. By default a list of all matches is returned, but this can be limited by 'max'.""" # If we weren't given any directories to search try the current # working directory. if not dirs: dirs = [os.getcwd()] else: dirs = conv.to_list(dirs) names = [n for n in make_file_names(name, prefixes, suffixes)] cur = 0 for d in dirs: for n in names: p = os.path.join(d, n) if os.path.exists(p): yield p if max: cur += 1 if cur == max: return
def __init__(self, flags, type="string", **kw): """flags: Either a string or list of the exact flags that can represent this option variant. type: A string representing the kind of option. One of "string", "enum" or "bool".""" # Convert the flags to a list. self.flags = conv.to_list(flags) # Extract parameters from the keywords. self.seps = conv.to_list(kw.get("seps", ["=", " "])) self.pref_sep = sep and kw.get("pref_sep", sep[0]) or None self.delims = conv.to_list(kw.get("delims", "")) self.pref_delim = delim and kw.get("pref_delim", delim[0]) or None # Error on duplicate flags. for i in range(len(self.flags) - 1): if self.flags[i] in self.flags[i + 1:]: raise "Duplicate flag given to OptionVariant." # Error on duplicate separators. for i in range(len(self.sep) - 1): if self.sep[i] in self.sep[i + 1:]: raise "Duplicate separators given to OptionVariant." # Error on separators that are not single characters. for s in self.seps: if len(s) != 1: raise "Separator of length != 1." # Error on duplicate delimiters. for i in range(len(self.delims) - 1): if self.delims[i] in self.delims[i + 1:]: raise "Duplicate delimiter given to OptionVariant." # Error on delimiters that are not single characters or # delimiters that are whitespaces. for d in self.delims: if len(d) != 1: raise "Delimeter of length != 1." if d == " ": raise "Whitespace delimeter." # Sort the separators and delimiters so that we don't mistake shorter # ones for longer ones. self.seps.sort(lambda x,y: len(y)-len(x)) self.delims.sort(lambda x,y: len(y)-len(x)) # # Handle the different kinds of option types. We need to set # the conversion method "to_str", set the parsing method # "parse_val" and setup any type specific details. # if self.type == "bool": self.to_str = self._bool_to_str self.parse_val = self._parse_bool # Boolean options accept an optional parameter defining # what indicates a positive and negative value. It should be # specified as a tuple of two lists, the first being the # positive values the second the negative. bf = kw.get("bool_values", (["", "yes", "1", "t"], ["no", "0", "f"])) # Boolean's also accept additional parameters for specifying # which positive and negative values are preferential. These # will influence conversion of option lists to strings. By default # the first values in the "bool_values" list are considered # preferential. self._pref_true_flag = kw.get("pref_true_value", conv.to_list(bf[0])[0]) self._pref_false_flag = kw.get("pref_false_value", conv.to_list(bf[1])[0]) # Setup the values. We sort the list by the length of the values # in descending order so that when we parse option strings we don't # mistake shorter options for longer ones. self.bool_values = (zip(conv.to_list(bf[0]), [True for i in range(len(bf[0]))]) + zip(conv.to_list(bf[1]), [False for i in range(len(bf[1]))])) self.bool_values.sort(lambda x,y: len(y[0])-len(x[0])) elif self.type == "enum": self.to_str = self._enum_to_str self.parse_val = self._parse_enum # An additional option for enumerations is "enum", which defines a # a mapping from the string values expected in the option strings to # an internal string representation. It accepts either a dictionary # or a string. In the case of a list each entry maps to itself. self.enum = kw.get("enum", {}) if isinstance(self.enum, list): self.enum = dict(zip(self.enum, self.enum)) else: self.to_str = self._str_to_str self.parse_val = self._parse_str
def __init__(self, flags, type="string", **kw): """flags: Either a string or list of the exact flags that can represent this option variant. type: A string representing the kind of option. One of "string", "enum" or "bool".""" # Convert the flags to a list. self.flags = conv.to_list(flags) # Extract parameters from the keywords. self.seps = conv.to_list(kw.get("seps", ["=", " "])) self.pref_sep = sep and kw.get("pref_sep", sep[0]) or None self.delims = conv.to_list(kw.get("delims", "")) self.pref_delim = delim and kw.get("pref_delim", delim[0]) or None # Error on duplicate flags. for i in range(len(self.flags) - 1): if self.flags[i] in self.flags[i + 1:]: raise "Duplicate flag given to OptionVariant." # Error on duplicate separators. for i in range(len(self.sep) - 1): if self.sep[i] in self.sep[i + 1:]: raise "Duplicate separators given to OptionVariant." # Error on separators that are not single characters. for s in self.seps: if len(s) != 1: raise "Separator of length != 1." # Error on duplicate delimiters. for i in range(len(self.delims) - 1): if self.delims[i] in self.delims[i + 1:]: raise "Duplicate delimiter given to OptionVariant." # Error on delimiters that are not single characters or # delimiters that are whitespaces. for d in self.delims: if len(d) != 1: raise "Delimeter of length != 1." if d == " ": raise "Whitespace delimeter." # Sort the separators and delimiters so that we don't mistake shorter # ones for longer ones. self.seps.sort(lambda x, y: len(y) - len(x)) self.delims.sort(lambda x, y: len(y) - len(x)) # # Handle the different kinds of option types. We need to set # the conversion method "to_str", set the parsing method # "parse_val" and setup any type specific details. # if self.type == "bool": self.to_str = self._bool_to_str self.parse_val = self._parse_bool # Boolean options accept an optional parameter defining # what indicates a positive and negative value. It should be # specified as a tuple of two lists, the first being the # positive values the second the negative. bf = kw.get("bool_values", (["", "yes", "1", "t"], ["no", "0", "f"])) # Boolean's also accept additional parameters for specifying # which positive and negative values are preferential. These # will influence conversion of option lists to strings. By default # the first values in the "bool_values" list are considered # preferential. self._pref_true_flag = kw.get("pref_true_value", conv.to_list(bf[0])[0]) self._pref_false_flag = kw.get("pref_false_value", conv.to_list(bf[1])[0]) # Setup the values. We sort the list by the length of the values # in descending order so that when we parse option strings we don't # mistake shorter options for longer ones. self.bool_values = ( zip(conv.to_list(bf[0]), [True for i in range(len(bf[0]))]) + zip(conv.to_list(bf[1]), [False for i in range(len(bf[1]))])) self.bool_values.sort(lambda x, y: len(y[0]) - len(x[0])) elif self.type == "enum": self.to_str = self._enum_to_str self.parse_val = self._parse_enum # An additional option for enumerations is "enum", which defines a # a mapping from the string values expected in the option strings to # an internal string representation. It accepts either a dictionary # or a string. In the case of a list each entry maps to itself. self.enum = kw.get("enum", {}) if isinstance(self.enum, list): self.enum = dict(zip(self.enum, self.enum)) else: self.to_str = self._str_to_str self.parse_val = self._parse_str
def _str_to_str(self, val): val = conv.to_list(val) return "%s%s%s" % (self.flags[0], self._pref_sep, self._pref_delim.join(val))