def list_or_caseless_string(value): """ Converts the value into a list of ``caseless_string``'s. If the value is not iterable a one-element list with stringified value will be returned. """ if isinstance(value, str): return [caseless_string(value)] else: try: return list(map(caseless_string, value)) except ValueError: return [caseless_string(value)]
def list_or_caseless_string(value): """ Converts the value into a list of ``caseless_string``'s. If the value is not iterable a one-element list with stringified value will be returned. """ if isinstance(value, str): return [caseless_string(value)] else: try: return list(map(caseless_string, value)) except ValueError: return [caseless_string(value)]
def __init__(self, path, path_kind): self.path = path path_kind = caseless_string(path_kind) if path_kind not in self.path_kinds: msg = '{} is not a valid path_kind [{}]' raise ValueError(msg.format(path_kind, ' '.join(self.path_kinds))) self.path_kind = path_kind
def cpu_names(self): cpu_names = [] global_name = None for section in self.sections: if 'processor' in section: if 'CPU part' in section: cpu_names.append(_get_part_name(section)) elif 'model name' in section: cpu_names.append(_get_model_name(section)) else: cpu_names.append(None) elif 'CPU part' in section: global_name = _get_part_name(section) return [caseless_string(c or global_name) for c in cpu_names]
def enum(args, start=0, step=1): """ Creates a class with attributes named by the first argument. Each attribute is a ``level`` so they behave is integers in comparisons. The value of the first attribute is specified by the second argument (``0`` if not specified). :: MyEnum = enum(['A', 'B', 'C']) is roughly equivalent of:: class MyEnum(object): A = 0 B = 1 C = 2 however it also implement some specialized behaviors for comparisons and instantiation. """ class Enum(with_metaclass(_EnumMeta, object)): @classmethod def from_pod(cls, pod): lv = level.from_pod(pod) for enum_level in cls.levels: if enum_level == lv: return enum_level msg = 'Unexpected value "{}" for enum.' raise ValueError(msg.format(pod)) def __new__(cls, name): for attr_name in dir(cls): if attr_name.startswith('__'): continue attr = getattr(cls, attr_name) if name == attr: return attr try: return Enum.from_pod(name) except ValueError: raise ValueError('Invalid enum value: {}'.format(repr(name))) reserved = ['values', 'levels', 'names'] levels = [] n = start for v in args: id_v = identifier(v) if id_v in reserved: message = 'Invalid enum level name "{}"; must not be in {}' raise ValueError(message.format(v, reserved)) name = caseless_string(id_v) lv = level(v, n) setattr(Enum, name, lv) levels.append(lv) n += step setattr(Enum, 'levels', levels) setattr(Enum, 'values', [lvl.value for lvl in levels]) setattr(Enum, 'names', [lvl.name for lvl in levels]) return Enum
def __init__(self, name, value): self.name = caseless_string(name) self.value = numeric(value)
def enum(args, start=0, step=1): """ Creates a class with attributes named by the first argument. Each attribute is a ``level`` so they behave is integers in comparisons. The value of the first attribute is specified by the second argument (``0`` if not specified). :: MyEnum = enum(['A', 'B', 'C']) is roughly equivalent of:: class MyEnum(object): A = 0 B = 1 C = 2 however it also implement some specialized behaviors for comparisons and instantiation. """ class Enum(with_metaclass(_EnumMeta, object)): @classmethod def from_pod(cls, pod): lv = level.from_pod(pod) for enum_level in cls.levels: if enum_level == lv: return enum_level msg = 'Unexpected value "{}" for enum.' raise ValueError(msg.format(pod)) def __new__(cls, name): for attr_name in dir(cls): if attr_name.startswith('__'): continue attr = getattr(cls, attr_name) if name == attr: return attr raise ValueError('Invalid enum value: {}'.format(repr(name))) reserved = ['values', 'levels', 'names'] levels = [] n = start for v in args: id_v = identifier(v) if id_v in reserved: message = 'Invalid enum level name "{}"; must not be in {}' raise ValueError(message.format(v, reserved)) name = caseless_string(id_v) lv = level(v, n) setattr(Enum, name, lv) levels.append(lv) n += step setattr(Enum, 'levels', levels) setattr(Enum, 'values', [lvl.value for lvl in levels]) setattr(Enum, 'names', [lvl.name for lvl in levels]) return Enum
def __init__(self, name, value): self.name = caseless_string(name) self.value = numeric(value)