zope.keyreference

zope.keyreference gir objekt referanser som støtter stabil sammenligning og hashes.
Nøkkel Referanser for persistente objekter
zope.keyreference.persistent.KeyReferenceToPersistent gir en zope.keyreference.interfaces.IKeyReference referanse for vedvarende stedene.
La oss se på et eksempel. Først vil vi lage noen vedvarende objekter i en database:
& Nbsp; >>> fra ZODB.MappingStorage import DB
& Nbsp; >>> import transaksjoner
& Nbsp; >>> fra persistent.mapping import PersistentMapping
& Nbsp; >>> db = DB ()
& Nbsp; >>> conn = db.open ()
& Nbsp; >>> root = conn.root ()
& Nbsp; >>> root ['OB1'] = PersistentMapping ()
& Nbsp; >>> root ['ob2'] = PersistentMapping ()
& Nbsp; >>> transaction.commit ()
Deretter vil vi lage noen viktige referanser:
& Nbsp; >>> fra zope.keyreference.persistent import KeyReferenceToPersistent
& Nbsp; >>> pinne 1 = KeyReferenceToPersistent (root ['OB1'])
& Nbsp; >>> NØKKEL2 = KeyReferenceToPersistent (root ['ob2'])
Vi kan kalle nøklene for å få objektene:
& Nbsp; >>> pinne 1 () er roten ['OB1'], er NØKKEL2 () root ['ob2']
& Nbsp; (sann, sann)
Nye nøkler til de samme objektene er lik den gamle:
& Nbsp; >>> KeyReferenceToPersistent (root ['OB1']) == nøkkel1
& Nbsp; Sann
og har de samme hashes:
& Nbsp; >>> hash (KeyReferenceToPersistent (root ['OB1'])) == hash (pinne 1)
& Nbsp; Sann
Andre viktige referanse implementeringer er uenige med deres nøkkeltype id. Nøkkel referanser skal sortere først på deres nøkkeltype og andre på alle typer spesifikk informasjon:
& Nbsp; >>> fra zope.interface import redskaper
& Nbsp; >>> fra zope.keyreference.interfaces importere IKeyReference
& Nbsp; >>> klasse DummyKeyReference (objekt):
& Nbsp; ... redskaper (IKeyReference)
& Nbsp; ... key_type_id = 'zope.app.keyreference.object'
& Nbsp; ... def __init __ (selv, obj):
& Nbsp; ... self.object = obj
& Nbsp; ... def __cmp __ (selv, annet):
& Nbsp; ... hvis 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; >>> nøkler = [pinne 1 dummy_key1, dummy_key2, NØKKEL2, dummy_key3]
& Nbsp; >>> keys.sort ()
& Nbsp; >>> key_type_ids = [key.key_type_id for nøkkelen i keys]
& Nbsp; >>> key_type_ids [0: 3] .count ('zope.app.keyreference.object')
& Nbsp; 3
. & Nbsp; >>> key_type_ids [3:] telle ('zope.app.keyreference.persistent')
& Nbsp; 2
Vi vil lagre viktige referanser i databasen:
& Nbsp; >>> root ['pinne 1'] = nøkkel1
& Nbsp; >>> root ['NØKKEL2'] = NØKKEL2
og bruke tastene til å lagre objektene igjen:
& Nbsp; >>> root [pinne 1] = root ['OB1']
& Nbsp; >>> root [NØKKEL2] = root ['ob2']
& Nbsp; >>> transaction.commit ()
Nå skal vi åpne en annen forbindelse:
& Nbsp; >>> conn2 = db.open ()
Og kontrollere at vi kan bruke tastene til å slå opp objektene:
& Nbsp; >>> root2 = conn2.root ()
& Nbsp; >>> pinne 1 = root2 ['pinne 1']
& Nbsp; >>> root2 [pinne 1] er root2 ['OB1']
& Nbsp; Sann
& Nbsp; >>> NØKKEL2 = root2 ['NØKKEL2']
& Nbsp; >>> root2 [NØKKEL2] er root2 ['ob2']
& Nbsp; Sann
og at vi også kan kalle nøklene for å få objektene:
& Nbsp; >>> pinne 1 () er root2 ['OB1']
& Nbsp; Sann
& Nbsp; >>> NØKKEL2 () er root2 ['ob2']
& Nbsp; Sann
Vi kan ikke få nøkkelen referanse for et objekt som ikke er lagret ennå:
& Nbsp; >>> KeyReferenceToPersistent (PersistentMapping ())
& Nbsp; ... # doctest: + ellipse
& Nbsp; Traceback (siste samtale sist):
& Nbsp; ...
& Nbsp; NotYet: ...
Legg merke til at vi får en NotYet feil. Dette tyder på at vi kan være i stand til å få en nøkkelreferanse senere.
Vi kan få referanser til ufrelste gjenstander hvis de har en adapter til ZODB.interfaces.IConnection. Tillegget metoden på forbindelsen vil bli benyttet for å gi objektet en gjenstand id, som er nok informasjon til å beregne referanse. For å se dette, vil vi lage et objekt som er i samsvar med IConnection på en dum måte:
& Nbsp; >>> import vedvarende
& Nbsp; >>> fra ZODB.interfaces importere IConnection
& Nbsp; >>> klasse C (persistent.Persistent):
& Nbsp; ... def __conform __ (selv, iface):
& Nbsp; ... hvis iface er IConnection:
& Nbsp; ... retur conn2
& Nbsp; >>> OB3 = C ()
& Nbsp; >>> TAST3 = KeyReferenceToPersistent (OB3)
& Nbsp; >>> transaction.abort ()
Konfliktløsning
Under konfliktløsning, som omtalt i ZODB / ConflictResolution.txt, referanser til vedvarende objekter er faktisk tilfeller av ZODB.ConflictResolution.PersistentReference. Dette er relevant på to måter for KeyReferenceToPersistent. Først, forklarer det en subtilitet av klassen: det gjør ikke arve fra persistent.Persistent. Hvis den gjorde det, ville det ikke være tilgjengelig for konfliktløsning, bare sin PersistentReference stand-in.
Sekund, det forklarer noe av koden i __hash__ og __cmp__ metoder. Disse metodene ikke bare håndtere persistent.Persistent objekter, men PersistentReference stedene. Uten denne oppførselen, vil objekter, for eksempel den klassiske ZODB BTrees, som bruker KeyReferenceToPersistent som nøkler eller sett medlemmer være i stand til å løse konflikter. Selv med spesiell kode, i noen tilfeller KeyReferenceToPersistent vil nekte å sammenligne og hasj i løpet av konfliktløsning, fordi det ikke kan sikkert gjøre det.
__hash__ vil fungere relativt sjelden ved konfliktløsning: bare for multidatabase referanser. Her er et par eksempler.
& Nbsp; >>> fra ZODB.ConflictResolution import PersistentReference
& Nbsp; >>> def fabrikk (ref):
& Nbsp; ... res = KeyReferenceToPersistent .__ ny __ (
& Nbsp; ... KeyReferenceToPersistent, ref)
& Nbsp; ... res.object = ref
& Nbsp; ... retur res
& Nbsp; ...
& Nbsp; >>> hash (fabrikk (PersistentReference (
& Nbsp; ... ('en OID', 'klasse metadata')))) # en typisk referanse
& Nbsp; Traceback (siste samtale sist):
& Nbsp; ...
& Nbsp; ValueError: databasenavn for tiden ikke tilgjengelig
& Nbsp; >>> bool (hash (fabrikk (PersistentReference (
& Nbsp; ... ['m', ('en database', 'en oid', 'klasse metadata')])))) # multidatabase
& Nbsp; Sann
Dette betyr at KeyReferenceToPersistent vil ofte hindre konfliktløsning for klasser som PersistentMapping.
__cmp__ arbeider med mindre ett objekt er en multidatabase referanse, og den andre ikke er det. Her er noen eksempler.
& Nbsp; >>> cmp (fabrikk (PersistentReference (
& Nbsp; ... ('en OID', 'klasse metadata'))),
& Nbsp; ... fabrikk (PersistentReference (
& Nbsp; ... ('en OID', 'klasse metadata'))))
& Nbsp; 0
& Nbsp; >>> cmp (fabrikk (PersistentReference (
& Nbsp; ... ('en OID', 'klasse metadata'))),
& Nbsp; ... fabrikk (PersistentReference (
& Nbsp; ... ('annen oid', 'klasse metadata'))))
& Nbsp; -1
& Nbsp; >>> cmp (fabrikk (PersistentReference ('en OID')),
& Nbsp; ... fabrikk (PersistentReference (
& Nbsp; ... ('en OID', 'klasse metadata'))))
& Nbsp; 0
& Nbsp; >>> cmp (fabrikk (PersistentReference ('en OID')),
& Nbsp; ... fabrikk (PersistentReference (
& Nbsp; ... ('en OID', 'klasse metadata'))))
& Nbsp; 0
& Nbsp; >>> cmp (fabrikk (PersistentReference (
& Nbsp; ... ['m', ('en database', 'en oid', 'klasse metadata')])),
& Nbsp; ... fabrikk (PersistentReference (
& Nbsp; ... ['m', ('en database', 'en oid', 'klasse metadata')])))
& Nbsp; 0
& Nbsp; >>> cmp (fabrikk (PersistentReference (
& Nbsp; ... ['m', ('en database', 'en oid', 'klasse metadata')])),
& Nbsp; ... fabrikk (PersistentReference (
& Nbsp; ... ['n', ('en database', 'en oid')])))
& Nbsp; 0
& Nbsp; >>> cmp (fabrikk (PersistentReference (
& Nbsp; ... ['m', ('en database', 'en oid', 'klasse metadata')])),
& Nbsp; ... fabrikk (PersistentReference (
& Nbsp; ... ['m', ('annen database', 'en oid', 'klasse metadata')])))
& Nbsp; -1
& Nbsp; >>> cmp (fabrikk (PersistentReference (
& Nbsp; ... ['m', ('en database', 'en oid', 'klasse metadata')])),
& Nbsp; ... fabrikk (PersistentReference (
& Nbsp; ... ('en OID', 'klasse metadata'))))
& Nbsp; Traceback (siste samtale sist):
& Nbsp; ...
& Nbsp; ValueError: kan ikke sortere pålitelig
Stedsbasert forbindelse adapter
Funksjonen zope.keyreference.connectionOfPersistent tilpasser objekter til tilkoblinger ved hjelp av en enkel stedsbasert heuristisk. Det sjekket for å se om objektet har en __parent__ som har en forbindelse:
& Nbsp; >>> fra zope.keyreference.persistent import connectionOfPersistent
& Nbsp; >>> OB3 = PersistentMapping ()
& Nbsp; >>> print connectionOfPersistent (OB3)
& Nbsp; None
& Nbsp; >>> OB3 .__ parent__ = root2 ['OB1']
& Nbsp; >>> connectionOfPersistent (OB3) er conn2
& Nbsp; Sann

Hva er nytt i denne utgaven:

• Fix tester brutt ved fjerning av zope.testing fra testavhengigheter: unngå ZODB3 modul som trenger det.

Krav :

• Python