zope.keyreference

zope.keyreference proporciona referencias a objetos que admiten comparación estable y hashes.
Referencias clave para Persistentes objetos
zope.keyreference.persistent.KeyReferenceToPersistent proporciona una referencia zope.keyreference.interfaces.IKeyReference para objetos persistentes.
Veamos un ejemplo. En primer lugar, vamos a crear algunos objetos persistentes en una base de datos:
& Nbsp; >>> from ZODB.MappingStorage importación DB
& Nbsp; >>> transacción de importación
& Nbsp; >>> from persistent.mapping PersistentMapping importación
& Nbsp; >>> db = DB ()
& Nbsp; >>> conn = db.Open ()
& Nbsp; >>> root = conn.root ()
& Nbsp; >>> raíz ['ob1'] = PersistentMapping ()
& Nbsp; >>> raíz ['ob2'] = PersistentMapping ()
& Nbsp; >>> transaction.Commit ()
A continuación vamos a crear algunas referencias clave:
& Nbsp; >>> from KeyReferenceToPersistent importación zope.keyreference.persistent
& Nbsp; >>> key1 = KeyReferenceToPersistent (root ['ob1'])
& Nbsp; >>> key2 = KeyReferenceToPersistent (root ['ob2'])
Podemos llamar a las claves para conseguir los objetos:
& Nbsp; >>> key1 () es la raíz ['ob1'], key2 () es la raíz ['ob2']
& Nbsp; (True, True)
Nuevas claves para los mismos objetos son iguales a la antigua:
& Nbsp; >>> KeyReferenceToPersistent (root ['ob1']) == key1
& Nbsp; El verdadero
y tienen los mismos valores hash:
& Nbsp; >>> almohadilla (KeyReferenceToPersistent (root ['ob1'])) == almohadilla (key1)
& Nbsp; El verdadero
Otras implementaciones de referencia clave se diferenciaban por su Identificación del tipo de clave. Principales referencias deben ordenar primero en su tipo de clave y segundo en la información específica del tipo:
& Nbsp; >>> de implementos de importación zope.interface
& Nbsp; >>> from zope.keyreference.interfaces importan IKeyReference
& Nbsp; >>> DummyKeyReference clase (objeto):
& Nbsp; ... implementos (IKeyReference)
& Nbsp; "zope.app.keyreference.object '... key_type_id =
& Nbsp; ... def __init __ (self, obj):
& Nbsp; ... self.object = obj
& Nbsp; ... def __cmp __ (self, otro):
& Nbsp; ... si self.key_type_id == other.key_type_id:
& Nbsp; ... volver cmp (self.object, other.object)
& Nbsp; ... volver cmp (self.key_type_id, other.key_type_id)
& Nbsp; >>> dummy_key1 = DummyKeyReference (objeto ())
& Nbsp; >>> dummy_key2 = DummyKeyReference (objeto ())
& Nbsp; >>> dummy_key3 = DummyKeyReference (objeto ())
& Nbsp; >>> teclas = [key1, dummy_key1, dummy_key2, key2, dummy_key3]
& Nbsp; >>> keys.sort ()
& Nbsp; >>> key_type_ids = [key.key_type_id para clave en teclas]
& Nbsp; >>> key_type_ids [0: 3] .count ('zope.app.keyreference.object')
& Nbsp; 3
. & Nbsp; >>> key_type_ids [3:] count ('zope.app.keyreference.persistent')
& Nbsp; 2
Almacenaremos las referencias clave en la base de datos:
& Nbsp; >>> raíz ['key1'] = key1
& Nbsp; >>> raíz ['key2'] = key2
y utilice las teclas para almacenar los objetos de nuevo:
& Nbsp; >>> raíz [key1] = root ['ob1']
& Nbsp; >>> raíz [key2] = root ['ob2']
& Nbsp; >>> transaction.Commit ()
Ahora vamos a abrir otra conexión:
& Nbsp; >>> Conn2 = db.Open ()
Y comprobamos que podemos utilizar las teclas para ver los objetos:
& Nbsp; >>> root2 = conn2.root ()
& Nbsp; >>> key1 = root2 ['key1']
& Nbsp; >>> root2 [key1] es root2 ['ob1']
& Nbsp; El verdadero
& Nbsp; >>> key2 = root2 ['key2']
& Nbsp; >>> root2 [key2] es root2 ['ob2']
& Nbsp; El verdadero
y que también podemos llamar las claves para conseguir los objetos:
& Nbsp; >>> key1 () es root2 ['ob1']
& Nbsp; El verdadero
& Nbsp; >>> key2 () es root2 ['ob2']
& Nbsp; El verdadero
No podemos obtener la clave de referencia para un objeto que no se ha guardado aún:
& Nbsp; >>> KeyReferenceToPersistent (PersistentMapping ())
& Nbsp; ... # doctest: + ELLIPSIS
& Nbsp; El rastreo (most recent call last):
& Nbsp; ...
& Nbsp; notyet: ...
Tenga en cuenta que tenemos un error notyet. Esto indica que es posible que podamos obtener una referencia clave de la tarde.
Podemos obtener referencias a objetos no guardados si tienen un adaptador para ZODB.interfaces.IConnection. El método add en la conexión se utiliza para dar al objeto un id de objeto, que es suficiente información para calcular la referencia. Para ver esto, vamos a crear un objeto que se ajusta a IConnection de una manera tonta:
& Nbsp; >>> import persistente
& Nbsp; >>> from ZODB.interfaces importan IConnection
& Nbsp; >>> clase C (persistent.Persistent):
& Nbsp; ... def __conform __ (self, del iface):
& Nbsp; ... si es del iface IConnection:
& Nbsp; ... volver Conn2
& Nbsp; >>> OB3 = C ()
& Nbsp; >>> key3 = KeyReferenceToPersistent (OB3)
& Nbsp; >>> transaction.abort ()
Resolución de Conflictos
Durante la resolución de conflictos, como se discute en ZODB / ConflictResolution.txt, las referencias a objetos persistentes son en realidad casos de ZODB.ConflictResolution.PersistentReference. Esto es pertinente en dos formas para que KeyReferenceToPersistent. En primer lugar, explica una sutileza de la clase: que no hereda de persistent.Persistent. Si lo hiciera, no estaría disponible para la resolución de conflictos, sólo su PersistentReference suplente.
En segundo lugar, explica una parte del código en los métodos __hash__ y __cmp__. Estos métodos no sólo manejan objetos persistent.Persistent, sino objetos PersistentReference. Sin este comportamiento, los objetos, como el clásico ZODB btrees, que utilizan KeyReferenceToPersistent como llaves o miembros del conjunto no serán capaces de resolver los conflictos. Incluso con el código especial, en algunos casos la KeyReferenceToPersistent se negará a comparar y de hash durante la resolución de conflictos porque no puede hacerlo de forma fiable.
__hash__ trabajará con relativa poca frecuencia durante la resolución de conflictos: sólo para datos múltiples referencias. Aquí hay un par de ejemplos.
& Nbsp; >>> from ZODB.ConflictResolution PersistentReference importación
& Nbsp; >>> fábrica def (ref):
& Nbsp; ... res = KeyReferenceToPersistent .__ nueva __ (
& Nbsp; ... KeyReferenceToPersistent, ref)
& Nbsp; ... res.object = ref
& Nbsp; ... res de retorno
& Nbsp; ...
& Nbsp; >>> almohadilla (fábrica (PersistentReference (
& Nbsp; ... ("clase de metadatos '' un OID ')))) # una referencia típica
& Nbsp; El rastreo (most recent call last):
& Nbsp; ...
& Nbsp; ValueError: nombre de la base no está disponible en este momento
& Nbsp; >>> bool (hash (fábrica (PersistentReference (
& Nbsp; ... ['m', ('una base de datos "," un OID "," clase de metadatos')])))) # varias bases
& Nbsp; El verdadero
Esto significa que KeyReferenceToPersistent menudo obstaculizará la resolución de conflictos de clases como PersistentMapping.
__cmp__ funciona a menos que un objeto es una referencia varias bases y el otro no lo es. Aquí hay algunos ejemplos.
& Nbsp; >>> cmp (fábrica (PersistentReference (
& Nbsp; ... ('un OID "," clase de metadatos'))),
& Nbsp; ... fábrica (PersistentReference (
& Nbsp; ... ('un OID "," clase de metadatos'))))
& Nbsp; 0
& Nbsp; >>> cmp (fábrica (PersistentReference (
& Nbsp; ... ('un OID "," clase de metadatos'))),
& Nbsp; ... fábrica (PersistentReference (
& Nbsp; ... ('otro oid "," clase de metadatos'))))
& Nbsp; -1
& Nbsp; >>> cmp (fábrica (PersistentReference ('un OID')),
& Nbsp; ... fábrica (PersistentReference (
& Nbsp; ... ('un OID "," clase de metadatos'))))
& Nbsp; 0
& Nbsp; >>> cmp (fábrica (PersistentReference ('un OID')),
& Nbsp; ... fábrica (PersistentReference (
& Nbsp; ... ('un OID "," clase de metadatos'))))
& Nbsp; 0
& Nbsp; >>> cmp (fábrica (PersistentReference (
& Nbsp; ... ['m', ('una base de datos "," un OID', 'metadatos clase')])),
& Nbsp; ... fábrica (PersistentReference (
& Nbsp; ... ['m', ('una base de datos "," un OID "," clase de metadatos')])))
& Nbsp; 0
& Nbsp; >>> cmp (fábrica (PersistentReference (
& Nbsp; ... ['m', ('una base de datos "," un OID', 'metadatos clase')])),
& Nbsp; ... fábrica (PersistentReference (
& Nbsp; ... ['n', ('una base de datos "," un OID')])))
& Nbsp; 0
& Nbsp; >>> cmp (fábrica (PersistentReference (
& Nbsp; ... ['m', ('una base de datos "," un OID', 'metadatos clase')])),
& Nbsp; ... fábrica (PersistentReference (
& Nbsp; ... ['m', ('otra base de datos', 'un OID "," clase de metadatos')])))
& Nbsp; -1
& Nbsp; >>> cmp (fábrica (PersistentReference (
& Nbsp; ... ['m', ('una base de datos "," un OID', 'metadatos clase')])),
& Nbsp; ... fábrica (PersistentReference (
& Nbsp; ... ('un OID "," clase de metadatos'))))
& Nbsp; El rastreo (most recent call last):
& Nbsp; ...
& Nbsp; ValueError: no puede ordenar de forma fiable
adaptador de conexión basada en la ubicación
El zope.keyreference.connectionOfPersistent función adapta objetos a las conexiones con una sencilla heurística basada en la ubicación. Se comprueba si el objeto tiene un __parent__ que tiene una conexión:
& Nbsp; >>> from connectionOfPersistent importación zope.keyreference.persistent
& Nbsp; >>> OB3 = PersistentMapping ()
& Nbsp; >>> connectionOfPersistent impresión (OB3)
& Nbsp; Ninguno
& Nbsp; >>> OB3 .__ parent__ = root2 ['ob1']
& Nbsp; >>> connectionOfPersistent (OB3) es Conn2
& Nbsp; El verdadero

¿Qué hay de nuevo en esta versión:

• Pruebas Fix roto por la eliminación de zope.testing de las dependencias de la prueba: evitar el módulo ZODB3 que la necesite.

Requisitos :

• Python