Package pyxmpp :: Module expdict :: Class ExpiringDictionary
[show private | hide private]
[frames | no frames]

Type ExpiringDictionary

object --+    
         |    
      dict --+
             |
            ExpiringDictionary


An extension to standard Python dictionary objects which implements item expiration.

Each item in ExpiringDictionary has its expiration time assigned, after which the item is removed from the mapping.


Method Summary
  __init__(self, default_timeout)
Initialize an ExpiringDictionary object.
  __delitem__(self, key)
  __getitem__(self, key)
  __setitem__(self, key, value)
  expire(self)
Do the expiration of dictionary items.
  set_item(self, key, value, timeout, timeout_callback)
Set item of the dictionary.
    Inherited from dict
  __cmp__(x, y)
x.__cmp__(y) <==> cmp(x,y)
  __contains__(D, k)
D.__contains__(k) -> True if D has a key k, else False
  __eq__(x, y)
x.__eq__(y) <==> x==y
  __ge__(x, y)
x.__ge__(y) <==> x>=y
  __getattribute__(...)
x.__getattribute__('name') <==> x.name
  __gt__(x, y)
x.__gt__(y) <==> x>y
  __hash__(x)
x.__hash__() <==> hash(x)
  __iter__(x)
x.__iter__() <==> iter(x)
  __le__(x, y)
x.__le__(y) <==> x<=y
  __len__(x)
x.__len__() <==> len(x)
  __lt__(x, y)
x.__lt__(y) <==> x<y
  __ne__(x, y)
x.__ne__(y) <==> x!=y
  __new__(T, S, ...)
T.__new__(S, ...) -> a new object with type S, a subtype of T
  __repr__(x)
x.__repr__() <==> repr(x)
  clear(D)
D.clear() -> None.
  copy(D)
D.copy() -> a shallow copy of D
  get(D, k, d)
D.get(k[,d]) -> D[k] if k in D, else d.
  has_key(D, k)
D.has_key(k) -> True if D has a key k, else False
  items(D)
D.items() -> list of D's (key, value) pairs, as 2-tuples
  iteritems(D)
D.iteritems() -> an iterator over the (key, value) items of D
  iterkeys(D)
D.iterkeys() -> an iterator over the keys of D
  itervalues(D)
D.itervalues() -> an iterator over the values of D
  keys(D)
D.keys() -> list of D's keys
  pop(D, k, d)
If key is not found, d is returned if given, otherwise KeyError is raised
  popitem(D)
2-tuple; but raise KeyError if D is empty
  setdefault(D, k, d)
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
  update(...)
D.update(E, **F) -> None.
  values(D)
D.values() -> list of D's values
    Inherited from object
  __delattr__(...)
x.__delattr__('name') <==> del x.name
  __reduce__(...)
helper for pickle
  __reduce_ex__(...)
helper for pickle
  __setattr__(...)
x.__setattr__('name', value) <==> x.name = value
  __str__(x)
x.__str__() <==> str(x)
    Inherited from type
  fromkeys(dict, S, v)
v defaults to None.

Class Variable Summary
list __slots__ = ['_timeouts', '_default_timeout', '_lock']

Method Details

__init__(self, default_timeout=300)
(Constructor)

Initialize an ExpiringDictionary object.
Parameters:
default_timeout - default timeout value for stored objects.
           (type=int)
Overrides:
__builtin__.dict.__init__

expire(self)

Do the expiration of dictionary items.

Remove items that expired by now from the dictionary.

set_item(self, key, value, timeout=None, timeout_callback=None)

Set item of the dictionary.
Parameters:
key - the key.
           (type=any hashable value)
value - the object to store.
           (type=any python object)
timeout - timeout value for the object (in seconds from now).
           (type=int)
timeout_callback - function to be called when the item expires. The callback should accept none, one (the key) or two (the key and the value) arguments.
           (type=callable)

Class Variable Details

__slots__

Type:
list
Value:
['_timeouts', '_default_timeout', '_lock']