zope.keyreference

zope.keyreference ger objektreferenser som stöder stabila jämförelse och hashar.
Nyckel Referenser för långlivade objekt
zope.keyreference.persistent.KeyReferenceToPersistent ger en zope.keyreference.interfaces.IKeyReference referens för persistenta objekt.
Låt oss titta på ett exempel. Först ska vi skapa några ihärdiga objekt i en databas:
& Nbsp; >>> från ZODB.MappingStorage import DB
& Nbsp; >>> importtransaktion
& Nbsp; >>> från persistent.mapping import PersistentMapping
& Nbsp; >>> db = DB ()
& Nbsp; >>> uppk = db.open ()
& Nbsp; >>> root = conn.root ()
& Nbsp; >>> rot ['OB1'] = PersistentMapping ()
& Nbsp; >>> rot ['OB2'] = PersistentMapping ()
& Nbsp; >>> transaction.commit ()
Sen ska vi skapa några viktiga referenser:
& Nbsp; >>> från zope.keyreference.persistent import KeyReferenceToPersistent
& Nbsp; >>> nyckel1 = KeyReferenceToPersistent (root ['OB1'])
& Nbsp; >>> KEY2 = KeyReferenceToPersistent (root ['OB2'])
Vi kan kalla nycklarna för att få objekten:
& Nbsp; >>> nyckel1 () är roten ['OB1'], är NKL2 () rot ['OB2']
& Nbsp; (Sant, sant)
Nya nycklar till samma objekt är lika med den gamla:
& Nbsp; >>> KeyReferenceToPersistent (root ['OB1']) == nyckel1
& Nbsp; Sann
och har samma hash:
& Nbsp; >>> hash (KeyReferenceToPersistent (root ['OB1'])) == hash (nyckel1)
& Nbsp; Sann
Andra viktiga referens implementeringar är skilde av sin nyckel typ id. Nyckel referenser bör sortera först på deras nyckel typ och andra på alla typer specifik information:
& Nbsp; >>> från zope.interface import redskap
& Nbsp; >>> från zope.keyreference.interfaces importera IKeyReference
& Nbsp; >>> klass DummyKeyReference (objekt):
& Nbsp; ... redskap (IKeyReference)
& Nbsp; ... key_type_id = 'zope.app.keyreference.object'
& Nbsp; ... def __init __ (self, obj):
& Nbsp; ... self.object = obj
& Nbsp; ... def __cmp __ (self, annat):
& Nbsp; ... om self.key_type_id == other.key_type_id:
& Nbsp; ... retur cmp (self.object, other.object)
& Nbsp; ... retur cmp (self.key_type_id, other.key_type_id)
& Nbsp; >>> dummy_key1 = DummyKeyReference (objekt ())
& Nbsp; >>> dummy_key2 = DummyKeyReference (objekt ())
& Nbsp; >>> dummy_key3 = DummyKeyReference (objekt ())
& Nbsp; >>> nycklar = [nyckel1, dummy_key1, dummy_key2, KEY2, dummy_key3]
& Nbsp; >>> keys.sort ()
& Nbsp; >>> key_type_ids = [key.key_type_id för nyckeln i nycklar]
& Nbsp; >>> key_type_ids [0: 3] .count ('zope.app.keyreference.object')
& Nbsp; 3
. & Nbsp; >>> key_type_ids [3:] räknas ("zope.app.keyreference.persistent ')
& Nbsp; 2
Vi kommer att lagra de viktigaste referenserna i databasen:
& Nbsp; >>> rot ['nyckel1'] = nyckel1
& Nbsp; >>> rot ['NKL2'] = KEY2
och använd knapparna för att lagra objekten igen:
& Nbsp; >>> root [nyckel1] = rot ['OB1']
& Nbsp; >>> root [NKL2] = rot ['OB2']
& Nbsp; >>> transaction.commit ()
Nu ska vi öppna en annan anslutning:
& Nbsp; >>> conn2 = db.open ()
Och kontrollera att vi kan använda knapparna för att slå upp objekten:
& Nbsp; >>> root2 = conn2.root ()
& Nbsp; >>> nyckel1 = root2 ['nyckel1']
& Nbsp; >>> root2 [nyckel1] är root2 ['OB1']
& Nbsp; Sann
& Nbsp; >>> NKL2 = root2 ['NKL2']
& Nbsp; >>> root2 [NKL2] är root2 ['OB2']
& Nbsp; Sann
och att vi kan också ringa nycklarna för att få objekten:
& Nbsp; >>> nyckel1 () är root2 ['OB1']
& Nbsp; Sann
& Nbsp; >>> NKL2 () är root2 ['OB2']
& Nbsp; Sann
Vi kan inte få nyckeln referens för ett objekt som inte har sparats ännu:
& Nbsp; >>> KeyReferenceToPersistent (PersistentMapping ())
& Nbsp; ... # doctest: + ELLIPS
& Nbsp; återsöknings (senaste samtal sist):
& Nbsp; ...
& Nbsp; NotYet: ...
Observera att vi får en NotYet fel. Detta tyder på att vi skulle kunna få en viktig referens senare.
Vi kan få referenser till ofrälsta föremål om de har en adapter till ZODB.interfaces.IConnection. Tillägget metod på anslutningen kommer att användas för att ge objektet ett objekt id, vilket är tillräckligt med information för att beräkna referens. För att se detta, kommer vi skapa ett objekt som överensstämmer med IConnection på ett dumt sätt:
& Nbsp; >>> import ihållande
& Nbsp; >>> från ZODB.interfaces importera IConnection
& Nbsp; >>> klass C (persistent.Persistent):
& Nbsp; ... def __conform __ (self, iface):
& Nbsp; ... om iface är IConnection:
& Nbsp; ... retur conn2
& Nbsp; >>> OB3 = C ()
& Nbsp; >>> KEY3 = KeyReferenceToPersistent (OB3)
& Nbsp; >>> transaction.abort ()
Konfliktlösning
Under konfliktlösning, vilket diskuteras i ZODB / ConflictResolution.txt, referenser till persistenta objekt är faktiskt instanser av ZODB.ConflictResolution.PersistentReference. Detta är relevant på två sätt för KeyReferenceToPersistent. Först förklarar det en subtilitet av klassen: den inte ärver från persistent.Persistent. Om det gjorde det, skulle det inte vara tillgänglig för konfliktlösning, bara dess PersistentReference stand-in.
För det andra, förklarar en del av koden i __hash__ och __cmp__ metoder. Dessa metoder inte bara hantera persistent.Persistent objekt, utan PersistentReference objekt. Utan detta beteende, kommer föremål, såsom den klassiska ZODB BTrees, som använder KeyReferenceToPersistent som nycklar eller inställda medlemmar inte kan lösa konflikter. Även med den speciella koden, i vissa fall KeyReferenceToPersistent kommer att vägra att jämföra och hash under konfliktlösning eftersom den inte på ett tillförlitligt sätt kan göra det.
__hash__ fungerar relativt sällan under konfliktlösning: endast för multidatabase referenser. Här är ett par exempel.
& Nbsp; >>> från ZODB.ConflictResolution import PersistentReference
& Nbsp; >>> def fabrik (ref):
& Nbsp; ... res = KeyReferenceToPersistent .__ nytt __ (
& Nbsp; ... KeyReferenceToPersistent, ref)
& Nbsp; ... res.object = ref
& Nbsp; ... retur res
& Nbsp; ...
& Nbsp; >>> hash (fabriks (PersistentReference (
& Nbsp; ... ("en oid ',' klass metadata")))) # en typisk referens
& Nbsp; återsöknings (senaste samtal sist):
& Nbsp; ...
& Nbsp; ValueError: databasnamn otillgänglig vid denna tid
& Nbsp; >>> bool (hash (fabriks (PersistentReference (
& Nbsp; ... ["m", ("en databas", "en oid ',' klass metadata")])))) # multidatabase
& Nbsp; Sann
Detta innebär att KeyReferenceToPersistent ofta hindrar konfliktlösning för klasser såsom PersistentMapping.
__cmp__ fungerar såvida ett objekt är en multidatabase referens och den andra inte. Här är några exempel.
& Nbsp; >>> cmp (fabriks (PersistentReference (
& Nbsp; ... ("en oid ',' klass metadata"))),
& Nbsp; ... fabriken (PersistentReference (
& Nbsp; ... ("en oid ',' klass metadata"))))
& Nbsp; 0
& Nbsp; >>> cmp (fabriks (PersistentReference (
& Nbsp; ... ("en oid ',' klass metadata"))),
& Nbsp; ... fabriken (PersistentReference (
& Nbsp; ... ("annan oid ',' klass metadata"))))
& Nbsp; -1
& Nbsp; >>> cmp (fabriks (PersistentReference ("en oid ')),
& Nbsp; ... fabriken (PersistentReference (
& Nbsp; ... ("en oid ',' klass metadata"))))
& Nbsp; 0
& Nbsp; >>> cmp (fabriks (PersistentReference ("en oid ')),
& Nbsp; ... fabriken (PersistentReference (
& Nbsp; ... ("en oid ',' klass metadata"))))
& Nbsp; 0
& Nbsp; >>> cmp (fabriks (PersistentReference (
& Nbsp; ... ["m", ("en databas", "en oid ',' klass metadata")])),
& Nbsp; ... fabriken (PersistentReference (
& Nbsp; ... ["m", ("en databas", "en oid ',' klass metadata")])))
& Nbsp; 0
& Nbsp; >>> cmp (fabriks (PersistentReference (
& Nbsp; ... ["m", ("en databas", "en oid ',' klass metadata")])),
& Nbsp; ... fabriken (PersistentReference (
& Nbsp; ... ['n', ('en databas "," en oid')])))
& Nbsp; 0
& Nbsp; >>> cmp (fabriks (PersistentReference (
& Nbsp; ... ["m", ("en databas", "en oid ',' klass metadata")])),
& Nbsp; ... fabriken (PersistentReference (
& Nbsp; ... ["m", ("en annan databas", "en oid ',' klass metadata")])))
& Nbsp; -1
& Nbsp; >>> cmp (fabriks (PersistentReference (
& Nbsp; ... ["m", ("en databas", "en oid ',' klass metadata")])),
& Nbsp; ... fabriken (PersistentReference (
& Nbsp; ... ("en oid ',' klass metadata"))))
& Nbsp; återsöknings (senaste samtal sist):
& Nbsp; ...
& Nbsp; ValueError: kan inte sortera tillförlitligt
Plats baserad anslutning adapter
Funktionen zope.keyreference.connectionOfPersistent anpassar objekt till anslutningar med en enkel platsbaserad heuristik. Det kontrolleras för att se om objektet har en __parent__ som har en anslutning:
& Nbsp; >>> från zope.keyreference.persistent import connectionOfPersistent
& Nbsp; >>> OB3 = PersistentMapping ()
& Nbsp; >>> utskrifts connectionOfPersistent (OB3)
& Nbsp; Ingen
& Nbsp; >>> OB3 .__ parent__ = root2 ['OB1']
& Nbsp; >>> connectionOfPersistent (OB3) är conn2
& Nbsp; Sann

Vad är nytt i den här versionen:

• Fix tester bryts genom att avlägsna zope.testing från prov beroenden: undvika ZODB3 modulen som behöver den.

Krav :

• Python