MiscUtils.Error | index /usr/local/share/webware/MiscUtils/Error.py

`Universal error class.`

Classes
`` |  | __builtin__.dict(__builtin__.object) Error
class Error(__builtin__.dict)
`` | `Universal error class. An error is a dictionary-like object, containing a specific user-readable error message and an object associated with it. Since Error inherits dict, other informative values can be arbitrarily attached to errors. For this reason, subclassing Error is rare. Example: err = Error(user, 'Invalid password.') err['time'] = time.time() err['attempts'] = attempts The object and message can be accessed via methods: print err.object() print err.message() When creating errors, you can pass None for both the object and the message. You can also pass additional values, which are then included in the error: >>> err = Error(None, 'Too bad.', timestamp=time.time()) >>> err.keys() ['timestamp'] Or include the values as a dictionary, instead of keyword arguments: >>> info = {'timestamp': time.time()} >>> err = Error(None, 'Too bad.', info) Or you could even do both if you needed to.`
| Method resolution order: Error __builtin__.dict __builtin__.object Methods defined here: __init__(self, obj, message, valueDict={}, **valueArgs) `Initialize the error. Takes the object the error occurred for, and the user-readable error message. The message should be self sufficient such that if printed by itself, the user would understand it.` __nonzero__(self) __repr__(self) __str__(self) message(self) object(self) Data descriptors defined here: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)` Methods inherited from __builtin__.dict: __cmp__(...) `x.__cmp__(y) <==> cmp(x,y)` __contains__(...) `D.__contains__(k) -> True if D has a key k, else False` __delitem__(...) `x.__delitem__(y) <==> del x[y]` __eq__(...) `x.__eq__(y) <==> x==y` __ge__(...) `x.__ge__(y) <==> x>=y` __getattribute__(...) `x.__getattribute__('name') <==> x.name` __getitem__(...) `x.__getitem__(y) <==> x[y]` __gt__(...) `x.__gt__(y) <==> x>y` __iter__(...) `x.__iter__() <==> iter(x)` __le__(...) `x.__le__(y) <==> x<=y` __len__(...) `x.__len__() <==> len(x)` __lt__(...) `x.__lt__(y) <==> x<y` __ne__(...) `x.__ne__(y) <==> x!=y` __setitem__(...) `x.__setitem__(i, y) <==> x[i]=y` __sizeof__(...) `D.__sizeof__() -> size of D in memory, in bytes` clear(...) `D.clear() -> None. Remove all items from D.` copy(...) `D.copy() -> a shallow copy of D` fromkeys(...) `dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v. v defaults to None.` get(...) `D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.` has_key(...) `D.has_key(k) -> True if D has a key k, else False` items(...) `D.items() -> list of D's (key, value) pairs, as 2-tuples` iteritems(...) `D.iteritems() -> an iterator over the (key, value) items of D` iterkeys(...) `D.iterkeys() -> an iterator over the keys of D` itervalues(...) `D.itervalues() -> an iterator over the values of D` keys(...) `D.keys() -> list of D's keys` pop(...) `D.pop(k[,d]) -> v, remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised` popitem(...) `D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty.` setdefault(...) `D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D` update(...) `D.update([E, ]**F) -> None. Update D from dict/iterable E and F. If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]` values(...) `D.values() -> list of D's values` viewitems(...) `D.viewitems() -> a set-like object providing a view on D's items` viewkeys(...) `D.viewkeys() -> a set-like object providing a view on D's keys` viewvalues(...) `D.viewvalues() -> an object providing a view on D's values` Data and other attributes inherited from __builtin__.dict: __hash__ = None __new__ = <built-in method __new__ of type object> `T.__new__(S, ...) -> a new object with type S, a subtype of T`