MiscUtils.Error
index
/var/www/docs/Webware-1.1.1/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
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 has a .keys() method, does:     for k in E: D[k] = E[k]
If E 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

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
fromkeys = <built-in method fromkeys of type object>
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.