| def recursion_lock(retval, lock_name = "__recursion_lock__"): |
| def decorator(func): |
| def wrapper(self, *args, **kw): |
| if getattr(self, lock_name, False): |
| return retval |
| setattr(self, lock_name, True) |
| try: |
| return func(self, *args, **kw) |
| finally: |
| setattr(self, lock_name, False) |
| wrapper.__name__ = func.__name__ |
| return wrapper |
| return decorator |
| |
| class Container(object): |
| """ |
| A generic container of attributes |
| """ |
| __slots__ = ["__dict__", "__attrs__"] |
| def __init__(self, **kw): |
| self.__dict__.update(kw) |
| object.__setattr__(self, "__attrs__", kw.keys()) |
| |
| def __eq__(self, other): |
| try: |
| return self.__dict__ == other.__dict__ |
| except AttributeError: |
| return False |
| def __ne__(self, other): |
| return not (self == other) |
| |
| def __delattr__(self, name): |
| object.__delattr__(self, name) |
| self.__attrs__.remove(name) |
| def __setattr__(self, name, value): |
| d = self.__dict__ |
| if name not in d: |
| self.__attrs__.append(name) |
| d[name] = value |
| def __contains__(self, name): |
| return name in self.__dict__ |
| def __getitem__(self, name): |
| return self.__dict__[name] |
| def __delitem__(self, name): |
| self.__delattr__(name) |
| def __setitem__(self, name, value): |
| self.__setattr__(name, value) |
| def __update__(self, obj): |
| for name in obj.__attrs__: |
| self[name] = obj[name] |
| def __copy__(self): |
| new = self.__class__() |
| new.__attrs__ = self.__attrs__[:] |
| new.__dict__ = self.__dict__.copy() |
| return new |
| |
| @recursion_lock("<...>") |
| def __repr__(self): |
| attrs = sorted("%s = %r" % (k, v) |
| for k, v in self.__dict__.iteritems() |
| if not k.startswith("_")) |
| return "%s(%s)" % (self.__class__.__name__, ", ".join(attrs)) |
| def __str__(self): |
| return self.__pretty_str__() |
| @recursion_lock("<...>") |
| def __pretty_str__(self, nesting = 1, indentation = " "): |
| attrs = [] |
| ind = indentation * nesting |
| for k in self.__attrs__: |
| v = self.__dict__[k] |
| if not k.startswith("_"): |
| text = [ind, k, " = "] |
| if hasattr(v, "__pretty_str__"): |
| text.append(v.__pretty_str__(nesting + 1, indentation)) |
| else: |
| text.append(repr(v)) |
| attrs.append("".join(text)) |
| if not attrs: |
| return "%s()" % (self.__class__.__name__,) |
| attrs.insert(0, self.__class__.__name__ + ":") |
| return "\n".join(attrs) |
| |
| class FlagsContainer(Container): |
| """ |
| A container providing pretty-printing for flags. Only set flags are |
| displayed. |
| """ |
| def __pretty_str__(self, nesting = 1, indentation = " "): |
| attrs = [] |
| ind = indentation * nesting |
| for k in self.__attrs__: |
| v = self.__dict__[k] |
| if not k.startswith("_") and v: |
| attrs.append(ind + k) |
| if not attrs: |
| return "%s()" % (self.__class__.__name__,) |
| attrs.insert(0, self.__class__.__name__+ ":") |
| return "\n".join(attrs) |
| |
| class ListContainer(list): |
| """ |
| A container for lists |
| """ |
| __slots__ = ["__recursion_lock__"] |
| def __str__(self): |
| return self.__pretty_str__() |
| @recursion_lock("[...]") |
| def __pretty_str__(self, nesting = 1, indentation = " "): |
| if not self: |
| return "[]" |
| ind = indentation * nesting |
| lines = ["["] |
| for elem in self: |
| lines.append("\n") |
| lines.append(ind) |
| if hasattr(elem, "__pretty_str__"): |
| lines.append(elem.__pretty_str__(nesting + 1, indentation)) |
| else: |
| lines.append(repr(elem)) |
| lines.append("\n") |
| lines.append(indentation * (nesting - 1)) |
| lines.append("]") |
| return "".join(lines) |
| |
| class AttrDict(object): |
| """ |
| A dictionary that can be accessed both using indexing and attributes, |
| i.e., |
| x = AttrDict() |
| x.foo = 5 |
| print x["foo"] |
| """ |
| __slots__ = ["__dict__"] |
| def __init__(self, **kw): |
| self.__dict__ = kw |
| def __contains__(self, key): |
| return key in self.__dict__ |
| def __nonzero__(self): |
| return bool(self.__dict__) |
| def __repr__(self): |
| return repr(self.__dict__) |
| def __str__(self): |
| return self.__pretty_str__() |
| def __pretty_str__(self, nesting = 1, indentation = " "): |
| if not self: |
| return "{}" |
| text = ["{\n"] |
| ind = nesting * indentation |
| for k in sorted(self.__dict__.keys()): |
| v = self.__dict__[k] |
| text.append(ind) |
| text.append(repr(k)) |
| text.append(" : ") |
| if hasattr(v, "__pretty_str__"): |
| try: |
| text.append(v.__pretty_str__(nesting+1, indentation)) |
| except Exception: |
| text.append(repr(v)) |
| else: |
| text.append(repr(v)) |
| text.append("\n") |
| text.append((nesting-1) * indentation) |
| text.append("}") |
| return "".join(text) |
| def __delitem__(self, key): |
| del self.__dict__[key] |
| def __getitem__(self, key): |
| return self.__dict__[key] |
| def __setitem__(self, key, value): |
| self.__dict__[key] = value |
| def __copy__(self): |
| new = self.__class__() |
| new.__dict__ = self.__dict__.copy() |
| return new |
| def __update__(self, other): |
| if isinstance(other, dict): |
| self.__dict__.update(other) |
| else: |
| self.__dict__.update(other.__dict__) |
| |
| class LazyContainer(object): |
| __slots__ = ["subcon", "stream", "pos", "context", "_value"] |
| def __init__(self, subcon, stream, pos, context): |
| self.subcon = subcon |
| self.stream = stream |
| self.pos = pos |
| self.context = context |
| self._value = NotImplemented |
| def __eq__(self, other): |
| try: |
| return self._value == other._value |
| except AttributeError: |
| return False |
| def __ne__(self, other): |
| return not (self == other) |
| def __str__(self): |
| return self.__pretty_str__() |
| def __pretty_str__(self, nesting = 1, indentation = " "): |
| if self._value is NotImplemented: |
| text = "<unread>" |
| elif hasattr(self._value, "__pretty_str__"): |
| text = self._value.__pretty_str__(nesting, indentation) |
| else: |
| text = repr(self._value) |
| return "%s: %s" % (self.__class__.__name__, text) |
| def read(self): |
| self.stream.seek(self.pos) |
| return self.subcon._parse(self.stream, self.context) |
| def dispose(self): |
| self.subcon = None |
| self.stream = None |
| self.context = None |
| self.pos = None |
| def _get_value(self): |
| if self._value is NotImplemented: |
| self._value = self.read() |
| return self._value |
| value = property(_get_value) |
| has_value = property(lambda self: self._value is not NotImplemented) |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |