Commit aec3292e authored by Christophe Combelles's avatar Christophe Combelles

Reverted the indentation and kept the docformat

parent 7687a555
...@@ -32,72 +32,72 @@ class WeakRef(object): ...@@ -32,72 +32,72 @@ class WeakRef(object):
Here's an example. We'll start by creating a persistent object and Here's an example. We'll start by creating a persistent object and
a reference to it: a reference to it:
>>> import persistent, ZODB.tests.MinPO >>> import persistent, ZODB.tests.MinPO
>>> import ZODB.tests.util >>> import ZODB.tests.util
>>> ob = ZODB.tests.MinPO.MinPO() >>> ob = ZODB.tests.MinPO.MinPO()
>>> ref = WeakRef(ob) >>> ref = WeakRef(ob)
>>> ref() is ob >>> ref() is ob
True True
The hash of the ref if the same as the hash of the referenced object: The hash of the ref if the same as the hash of the referenced object:
>>> hash(ref) == hash(ob) >>> hash(ref) == hash(ob)
True True
Two refs to the same object are equal: Two refs to the same object are equal:
>>> WeakRef(ob) == ref >>> WeakRef(ob) == ref
True True
>>> ob2 = ZODB.tests.MinPO.MinPO(1) >>> ob2 = ZODB.tests.MinPO.MinPO(1)
>>> WeakRef(ob2) == ref >>> WeakRef(ob2) == ref
False False
Lets save the reference and the referenced object in a database: Lets save the reference and the referenced object in a database:
>>> db = ZODB.tests.util.DB() >>> db = ZODB.tests.util.DB()
>>> conn1 = db.open() >>> conn1 = db.open()
>>> conn1.root()['ob'] = ob >>> conn1.root()['ob'] = ob
>>> conn1.root()['ref'] = ref >>> conn1.root()['ref'] = ref
>>> ZODB.tests.util.commit() >>> ZODB.tests.util.commit()
If we open a new connection, we can use the reference: If we open a new connection, we can use the reference:
>>> conn2 = db.open() >>> conn2 = db.open()
>>> conn2.root()['ref']() is conn2.root()['ob'] >>> conn2.root()['ref']() is conn2.root()['ob']
True True
>>> hash(conn2.root()['ref']) == hash(conn2.root()['ob']) >>> hash(conn2.root()['ref']) == hash(conn2.root()['ob'])
True True
But if we delete the referenced object and pack: But if we delete the referenced object and pack:
>>> del conn2.root()['ob'] >>> del conn2.root()['ob']
>>> ZODB.tests.util.commit() >>> ZODB.tests.util.commit()
>>> ZODB.tests.util.pack(db) >>> ZODB.tests.util.pack(db)
And then look in a new connection: And then look in a new connection:
>>> conn3 = db.open() >>> conn3 = db.open()
>>> conn3.root()['ob'] >>> conn3.root()['ob']
Traceback (most recent call last): Traceback (most recent call last):
... ...
KeyError: 'ob' KeyError: 'ob'
Trying to dereference the reference returns None: Trying to dereference the reference returns None:
>>> conn3.root()['ref']() >>> conn3.root()['ref']()
Trying to get a hash, raises a type error: Trying to get a hash, raises a type error:
>>> hash(conn3.root()['ref']) >>> hash(conn3.root()['ref'])
Traceback (most recent call last): Traceback (most recent call last):
... ...
TypeError: Weakly-referenced object has gone away TypeError: Weakly-referenced object has gone away
Always explicitly close databases :) : Always explicitly close databases: :)
>>> db.close() >>> db.close()
""" """
...@@ -144,96 +144,96 @@ class PersistentWeakKeyDictionary(Persistent): ...@@ -144,96 +144,96 @@ class PersistentWeakKeyDictionary(Persistent):
of items is extremely lazy. See below. of items is extremely lazy. See below.
We'll start by creating a PersistentWeakKeyDictionary and adding We'll start by creating a PersistentWeakKeyDictionary and adding
some persistent objects to it: some persistent objects to it.
>>> d = PersistentWeakKeyDictionary() >>> d = PersistentWeakKeyDictionary()
>>> import ZODB.tests.util >>> import ZODB.tests.util
>>> p1 = ZODB.tests.util.P('p1') >>> p1 = ZODB.tests.util.P('p1')
>>> p2 = ZODB.tests.util.P('p2') >>> p2 = ZODB.tests.util.P('p2')
>>> p3 = ZODB.tests.util.P('p3') >>> p3 = ZODB.tests.util.P('p3')
>>> d[p1] = 1 >>> d[p1] = 1
>>> d[p2] = 2 >>> d[p2] = 2
>>> d[p3] = 3 >>> d[p3] = 3
We'll create an extra persistent object that's not in the dict: We'll create an extra persistent object that's not in the dict:
>>> p4 = ZODB.tests.util.P('p4') >>> p4 = ZODB.tests.util.P('p4')
Now we'll excercise iteration and item access: Now we'll excercise iteration and item access:
>>> l = [(str(k), d[k], d.get(k)) for k in d] >>> l = [(str(k), d[k], d.get(k)) for k in d]
>>> l.sort() >>> l.sort()
>>> l >>> l
[('P(p1)', 1, 1), ('P(p2)', 2, 2), ('P(p3)', 3, 3)] [('P(p1)', 1, 1), ('P(p2)', 2, 2), ('P(p3)', 3, 3)]
And the containment operator: And the containment operator:
>>> [p in d for p in [p1, p2, p3, p4]] >>> [p in d for p in [p1, p2, p3, p4]]
[True, True, True, False] [True, True, True, False]
We can add the dict and the referenced objects to a database: We can add the dict and the referenced objects to a database:
>>> db = ZODB.tests.util.DB() >>> db = ZODB.tests.util.DB()
>>> conn1 = db.open() >>> conn1 = db.open()
>>> conn1.root()['p1'] = p1 >>> conn1.root()['p1'] = p1
>>> conn1.root()['d'] = d >>> conn1.root()['d'] = d
>>> conn1.root()['p2'] = p2 >>> conn1.root()['p2'] = p2
>>> conn1.root()['p3'] = p3 >>> conn1.root()['p3'] = p3
>>> ZODB.tests.util.commit() >>> ZODB.tests.util.commit()
And things still work, as before: And things still work, as before:
>>> l = [(str(k), d[k], d.get(k)) for k in d] >>> l = [(str(k), d[k], d.get(k)) for k in d]
>>> l.sort() >>> l.sort()
>>> l >>> l
[('P(p1)', 1, 1), ('P(p2)', 2, 2), ('P(p3)', 3, 3)] [('P(p1)', 1, 1), ('P(p2)', 2, 2), ('P(p3)', 3, 3)]
>>> [p in d for p in [p1, p2, p3, p4]] >>> [p in d for p in [p1, p2, p3, p4]]
[True, True, True, False] [True, True, True, False]
Likewise, we can read the objects from another connection and Likewise, we can read the objects from another connection and
things still work: things still work.
>>> conn2 = db.open() >>> conn2 = db.open()
>>> d = conn2.root()['d'] >>> d = conn2.root()['d']
>>> p1 = conn2.root()['p1'] >>> p1 = conn2.root()['p1']
>>> p2 = conn2.root()['p2'] >>> p2 = conn2.root()['p2']
>>> p3 = conn2.root()['p3'] >>> p3 = conn2.root()['p3']
>>> l = [(str(k), d[k], d.get(k)) for k in d] >>> l = [(str(k), d[k], d.get(k)) for k in d]
>>> l.sort() >>> l.sort()
>>> l >>> l
[('P(p1)', 1, 1), ('P(p2)', 2, 2), ('P(p3)', 3, 3)] [('P(p1)', 1, 1), ('P(p2)', 2, 2), ('P(p3)', 3, 3)]
>>> [p in d for p in [p1, p2, p3, p4]] >>> [p in d for p in [p1, p2, p3, p4]]
[True, True, True, False] [True, True, True, False]
Now, we'll delete one of the objects from the database, but *not* Now, we'll delete one of the objects from the database, but *not*
from the dictionary: from the dictionary:
>>> del conn2.root()['p2'] >>> del conn2.root()['p2']
>>> ZODB.tests.util.commit() >>> ZODB.tests.util.commit()
And pack the database, so that the no-longer referenced p2 is And pack the database, so that the no-longer referenced p2 is
actually removed from the database: actually removed from the database.
>>> ZODB.tests.util.pack(db) >>> ZODB.tests.util.pack(db)
Now if we access the dictionary in a new connection, it no longer Now if we access the dictionary in a new connection, it no longer
has p2: has p2:
>>> conn3 = db.open() >>> conn3 = db.open()
>>> d = conn3.root()['d'] >>> d = conn3.root()['d']
>>> l = [(str(k), d[k], d.get(k)) for k in d] >>> l = [(str(k), d[k], d.get(k)) for k in d]
>>> l.sort() >>> l.sort()
>>> l >>> l
[('P(p1)', 1, 1), ('P(p3)', 3, 3)] [('P(p1)', 1, 1), ('P(p3)', 3, 3)]
It's worth nothing that that the versions of the dictionary in It's worth nothing that that the versions of the dictionary in
conn1 and conn2 still have p2, because p2 is still in the caches conn1 and conn2 still have p2, because p2 is still in the caches
for those connections. for those connections.
Always explicitly close databases :) : Always explicitly close databases: :)
>>> db.close() >>> db.close()
""" """
# TODO: It's expensive trying to load dead objects from the database. # TODO: It's expensive trying to load dead objects from the database.
...@@ -271,17 +271,17 @@ class PersistentWeakKeyDictionary(Persistent): ...@@ -271,17 +271,17 @@ class PersistentWeakKeyDictionary(Persistent):
del self.data[WeakRef(key)] del self.data[WeakRef(key)]
def get(self, key, default=None): def get(self, key, default=None):
"""D.get(k[, d]) -> D[k] if k in D, else d. : """D.get(k[, d]) -> D[k] if k in D, else d.
>>> import ZODB.tests.util >>> import ZODB.tests.util
>>> key = ZODB.tests.util.P("key") >>> key = ZODB.tests.util.P("key")
>>> missing = ZODB.tests.util.P("missing") >>> missing = ZODB.tests.util.P("missing")
>>> d = PersistentWeakKeyDictionary([(key, 1)]) >>> d = PersistentWeakKeyDictionary([(key, 1)])
>>> d.get(key) >>> d.get(key)
1 1
>>> d.get(missing) >>> d.get(missing)
>>> d.get(missing, 12) >>> d.get(missing, 12)
12 12
""" """
return self.data.get(WeakRef(key), default) return self.data.get(WeakRef(key), default)
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment