zope.keyreference

zope.keyreference bied voorwerp verwysings wat ondersteun stabiele vergelyking en allegaartjies.
Sleutel Verwysings vir Aanhoudende voorwerpe
zope.keyreference.persistent.KeyReferenceToPersistent bied 'n zope.keyreference.interfaces.IKeyReference verwysing vir volgehoue ​​voorwerpe.
Kom ons kyk na 'n voorbeeld. Eerstens, sal ons skep 'n paar hardnekkige voorwerpe in 'n databasis:
& Nbsp; >>> van ZODB.MappingStorage invoer DB
& Nbsp; >>> invoer transaksie
& Nbsp; >>> van persistent.mapping invoer PersistentMapping
& Nbsp; >>> db = DB ()
& Nbsp; >>> conn = db.open ()
& Nbsp; >>> wortel = conn.root ()
& Nbsp; >>> wortel ['OB1'] = PersistentMapping ()
& Nbsp; >>> wortel ['ob2'] = PersistentMapping ()
& Nbsp; >>> transaction.commit ()
Dan sal ons skep 'n paar belangrike verwysings:
& Nbsp; >>> van zope.keyreference.persistent invoer KeyReferenceToPersistent
& Nbsp; >>> key1 = KeyReferenceToPersistent (wortel ['OB1'])
& Nbsp; >>> key2 = KeyReferenceToPersistent (wortel ['ob2'])
Ons kan die sleutels noem die voorwerpe te kry:
& Nbsp; >>> key1 () is die wortel ['OB1'], key2 () is die wortel ['ob2']
& Nbsp; (True, True)
Nuwe sleutels aan dieselfde voorwerpe is gelyk aan die ou:
& Nbsp; >>> KeyReferenceToPersistent (wortel ['OB1']) == key1
& Nbsp; True
en het dieselfde allegaartjies:
& Nbsp; >>> hash (KeyReferenceToPersistent (wortel ['OB1'])) == hash (key1)
& Nbsp; True
Ander belangrike verwysing implementering is verskil deur hul sleutel tipe id. Sleutel verwysings moet eerste op hul sleutel tipe en tweede sorteer op enige tipe-spesifieke inligting:
& Nbsp; >>> van zope.interface invoer implemente
& Nbsp; >>> van zope.keyreference.interfaces invoer IKeyReference
& Nbsp; >>> klas DummyKeyReference (voorwerp):
& Nbsp; ... implemente (IKeyReference)
& Nbsp; ... key_type_id = 'zope.app.keyreference.object'
& Nbsp; ... def __init __ (self, obj):
& Nbsp; ... self.object = obj
& Nbsp; ... def __cmp __ (self, ander):
& Nbsp; ... as self.key_type_id == other.key_type_id:
& Nbsp; ... terugkeer CMP (self.object, other.object)
& Nbsp; ... terugkeer CMP (self.key_type_id, other.key_type_id)
& Nbsp; >>> dummy_key1 = DummyKeyReference (voorwerp ())
& Nbsp; >>> dummy_key2 = DummyKeyReference (voorwerp ())
& Nbsp; >>> dummy_key3 = DummyKeyReference (voorwerp ())
& Nbsp; >>> sleutels = [key1, dummy_key1, dummy_key2, key2, dummy_key3]
& Nbsp; >>> keys.sort ()
& Nbsp; >>> key_type_ids = [key.key_type_id vir die sleutel in sleutels]
& Nbsp; >>> key_type_ids [0: 3] .count ('zope.app.keyreference.object')
& Nbsp; 3
. & Nbsp; >>> key_type_ids [3:] tel ('zope.app.keyreference.persistent')
& Nbsp; 2
Ons sal die stoor van die sleutel verwysings in die databasis:
& Nbsp; >>> wortel ['key1'] = key1
& Nbsp; >>> wortel ['key2'] = key2
en gebruik die sleutels weer die voorwerpe te slaan:
& Nbsp; >>> wortel [key1] = wortel ['OB1']
& Nbsp; >>> wortel [key2] = wortel ['ob2']
& Nbsp; >>> transaction.commit ()
Nou sal ons 'n ander verband open:
& Nbsp; >>> conn2 = db.open ()
En bevestig dat ons die sleutels kan gebruik om te soek na die voorwerpe:
& Nbsp; >>> root2 = conn2.root ()
& Nbsp; >>> key1 = root2 ['key1']
& Nbsp; >>> root2 [key1] is root2 ['OB1']
& Nbsp; True
& Nbsp; >>> key2 = root2 ['key2']
& Nbsp; >>> root2 [key2] is root2 ['ob2']
& Nbsp; True
en dat ons kan ook die sleutels van die voorwerpe te kry:
& Nbsp; >>> key1 () is root2 ['OB1']
& Nbsp; True
& Nbsp; >>> key2 () is root2 ['ob2']
& Nbsp; True
Ons kan nie die sleutel verwysing vir 'n voorwerp wat is nog nie gestoor is:
& Nbsp; >>> KeyReferenceToPersistent (PersistentMapping ())
& Nbsp; ... # doctest: + beletselteken
& Nbsp; Stapelspoor (mees onlangse oproep laaste):
& Nbsp; ...
& Nbsp; NotYet: ...
Let daarop dat ons 'n NotYet fout. Dit dui daarop dat ons dalk in staat wees om later 'n belangrike verwysing te kry.
Ons kan kry verwysings na ongeredde voorwerpe as hulle 'n adapter te ZODB.interfaces.IConnection. Die byvoeging metode op die verband sal gebruik word om die voorwerp te gee 'n voorwerp id, wat genoeg is om inligting wat die verwysing te bereken. Om dit te sien, sal ons 'n voorwerp wat voldoen aan IConnection in 'n dom manier skep:
& Nbsp; >>> invoer aanhoudende
& Nbsp; >>> van ZODB.interfaces invoer IConnection
& Nbsp; >>> klas C (persistent.Persistent):
& Nbsp; ... def __conform __ (self, iface):
& Nbsp; ... as iface is IConnection:
& Nbsp; ... terugkeer conn2
& Nbsp; >>> ob3 = C ()
& Nbsp; >>> key3 = KeyReferenceToPersistent (ob3)
& Nbsp; >>> transaction.abort ()
Konflikresolusie
Gedurende konflikoplossing, soos bespreek in ZODB / ConflictResolution.txt, verwysings na aanhoudende voorwerpe is eintlik gevalle van ZODB.ConflictResolution.PersistentReference. Dit is pertinent in twee maniere vir KeyReferenceToPersistent. Eerstens, dit verduidelik 'n subtiliteit van die klas: dit erf nie van persistent.Persistent. As dit gedoen het, sou dit nie beskikbaar vir konflikoplossing wees, net sy PersistentReference stand-in.
Tweedens, dit verduidelik sommige van die kode in die __hash__ en __cmp__ metodes. Hierdie metodes nie net hanteer persistent.Persistent voorwerpe, maar PersistentReference voorwerpe. Sonder hierdie gedrag, sal voorwerpe, soos die klassieke ZODB BTrees, wat gebruik maak van KeyReferenceToPersistent as sleutels of stel lede in staat wees om konflikte op te los. Selfs met die spesiale kode in sommige gevalle is die KeyReferenceToPersistent sal weier om te vergelyk en hash tydens konflik resolusie, want dit kan nie betroubaar dit te doen.
__hash__ sal relatief selde werk tydens konflik resolusie: net vir multidatabase verwysings. Hier is 'n paar voorbeelde.
& Nbsp; >>> van ZODB.ConflictResolution invoer PersistentReference
& Nbsp; >>> def fabriek (ref):
& Nbsp; ... res = KeyReferenceToPersistent .__ nuwe __ (
& Nbsp; ... KeyReferenceToPersistent, ref)
& Nbsp; ... res.object = ref
& Nbsp; ... terugkeer res
& Nbsp; ...
& Nbsp; >>> hash (fabriek (PersistentReference (
& Nbsp; ... ('n oid "," klas metadata ')))) # n tipiese verwysing
& Nbsp; Stapelspoor (mees onlangse oproep laaste):
& Nbsp; ...
& Nbsp; ValueError: databasis naam beskikbaar in hierdie tyd
& Nbsp; >>> Bool (hash (fabriek (PersistentReference (
& Nbsp; ... ['m', ('n databasis ', 'n oid "," klas metadata')])))) # multidatabase
& Nbsp; True
Dit beteken dat KeyReferenceToPersistent dikwels sal verhinder konflikoplossing vir klasse soos PersistentMapping.
__cmp__ werk nie, tensy een voorwerp is 'n multidatabase verwysing en die ander is nie. Hier is 'n paar voorbeelde.
& Nbsp; >>> CMP (fabriek (PersistentReference (
& Nbsp; ... ('n oid "," klas metadata '))),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ('n oid "," klas metadata '))))
& Nbsp; 0
& Nbsp; >>> CMP (fabriek (PersistentReference (
& Nbsp; ... ('n oid "," klas metadata '))),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ('n ander oid "," klas metadata '))))
& Nbsp; -1
& Nbsp; >>> CMP (fabriek (PersistentReference ('n oid ')),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ('n oid "," klas metadata '))))
& Nbsp; 0
& Nbsp; >>> CMP (fabriek (PersistentReference ('n oid ')),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ('n oid "," klas metadata '))))
& Nbsp; 0
& Nbsp; >>> CMP (fabriek (PersistentReference (
& Nbsp; ... ['m', ('n databasis ', 'n oid "," klas metadata')])),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ['m', ('n databasis ', 'n oid "," klas metadata')])))
& Nbsp; 0
& Nbsp; >>> CMP (fabriek (PersistentReference (
& Nbsp; ... ['m', ('n databasis ', 'n oid "," klas metadata')])),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ['n ', ('n databasis', 'n oid ')])))
& Nbsp; 0
& Nbsp; >>> CMP (fabriek (PersistentReference (
& Nbsp; ... ['m', ('n databasis ', 'n oid "," klas metadata')])),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ['m', ('n ander databasis ', 'n oid "," klas metadata')])))
& Nbsp; -1
& Nbsp; >>> CMP (fabriek (PersistentReference (
& Nbsp; ... ['m', ('n databasis ', 'n oid "," klas metadata')])),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ('n oid "," klas metadata '))))
& Nbsp; Stapelspoor (mees onlangse oproep laaste):
& Nbsp; ...
& Nbsp; ValueError: kan nie soort betroubaar
Ligging-gebaseerde verband adapter
Die funksie zope.keyreference.connectionOfPersistent pas voorwerpe te verbindings met behulp van 'n eenvoudige plek-gebaseerde heuristiese. Dit nagegaan om te sien of die voorwerp het 'n __parent__ wat 'n verband:
& Nbsp; >>> van zope.keyreference.persistent invoer connectionOfPersistent
& Nbsp; >>> ob3 = PersistentMapping ()
& Nbsp; >>> druk connectionOfPersistent (ob3)
& Nbsp; Geen
& Nbsp; >>> ob3 .__ parent__ = root2 ['OB1']
& Nbsp; >>> connectionOfPersistent (ob3) is conn2
& Nbsp; Ware

Wat is nuut in hierdie release:

• Fix toetse gebreek deur die verwydering van zope.testing van die toets van afhanklikhede: vermy die ZODB3 module wat dit nodig het.

Vereistes :

• Python