pyxmpp.expdict.ExpiringDictionary

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']