zope.keyreference

zope.keyreference biedt object referenties die stabiel vergelijking en hashes te ondersteunen.
Belangrijke Referenties voor blijvende objecten
zope.keyreference.persistent.KeyReferenceToPersistent biedt een zope.keyreference.interfaces.IKeyReference referentie voor blijvende objecten.
Laten we eens kijken naar een voorbeeld. Eerst zullen we een aantal hardnekkige objecten in een database te maken:
& Nbsp; >>> van ZODB.MappingStorage import DB
& Nbsp; >>> import transactie
& Nbsp; >>> van persistent.mapping import PersistentMapping
& Nbsp; >>> db = DB ()
& Nbsp; >>> conn = db.open ()
& Nbsp; >>> root = conn.root ()
& Nbsp; >>> wortel ['ob1'] = PersistentMapping ()
& Nbsp; >>> wortel ['OB2'] = PersistentMapping ()
& Nbsp; >>> transaction.commit ()
Dan zullen we een aantal belangrijke referenties te maken:
& Nbsp; >>> van zope.keyreference.persistent import KeyReferenceToPersistent
& Nbsp; >>> key1 = KeyReferenceToPersistent (root ['ob1'])
& Nbsp; >>> key2 = KeyReferenceToPersistent (root ['OB2'])
We kunnen de sleutels bellen om de voorwerpen te krijgen:
& Nbsp; >>> key1 () is wortel ['ob1'], key2 () is wortel ['OB2']
& Nbsp; (True, True)
Nieuwe sleutels dezelfde objecten zijn gelijk aan het oude:
& Nbsp; >>> KeyReferenceToPersistent (root ['ob1']) == key1
& Nbsp; True
en hebben dezelfde hashes:
& Nbsp; >>> hash (KeyReferenceToPersistent (root ['ob1'])) == hash (key1)
& Nbsp; True
Andere belangrijke referentie-implementaties worden verschilden door hun type sleutel id. Belangrijke referenties moeten eerst op hun type sleutel en tweede sorteren op elk type-specifieke informatie:
& Nbsp; >>> van zope.interface import werktuigen
& Nbsp; >>> van zope.keyreference.interfaces importeren IKeyReference
& Nbsp; >>> klasse DummyKeyReference (object):
& Nbsp; ... werktuigen (IKeyReference)
& Nbsp; ... key_type_id = 'zope.app.keyreference.object'
& Nbsp; ... def __init __ (zelf, obj):
& Nbsp; ... self.object = obj
& Nbsp; ... def __cmp __ (self, other):
& Nbsp; ... als self.key_type_id == other.key_type_id:
& Nbsp; ... return cmp (self.object, other.object)
& Nbsp; ... return cmp (self.key_type_id, other.key_type_id)
& Nbsp; >>> dummy_key1 = DummyKeyReference (object ())
& Nbsp; >>> dummy_key2 = DummyKeyReference (object ())
& Nbsp; >>> dummy_key3 = DummyKeyReference (object ())
& Nbsp; >>> toetsen = [key1, dummy_key1, dummy_key2, key2, dummy_key3]
& Nbsp; >>> keys.sort ()
& Nbsp; >>> key_type_ids = [key.key_type_id voor de belangrijkste in de keys]
& Nbsp; >>> key_type_ids [0: 3] .count ('zope.app.keyreference.object')
& Nbsp; 3
. & Nbsp; >>> key_type_ids [3:] te tellen ('zope.app.keyreference.persistent')
& Nbsp; 2
We zullen de belangrijkste referenties in de database op te slaan:
& Nbsp; >>> wortel ['key1'] = key1
& Nbsp; >>> wortel ['key2'] = key2
en gebruik de toetsen om de objecten weer te slaan:
& Nbsp; >>> wortel [key1] = root ['ob1']
& Nbsp; >>> wortel [key2] = root ['OB2']
& Nbsp; >>> transaction.commit ()
Nu gaan we nog een verbinding te openen:
& Nbsp; >>> conn2 = db.open ()
En controleer dat we de sleutels kan gebruiken voor het opzoeken van de objecten:
& 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 kunnen we ook de sleutels bellen om de voorwerpen te krijgen:
& Nbsp; >>> key1 () is root2 ['ob1']
& Nbsp; True
& Nbsp; >>> key2 () is root2 ['OB2']
& Nbsp; True
We kunnen niet de belangrijkste referentie voor een object dat nog niet is opgeslagen:
& Nbsp; >>> KeyReferenceToPersistent (PersistentMapping ())
& Nbsp; ... # doctest: + Ellipsis
& Nbsp; Traceback (meest recente oproep vorige):
& Nbsp; ...
& Nbsp; NotYet: ...
Merk op dat we een NotYet fout. Dit geeft aan dat we misschien in staat zijn om een ​​belangrijke referentie later.
We kunnen verwijzingen naar niet-opgeslagen objecten krijgen als ze een adapter aan ZODB.interfaces.IConnection. De methode add op de verbinding wordt gebruikt om het object een object ID, welke voldoende informatie om de referentie te berekenen. Om dit te zien, zullen we een object dat voldoet aan IConnection op een domme manier te maken:
& Nbsp; >>> import aanhoudende
& Nbsp; >>> van ZODB.interfaces importeren IConnection
& Nbsp; >>> klasse C (persistent.Persistent):
& Nbsp; ... def __conform __ (zelf, iface):
& Nbsp; ... als iface is IConnection:
& Nbsp; ... return conn2
& Nbsp; >>> OB3 = C ()
& Nbsp; >>> Toets 3 = KeyReferenceToPersistent (OB3)
& Nbsp; >>> transaction.abort ()
Conflict Resolution
Tijdens het oplossen van conflicten, zoals besproken in ZODB / ConflictResolution.txt, verwijzingen naar blijvende objecten zijn in feite gevallen van ZODB.ConflictResolution.PersistentReference. Dit is relevant op twee manieren voor KeyReferenceToPersistent. Ten eerste, het verklaart een subtiliteit van de klas: het maakt niet erven van persistent.Persistent. Als dat zo was, zou het niet beschikbaar voor het oplossen van conflicten, net haar PersistentReference stand-in.
Ten tweede, het verklaart een deel van de code in de __hash__ en __cmp__ methoden. Deze methoden niet alleen omgaan persistent.Persistent objecten, maar PersistentReference objecten. Zonder dit gedrag, zullen objecten, zoals de klassieke ZODB BTrees, dat KeyReferenceToPersistent gebruiken als sleutels of set-leden niet in staat om conflicten op te lossen zijn. Zelfs met de speciale code in sommige gevallen de KeyReferenceToPersistent weigert vergelijken en hash tijdens conflictoplossing omdat het niet betrouwbaar kan doen.
__hash__ zullen relatief weinig werken tijdens conflictoplossing: alleen voor multidatabase gevonden. Hier zijn een paar voorbeelden.
& Nbsp; >>> van ZODB.ConflictResolution import PersistentReference
& Nbsp; >>> def fabriek (ref):
& Nbsp; ... res = KeyReferenceToPersistent .__ nieuwe __ (
& Nbsp; ... KeyReferenceToPersistent, ref)
& Nbsp; ... res.object = ref
& Nbsp; ... return res
& Nbsp; ...
& Nbsp; >>> hash (fabriek (PersistentReference (
& Nbsp; ... ('een OID', 'klasse metadata')))) # een typische verwijzing
& Nbsp; Traceback (meest recente oproep vorige):
& Nbsp; ...
& Nbsp; ValueError: de database naam niet beschikbaar op dit moment
& Nbsp; >>> bool (hash (fabriek (PersistentReference (
& Nbsp; ... ['m', ('een database', 'een OID', 'klasse metadata')])))) # multidatabase
& Nbsp; True
Dit betekent dat KeyReferenceToPersistent vaak zal belemmeren conflictoplossing voor de klassen zoals PersistentMapping.
__cmp__ werkt tenzij één object is een multidatabase referentie en de andere niet. Hier zijn een paar voorbeelden.
& Nbsp; >>> CMP (fabriek (PersistentReference (
& Nbsp; ... ('een OID', 'klasse metadata'))),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ('een OID', 'klasse metadata'))))
& Nbsp; 0
& Nbsp; >>> CMP (fabriek (PersistentReference (
& Nbsp; ... ('een OID', 'klasse metadata'))),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ('een ander oid', 'klasse metadata'))))
& Nbsp; -1
& Nbsp; >>> CMP (fabriek (PersistentReference ('een OID')),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ('een OID', 'klasse metadata'))))
& Nbsp; 0
& Nbsp; >>> CMP (fabriek (PersistentReference ('een OID')),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ('een OID', 'klasse metadata'))))
& Nbsp; 0
& Nbsp; >>> CMP (fabriek (PersistentReference (
& Nbsp; ... ['m', ('een database', 'een OID', 'klasse metadata')])),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ['m', ('een database', 'een OID', 'klasse metadata')])))
& Nbsp; 0
& Nbsp; >>> CMP (fabriek (PersistentReference (
& Nbsp; ... ['m', ('een database', 'een OID', 'klasse metadata')])),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ['n', ('een database', 'een OID')])))
& Nbsp; 0
& Nbsp; >>> CMP (fabriek (PersistentReference (
& Nbsp; ... ['m', ('een database', 'een OID', 'klasse metadata')])),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ['m', ('een andere database', 'een OID', 'klasse metadata')])))
& Nbsp; -1
& Nbsp; >>> CMP (fabriek (PersistentReference (
& Nbsp; ... ['m', ('een database', 'een OID', 'klasse metadata')])),
& Nbsp; ... fabriek (PersistentReference (
& Nbsp; ... ('een OID', 'klasse metadata'))))
& Nbsp; Traceback (meest recente oproep vorige):
& Nbsp; ...
& Nbsp; ValueError: kan niet sorteren op betrouwbare
Locatie-gebaseerde aansluiting adapter
De functie zope.keyreference.connectionOfPersistent past objecten om verbindingen met behulp van een eenvoudige locatie-gebaseerde heuristiek. Laten controleren om te zien of het object een __parent__ dat een verbinding heeft:
& Nbsp; >>> van zope.keyreference.persistent import connectionOfPersistent
& Nbsp; >>> OB3 = PersistentMapping ()
& Nbsp; >>> print connectionOfPersistent (OB3)
& Nbsp; Geen
& Nbsp; >>> OB3 .__ parent__ = root2 ['ob1']
& Nbsp; >>> connectionOfPersistent (OB3) is conn2
& Nbsp; True

Wat is nieuw in deze release:

• Fix testen gebroken door verwijdering van zope.testing uit testen afhankelijkheden: voorkomen dat de ZODB3 module die het nodig heeft.

Eisen

• Python