Back to index

python3.2  3.2.2
Public Member Functions | Public Attributes
shelve.DbfilenameShelf Class Reference
Inheritance diagram for shelve.DbfilenameShelf:
Inheritance graph
[legend]
Collaboration diagram for shelve.DbfilenameShelf:
Collaboration graph
[legend]

List of all members.

Public Member Functions

def __init__
def __iter__
def __len__
def __contains__
def get
def __getitem__
def __setitem__
def __delitem__
def close
def sync
def pop
def popitem
def clear
def update
def setdefault
def keys
def items
def values
def __eq__
def __ne__
def __subclasshook__
def __subclasshook__
def __subclasshook__
def __new__
def __new__
def __new__
def register
def register
def register
def __instancecheck__
def __instancecheck__
def __instancecheck__
def __subclasscheck__
def __subclasscheck__
def __subclasscheck__

Public Attributes

 dict
 writeback
 cache
 keyencoding

Detailed Description

Shelf implementation using the "dbm" generic dbm interface.

This is initialized with the filename for the dbm database.
See the module's __doc__ string for an overview of the interface.

Definition at line 207 of file shelve.py.


Constructor & Destructor Documentation

def shelve.DbfilenameShelf.__init__ (   self,
  filename,
  flag = 'c',
  protocol = None,
  writeback = False 
)

Reimplemented from shelve.Shelf.

Definition at line 214 of file shelve.py.

00214 
00215     def __init__(self, filename, flag='c', protocol=None, writeback=False):
00216         import dbm
00217         Shelf.__init__(self, dbm.open(filename, flag), protocol, writeback)
00218 

Here is the call graph for this function:

Here is the caller graph for this function:


Member Function Documentation

def shelve.Shelf.__contains__ (   self,
  key 
) [inherited]

Reimplemented from _abcoll.Mapping.

Definition at line 101 of file shelve.py.

00101 
00102     def __contains__(self, key):
00103         return key.encode(self.keyencoding) in self.dict

def shelve.Shelf.__delitem__ (   self,
  key 
) [inherited]

Reimplemented from _abcoll.MutableMapping.

Definition at line 127 of file shelve.py.

00127 
00128     def __delitem__(self, key):
00129         del self.dict[key.encode(self.keyencoding)]
00130         try:
00131             del self.cache[key]
00132         except KeyError:
00133             pass

def _abcoll.Mapping.__eq__ (   self,
  other 
) [inherited]

Definition at line 380 of file _abcoll.py.

00380 
00381     def __eq__(self, other):
00382         if not isinstance(other, Mapping):
00383             return NotImplemented
00384         return dict(self.items()) == dict(other.items())

Here is the call graph for this function:

Here is the caller graph for this function:

def shelve.Shelf.__getitem__ (   self,
  key 
) [inherited]

Reimplemented from _abcoll.Mapping.

Definition at line 109 of file shelve.py.

00109 
00110     def __getitem__(self, key):
00111         try:
00112             value = self.cache[key]
00113         except KeyError:
00114             f = BytesIO(self.dict[key.encode(self.keyencoding)])
00115             value = Unpickler(f).load()
00116             if self.writeback:
00117                 self.cache[key] = value
00118         return value

Here is the call graph for this function:

def abc.ABCMeta.__instancecheck__ (   cls,
  instance 
) [inherited]
Override for isinstance(instance, cls).

Definition at line 158 of file abc.py.

00158 
00159     def __instancecheck__(cls, instance):
00160         """Override for isinstance(instance, cls)."""
00161         # Inline the cache checking
00162         subclass = instance.__class__
00163         if subclass in cls._abc_cache:
00164             return True
00165         subtype = type(instance)
00166         if subtype is subclass:
00167             if (cls._abc_negative_cache_version ==
00168                 ABCMeta._abc_invalidation_counter and
00169                 subclass in cls._abc_negative_cache):
00170                 return False
00171             # Fall back to the subclass check.
00172             return cls.__subclasscheck__(subclass)
00173         return any(cls.__subclasscheck__(c) for c in {subclass, subtype})

Here is the call graph for this function:

def abc.ABCMeta.__instancecheck__ (   cls,
  instance 
) [inherited]
Override for isinstance(instance, cls).

Definition at line 158 of file abc.py.

00158 
00159     def __instancecheck__(cls, instance):
00160         """Override for isinstance(instance, cls)."""
00161         # Inline the cache checking
00162         subclass = instance.__class__
00163         if subclass in cls._abc_cache:
00164             return True
00165         subtype = type(instance)
00166         if subtype is subclass:
00167             if (cls._abc_negative_cache_version ==
00168                 ABCMeta._abc_invalidation_counter and
00169                 subclass in cls._abc_negative_cache):
00170                 return False
00171             # Fall back to the subclass check.
00172             return cls.__subclasscheck__(subclass)
00173         return any(cls.__subclasscheck__(c) for c in {subclass, subtype})

Here is the call graph for this function:

def abc.ABCMeta.__instancecheck__ (   cls,
  instance 
) [inherited]
Override for isinstance(instance, cls).

Definition at line 158 of file abc.py.

00158 
00159     def __instancecheck__(cls, instance):
00160         """Override for isinstance(instance, cls)."""
00161         # Inline the cache checking
00162         subclass = instance.__class__
00163         if subclass in cls._abc_cache:
00164             return True
00165         subtype = type(instance)
00166         if subtype is subclass:
00167             if (cls._abc_negative_cache_version ==
00168                 ABCMeta._abc_invalidation_counter and
00169                 subclass in cls._abc_negative_cache):
00170                 return False
00171             # Fall back to the subclass check.
00172             return cls.__subclasscheck__(subclass)
00173         return any(cls.__subclasscheck__(c) for c in {subclass, subtype})

Here is the call graph for this function:

def shelve.Shelf.__iter__ (   self) [inherited]

Reimplemented from _abcoll.Iterable.

Definition at line 94 of file shelve.py.

00094 
00095     def __iter__(self):
00096         for k in self.dict.keys():
00097             yield k.decode(self.keyencoding)

def shelve.Shelf.__len__ (   self) [inherited]

Reimplemented from _abcoll.Sized.

Definition at line 98 of file shelve.py.

00098 
00099     def __len__(self):
00100         return len(self.dict)

def _abcoll.Mapping.__ne__ (   self,
  other 
) [inherited]

Definition at line 385 of file _abcoll.py.

00385 
00386     def __ne__(self, other):
00387         return not (self == other)
00388 

def abc.ABCMeta.__new__ (   mcls,
  name,
  bases,
  namespace 
) [inherited]

Definition at line 116 of file abc.py.

00116 
00117     def __new__(mcls, name, bases, namespace):
00118         cls = super().__new__(mcls, name, bases, namespace)
00119         # Compute set of abstract method names
00120         abstracts = {name
00121                      for name, value in namespace.items()
00122                      if getattr(value, "__isabstractmethod__", False)}
00123         for base in bases:
00124             for name in getattr(base, "__abstractmethods__", set()):
00125                 value = getattr(cls, name, None)
00126                 if getattr(value, "__isabstractmethod__", False):
00127                     abstracts.add(name)
00128         cls.__abstractmethods__ = frozenset(abstracts)
00129         # Set up inheritance registry
00130         cls._abc_registry = WeakSet()
00131         cls._abc_cache = WeakSet()
00132         cls._abc_negative_cache = WeakSet()
00133         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00134         return cls

Here is the call graph for this function:

def abc.ABCMeta.__new__ (   mcls,
  name,
  bases,
  namespace 
) [inherited]

Definition at line 116 of file abc.py.

00116 
00117     def __new__(mcls, name, bases, namespace):
00118         cls = super().__new__(mcls, name, bases, namespace)
00119         # Compute set of abstract method names
00120         abstracts = {name
00121                      for name, value in namespace.items()
00122                      if getattr(value, "__isabstractmethod__", False)}
00123         for base in bases:
00124             for name in getattr(base, "__abstractmethods__", set()):
00125                 value = getattr(cls, name, None)
00126                 if getattr(value, "__isabstractmethod__", False):
00127                     abstracts.add(name)
00128         cls.__abstractmethods__ = frozenset(abstracts)
00129         # Set up inheritance registry
00130         cls._abc_registry = WeakSet()
00131         cls._abc_cache = WeakSet()
00132         cls._abc_negative_cache = WeakSet()
00133         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00134         return cls

Here is the call graph for this function:

def abc.ABCMeta.__new__ (   mcls,
  name,
  bases,
  namespace 
) [inherited]

Definition at line 116 of file abc.py.

00116 
00117     def __new__(mcls, name, bases, namespace):
00118         cls = super().__new__(mcls, name, bases, namespace)
00119         # Compute set of abstract method names
00120         abstracts = {name
00121                      for name, value in namespace.items()
00122                      if getattr(value, "__isabstractmethod__", False)}
00123         for base in bases:
00124             for name in getattr(base, "__abstractmethods__", set()):
00125                 value = getattr(cls, name, None)
00126                 if getattr(value, "__isabstractmethod__", False):
00127                     abstracts.add(name)
00128         cls.__abstractmethods__ = frozenset(abstracts)
00129         # Set up inheritance registry
00130         cls._abc_registry = WeakSet()
00131         cls._abc_cache = WeakSet()
00132         cls._abc_negative_cache = WeakSet()
00133         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00134         return cls

Here is the call graph for this function:

def shelve.Shelf.__setitem__ (   self,
  key,
  value 
) [inherited]

Reimplemented from _abcoll.MutableMapping.

Definition at line 119 of file shelve.py.

00119 
00120     def __setitem__(self, key, value):
00121         if self.writeback:
00122             self.cache[key] = value
00123         f = BytesIO()
00124         p = Pickler(f, self._protocol)
00125         p.dump(value)
00126         self.dict[key.encode(self.keyencoding)] = f.getvalue()

def abc.ABCMeta.__subclasscheck__ (   cls,
  subclass 
) [inherited]
Override for issubclass(subclass, cls).

Definition at line 174 of file abc.py.

00174 
00175     def __subclasscheck__(cls, subclass):
00176         """Override for issubclass(subclass, cls)."""
00177         # Check cache
00178         if subclass in cls._abc_cache:
00179             return True
00180         # Check negative cache; may have to invalidate
00181         if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
00182             # Invalidate the negative cache
00183             cls._abc_negative_cache = WeakSet()
00184             cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00185         elif subclass in cls._abc_negative_cache:
00186             return False
00187         # Check the subclass hook
00188         ok = cls.__subclasshook__(subclass)
00189         if ok is not NotImplemented:
00190             assert isinstance(ok, bool)
00191             if ok:
00192                 cls._abc_cache.add(subclass)
00193             else:
00194                 cls._abc_negative_cache.add(subclass)
00195             return ok
00196         # Check if it's a direct subclass
00197         if cls in getattr(subclass, '__mro__', ()):
00198             cls._abc_cache.add(subclass)
00199             return True
00200         # Check if it's a subclass of a registered class (recursive)
00201         for rcls in cls._abc_registry:
00202             if issubclass(subclass, rcls):
00203                 cls._abc_cache.add(subclass)
00204                 return True
00205         # Check if it's a subclass of a subclass (recursive)
00206         for scls in cls.__subclasses__():
00207             if issubclass(subclass, scls):
00208                 cls._abc_cache.add(subclass)
00209                 return True
00210         # No dice; update negative cache
00211         cls._abc_negative_cache.add(subclass)
00212         return False

Here is the call graph for this function:

def abc.ABCMeta.__subclasscheck__ (   cls,
  subclass 
) [inherited]
Override for issubclass(subclass, cls).

Definition at line 174 of file abc.py.

00174 
00175     def __subclasscheck__(cls, subclass):
00176         """Override for issubclass(subclass, cls)."""
00177         # Check cache
00178         if subclass in cls._abc_cache:
00179             return True
00180         # Check negative cache; may have to invalidate
00181         if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
00182             # Invalidate the negative cache
00183             cls._abc_negative_cache = WeakSet()
00184             cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00185         elif subclass in cls._abc_negative_cache:
00186             return False
00187         # Check the subclass hook
00188         ok = cls.__subclasshook__(subclass)
00189         if ok is not NotImplemented:
00190             assert isinstance(ok, bool)
00191             if ok:
00192                 cls._abc_cache.add(subclass)
00193             else:
00194                 cls._abc_negative_cache.add(subclass)
00195             return ok
00196         # Check if it's a direct subclass
00197         if cls in getattr(subclass, '__mro__', ()):
00198             cls._abc_cache.add(subclass)
00199             return True
00200         # Check if it's a subclass of a registered class (recursive)
00201         for rcls in cls._abc_registry:
00202             if issubclass(subclass, rcls):
00203                 cls._abc_cache.add(subclass)
00204                 return True
00205         # Check if it's a subclass of a subclass (recursive)
00206         for scls in cls.__subclasses__():
00207             if issubclass(subclass, scls):
00208                 cls._abc_cache.add(subclass)
00209                 return True
00210         # No dice; update negative cache
00211         cls._abc_negative_cache.add(subclass)
00212         return False

Here is the call graph for this function:

def abc.ABCMeta.__subclasscheck__ (   cls,
  subclass 
) [inherited]
Override for issubclass(subclass, cls).

Definition at line 174 of file abc.py.

00174 
00175     def __subclasscheck__(cls, subclass):
00176         """Override for issubclass(subclass, cls)."""
00177         # Check cache
00178         if subclass in cls._abc_cache:
00179             return True
00180         # Check negative cache; may have to invalidate
00181         if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
00182             # Invalidate the negative cache
00183             cls._abc_negative_cache = WeakSet()
00184             cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00185         elif subclass in cls._abc_negative_cache:
00186             return False
00187         # Check the subclass hook
00188         ok = cls.__subclasshook__(subclass)
00189         if ok is not NotImplemented:
00190             assert isinstance(ok, bool)
00191             if ok:
00192                 cls._abc_cache.add(subclass)
00193             else:
00194                 cls._abc_negative_cache.add(subclass)
00195             return ok
00196         # Check if it's a direct subclass
00197         if cls in getattr(subclass, '__mro__', ()):
00198             cls._abc_cache.add(subclass)
00199             return True
00200         # Check if it's a subclass of a registered class (recursive)
00201         for rcls in cls._abc_registry:
00202             if issubclass(subclass, rcls):
00203                 cls._abc_cache.add(subclass)
00204                 return True
00205         # Check if it's a subclass of a subclass (recursive)
00206         for scls in cls.__subclasses__():
00207             if issubclass(subclass, scls):
00208                 cls._abc_cache.add(subclass)
00209                 return True
00210         # No dice; update negative cache
00211         cls._abc_negative_cache.add(subclass)
00212         return False

Here is the call graph for this function:

def _abcoll.Iterable.__subclasshook__ (   cls,
  C 
) [inherited]

Reimplemented in _abcoll.Iterator.

Definition at line 74 of file _abcoll.py.

00074 
00075     def __subclasshook__(cls, C):
00076         if cls is Iterable:
00077             if any("__iter__" in B.__dict__ for B in C.__mro__):
00078                 return True
00079         return NotImplemented
00080 

Here is the call graph for this function:

def _abcoll.Sized.__subclasshook__ (   cls,
  C 
) [inherited]

Definition at line 119 of file _abcoll.py.

00119 
00120     def __subclasshook__(cls, C):
00121         if cls is Sized:
00122             if any("__len__" in B.__dict__ for B in C.__mro__):
00123                 return True
00124         return NotImplemented
00125 

Here is the call graph for this function:

def _abcoll.Container.__subclasshook__ (   cls,
  C 
) [inherited]

Definition at line 133 of file _abcoll.py.

00133 
00134     def __subclasshook__(cls, C):
00135         if cls is Container:
00136             if any("__contains__" in B.__dict__ for B in C.__mro__):
00137                 return True
00138         return NotImplemented
00139 

Here is the call graph for this function:

def _abcoll.MutableMapping.clear (   self) [inherited]

Reimplemented in collections._ChainMap.

Definition at line 486 of file _abcoll.py.

00486 
00487     def clear(self):
00488         try:
00489             while True:
00490                 self.popitem()
00491         except KeyError:
00492             pass

Here is the call graph for this function:

Here is the caller graph for this function:

def shelve.Shelf.close (   self) [inherited]

Definition at line 134 of file shelve.py.

00134 
00135     def close(self):
00136         self.sync()
00137         try:
00138             self.dict.close()
00139         except AttributeError:
00140             pass
00141         # Catch errors that may happen when close is called from __del__
00142         # because CPython is in interpreter shutdown.
00143         try:
00144             self.dict = _ClosedDict()
00145         except (NameError, TypeError):
00146             self.dict = None

Here is the call graph for this function:

Here is the caller graph for this function:

def shelve.Shelf.get (   self,
  key,
  default = None 
) [inherited]

Reimplemented from _abcoll.Mapping.

Definition at line 104 of file shelve.py.

00104 
00105     def get(self, key, default=None):
00106         if key.encode(self.keyencoding) in self.dict:
00107             return self[key]
00108         return default

Here is the caller graph for this function:

def _abcoll.Mapping.items (   self) [inherited]

Reimplemented in weakref.WeakKeyDictionary, dbm.dumb._Database, weakref.WeakValueDictionary, and test.test_cfgparser.SortedDict.

Definition at line 374 of file _abcoll.py.

00374 
00375     def items(self):
00376         return ItemsView(self)

Here is the caller graph for this function:

def _abcoll.Mapping.keys (   self) [inherited]

Reimplemented in test.support.EnvironmentVarGuard, weakref.WeakKeyDictionary, dbm.dumb._Database, weakref.WeakValueDictionary, and test.test_cfgparser.SortedDict.

Definition at line 371 of file _abcoll.py.

00371 
00372     def keys(self):
00373         return KeysView(self)

Here is the caller graph for this function:

def _abcoll.MutableMapping.pop (   self,
  key,
  default = __marker 
) [inherited]

Reimplemented in collections._ChainMap, weakref.WeakKeyDictionary, and weakref.WeakValueDictionary.

Definition at line 466 of file _abcoll.py.

00466 
00467     def pop(self, key, default=__marker):
00468         try:
00469             value = self[key]
00470         except KeyError:
00471             if default is self.__marker:
00472                 raise
00473             return default
00474         else:
00475             del self[key]
00476             return value

Here is the caller graph for this function:

def _abcoll.MutableMapping.popitem (   self) [inherited]

Reimplemented in collections._ChainMap, weakref.WeakKeyDictionary, and weakref.WeakValueDictionary.

Definition at line 477 of file _abcoll.py.

00477 
00478     def popitem(self):
00479         try:
00480             key = next(iter(self))
00481         except StopIteration:
00482             raise KeyError
00483         value = self[key]
00484         del self[key]
00485         return key, value

Here is the caller graph for this function:

def abc.ABCMeta.register (   cls,
  subclass 
) [inherited]
Register a virtual subclass of an ABC.

Definition at line 135 of file abc.py.

00135 
00136     def register(cls, subclass):
00137         """Register a virtual subclass of an ABC."""
00138         if not isinstance(subclass, type):
00139             raise TypeError("Can only register classes")
00140         if issubclass(subclass, cls):
00141             return  # Already a subclass
00142         # Subtle: test for cycles *after* testing for "already a subclass";
00143         # this means we allow X.register(X) and interpret it as a no-op.
00144         if issubclass(cls, subclass):
00145             # This would create a cycle, which is bad for the algorithm below
00146             raise RuntimeError("Refusing to create an inheritance cycle")
00147         cls._abc_registry.add(subclass)
00148         ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache

Here is the caller graph for this function:

def abc.ABCMeta.register (   cls,
  subclass 
) [inherited]
Register a virtual subclass of an ABC.

Definition at line 135 of file abc.py.

00135 
00136     def register(cls, subclass):
00137         """Register a virtual subclass of an ABC."""
00138         if not isinstance(subclass, type):
00139             raise TypeError("Can only register classes")
00140         if issubclass(subclass, cls):
00141             return  # Already a subclass
00142         # Subtle: test for cycles *after* testing for "already a subclass";
00143         # this means we allow X.register(X) and interpret it as a no-op.
00144         if issubclass(cls, subclass):
00145             # This would create a cycle, which is bad for the algorithm below
00146             raise RuntimeError("Refusing to create an inheritance cycle")
00147         cls._abc_registry.add(subclass)
00148         ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache

Here is the caller graph for this function:

def abc.ABCMeta.register (   cls,
  subclass 
) [inherited]
Register a virtual subclass of an ABC.

Definition at line 135 of file abc.py.

00135 
00136     def register(cls, subclass):
00137         """Register a virtual subclass of an ABC."""
00138         if not isinstance(subclass, type):
00139             raise TypeError("Can only register classes")
00140         if issubclass(subclass, cls):
00141             return  # Already a subclass
00142         # Subtle: test for cycles *after* testing for "already a subclass";
00143         # this means we allow X.register(X) and interpret it as a no-op.
00144         if issubclass(cls, subclass):
00145             # This would create a cycle, which is bad for the algorithm below
00146             raise RuntimeError("Refusing to create an inheritance cycle")
00147         cls._abc_registry.add(subclass)
00148         ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache

Here is the caller graph for this function:

def _abcoll.MutableMapping.setdefault (   self,
  key,
  default = None 
) [inherited]

Reimplemented in os._Environ, weakref.WeakKeyDictionary, and weakref.WeakValueDictionary.

Definition at line 514 of file _abcoll.py.

00514 
00515     def setdefault(self, key, default=None):
00516         try:
00517             return self[key]
00518         except KeyError:
00519             self[key] = default
00520         return default
00521 
00522 MutableMapping.register(dict)
00523 

def shelve.Shelf.sync (   self) [inherited]

Definition at line 153 of file shelve.py.

00153 
00154     def sync(self):
00155         if self.writeback and self.cache:
00156             self.writeback = False
00157             for key, entry in self.cache.items():
00158                 self[key] = entry
00159             self.writeback = True
00160             self.cache = {}
00161         if hasattr(self.dict, 'sync'):
00162             self.dict.sync()
00163 

Here is the caller graph for this function:

def _abcoll.MutableMapping.update (   args,
  kwds 
) [inherited]

Definition at line 493 of file _abcoll.py.

00493 
00494     def update(*args, **kwds):
00495         if len(args) > 2:
00496             raise TypeError("update() takes at most 2 positional "
00497                             "arguments ({} given)".format(len(args)))
00498         elif not args:
00499             raise TypeError("update() takes at least 1 argument (0 given)")
00500         self = args[0]
00501         other = args[1] if len(args) >= 2 else ()
00502 
00503         if isinstance(other, Mapping):
00504             for key in other:
00505                 self[key] = other[key]
00506         elif hasattr(other, "keys"):
00507             for key in other.keys():
00508                 self[key] = other[key]
00509         else:
00510             for key, value in other:
00511                 self[key] = value
00512         for key, value in kwds.items():
00513             self[key] = value

Here is the caller graph for this function:

def _abcoll.Mapping.values (   self) [inherited]

Reimplemented in weakref.WeakKeyDictionary, weakref.WeakValueDictionary, and test.test_cfgparser.SortedDict.

Definition at line 377 of file _abcoll.py.

00377 
00378     def values(self):
00379         return ValuesView(self)

Here is the caller graph for this function:


Member Data Documentation

shelve.Shelf.cache [inherited]

Definition at line 91 of file shelve.py.

shelve.Shelf.dict [inherited]

Definition at line 86 of file shelve.py.

Definition at line 92 of file shelve.py.

Definition at line 90 of file shelve.py.


The documentation for this class was generated from the following file: