zope.keyreference

zope.keyreference fournit des références d'objets qui soutiennent la comparaison et hashes stable.
Références clés pour objets persistants
zope.keyreference.persistent.KeyReferenceToPersistent fournit une référence pour zope.keyreference.interfaces.IKeyReference objets persistants.
Voyons un exemple. Tout d'abord, nous allons créer des objets persistants dans une base de données:
& Nbsp; >>> from ZODB.MappingStorage importation DB
& Nbsp; >>> opération d'importation
& Nbsp; >>> from persistent.mapping PersistentMapping d'importation
& Nbsp; >>> db = DB ()
& Nbsp; >>> conn = db.Open ()
& Nbsp; >>> root = conn.root ()
& Nbsp; >>> racine ['OB1'] = PersistentMapping ()
& Nbsp; >>> racine ['OB2'] = PersistentMapping ()
& Nbsp; >>> transaction.Commit ()
Ensuite, nous allons créer quelques références clés:
& Nbsp; >>> from KeyReferenceToPersistent d'importation zope.keyreference.persistent
& Nbsp; >>> key1 = KeyReferenceToPersistent (racine ['OB1'])
& Nbsp; >>> key2 = KeyReferenceToPersistent (racine ['OB2'])
Nous pouvons appeler les touches pour obtenir les objets:
& Nbsp; >>> key1 () est la racine ['OB1'], key2 () est la racine ['OB2']
& Nbsp; (True, True)
De nouvelles clés aux mêmes objets sont égaux à l'ancien:
& Nbsp; >>> KeyReferenceToPersistent (racine ['OB1']) == key1
& Nbsp; Vrai
et ont les mêmes tables de hachage:
& Nbsp; >>> hachage (KeyReferenceToPersistent (racine ['OB1'])) == hachage (key1)
& Nbsp; Vrai
D'autres implémentations de référence clés sont différaient par leur type de clé id. Principales références doivent trier d'abord sur leur type de clé et le second sur toute information spécifique au type:
& Nbsp; >>> à partir des outils d'importation zope.interface
& Nbsp; >>> from zope.keyreference.interfaces importer IKeyReference
& Nbsp; >>> DummyKeyReference de classe (objet):
& Nbsp; ... instruments (IKeyReference)
& Nbsp; ... key_type_id = 'zope.app.keyreference.object'
& Nbsp; ... def __init __ (self, obj):
& Nbsp; ... self.object = obj
& Nbsp; ... def __cmp __ (self, autre):
& Nbsp; ... si self.key_type_id == other.key_type_id:
& Nbsp; ... retour cmp (self.object, other.object)
& Nbsp; ... retour cmp (self.key_type_id, other.key_type_id)
& Nbsp; >>> dummy_key1 = DummyKeyReference (objet ())
& Nbsp; >>> dummy_key2 = DummyKeyReference (objet ())
& Nbsp; >>> dummy_key3 = DummyKeyReference (objet ())
& Nbsp; >>> touches = [key1, dummy_key1, dummy_key2, key2, dummy_key3]
& Nbsp; >>> keys.sort ()
& Nbsp; >>> key_type_ids = [key.key_type_id pour la clé dans les clés]
& 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
Nous allons stocker les références clés dans la base de données:
& Nbsp; >>> racine ['key1'] = key1
& Nbsp; >>> racine ['key2'] = key2
et utiliser les touches pour stocker à nouveau les objets:
& Nbsp; >>> racine [key1] = racine ['OB1']
& Nbsp; >>> racine [key2] = racine ['OB2']
& Nbsp; >>> transaction.Commit ()
Maintenant, nous allons ouvrir une autre connexion:
& Nbsp; >>> conn2 = db.Open ()
Et de vérifier que nous pouvons utiliser les touches pour rechercher les objets:
& Nbsp; >>> Root2 = conn2.root ()
& Nbsp; >>> key1 = Root2 ['key1']
& Nbsp; >>> Root2 [key1] est Root2 ['OB1']
& Nbsp; Vrai
& Nbsp; >>> key2 = Root2 ['key2']
& Nbsp; >>> Root2 [key2] est Root2 ['OB2']
& Nbsp; Vrai
et que nous pouvons aussi appeler les touches pour obtenir les objets:
& Nbsp; >>> key1 () est Root2 ['OB1']
& Nbsp; Vrai
& Nbsp; >>> key2 () est Root2 ['OB2']
& Nbsp; Vrai
Nous ne pouvons pas obtenir la référence clé pour un objet qui n'a pas encore été enregistré:
& Nbsp; >>> KeyReferenceToPersistent (PersistentMapping ())
& Nbsp; ... # doctest: + ELLIPSIS
& Nbsp; d'enquête (appel le plus récent dernière):
& Nbsp; ...
& Nbsp; notyet: ...
Notez que nous obtenons une erreur de notyet. Cela indique que nous pourrions être en mesure d'obtenir une référence clé plus tard.
Nous pouvons obtenir des références à des objets non enregistrées se ils ont un adaptateur pour ZODB.interfaces.IConnection. La méthode add sur la connexion sera utilisée pour donner à l'objet un id de l'objet, qui est suffisamment d'informations pour calculer la référence. Pour le voir, nous allons créer un objet qui est conforme à IConnection d'une manière idiote:
& Nbsp; >>> import persistante
& Nbsp; >>> from ZODB.interfaces importer IConnection
& Nbsp; >>> classe C (persistent.Persistent):
& Nbsp; ... def __conform __ (self, iface):
& Nbsp; ... si iface est IConnection:
& Nbsp; ... retour conn2
& Nbsp; >>> ob3 = C ()
& Nbsp; >>> key3 = KeyReferenceToPersistent (ob3)
& Nbsp; >>> transaction.abort ()
Conflict Resolution
Au cours de la résolution des conflits, tel que discuté dans ZODB / ConflictResolution.txt, références à des objets persistants sont en fait des cas de ZODB.ConflictResolution.PersistentReference. Ce est pertinent de deux façons pour KeyReferenceToPersistent. D'abord, il explique une subtilité de la classe: il ne hérite pas de persistent.Persistent. Si elle le faisait, il ne serait pas disponible pour la résolution des conflits, seulement son PersistentReference stand-in.
Deuxièmement, il explique une partie du code dans les méthodes de __hash__ et __cmp__. Ces méthodes non seulement manipuler des objets, mais persistent.Persistent objets PersistentReference. Sans ce comportement, objets, tels que le classique ZODB arbre binaire, qui utilisent KeyReferenceToPersistent comme des touches ou des membres fixés seront incapables de résoudre les conflits. Même avec le code spécial, dans certains cas, le KeyReferenceToPersistent refusera de comparer et hachage lors de la résolution des conflits, car il ne peut pas le faire de manière fiable.
__hash__ fonctionnera relativement rarement lors de la résolution des conflits: uniquement pour les références de multi-bases. Voici quelques exemples.
& Nbsp; >>> from ZODB.ConflictResolution importation PersistentReference
& Nbsp; >>> usine de def (ref):
& Nbsp; ... res = KeyReferenceToPersistent .__ nouvelle __ (
& Nbsp; ... KeyReferenceToPersistent, ref)
& Nbsp; ... res.object = ref
& Nbsp; ... retour res
& Nbsp; ...
& Nbsp; >>> hachage (usine (PersistentReference (
& Nbsp; ... («métadonnées de classe '' un oid ')))) # une référence typique
& Nbsp; d'enquête (appel le plus récent dernière):
& Nbsp; ...
& Nbsp; ValueError: nom de la base disponible pour le moment
& Nbsp; >>> bool (dièse (usine (PersistentReference (
& Nbsp; ... ['m', ('une base de données »,« un oid »,« métadonnées de classe »)])))) # multi-bases
& Nbsp; Vrai
Cela signifie que KeyReferenceToPersistent souvent entraver la résolution des conflits pour les classes telles que PersistentMapping.
__cmp__ travaille moins un objet est une référence multi-bases et l'autre ne est pas. Voici quelques exemples.
& Nbsp; >>> cmp (usine (PersistentReference (
& Nbsp; ... ('un oid »,« métadonnées de classe »))),
& Nbsp; ... usine (PersistentReference (
& Nbsp; ... ('un oid »,« métadonnées de classe »))))
& Nbsp; 0
& Nbsp; >>> cmp (usine (PersistentReference (
& Nbsp; ... ('un oid »,« métadonnées de classe »))),
& Nbsp; ... usine (PersistentReference (
& Nbsp; ... ('autre oid »,« métadonnées de classe »))))
& Nbsp; -1
& Nbsp; >>> cmp (usine (PersistentReference ('un oid')),
& Nbsp; ... usine (PersistentReference (
& Nbsp; ... ('un oid »,« métadonnées de classe »))))
& Nbsp; 0
& Nbsp; >>> cmp (usine (PersistentReference ('un oid')),
& Nbsp; ... usine (PersistentReference (
& Nbsp; ... ('un oid »,« métadonnées de classe »))))
& Nbsp; 0
& Nbsp; >>> cmp (usine (PersistentReference (
& Nbsp; ... ['m', ('une base de données »,« un oid »,« métadonnées de classe »)])),
& Nbsp; ... usine (PersistentReference (
& Nbsp; ... ['m', ('une base de données »,« un oid »,« métadonnées de classe »)])))
& Nbsp; 0
& Nbsp; >>> cmp (usine (PersistentReference (
& Nbsp; ... ['m', ('une base de données »,« un oid »,« métadonnées de classe »)])),
& Nbsp; ... usine (PersistentReference (
& Nbsp; ... ['n', ('une base de données »,« un oid')])))
& Nbsp; 0
& Nbsp; >>> cmp (usine (PersistentReference (
& Nbsp; ... ['m', ('une base de données »,« un oid »,« métadonnées de classe »)])),
& Nbsp; ... usine (PersistentReference (
& Nbsp; ... ['m', ('autre base de données »,« un oid »,« métadonnées de classe »)])))
& Nbsp; -1
& Nbsp; >>> cmp (usine (PersistentReference (
& Nbsp; ... ['m', ('une base de données »,« un oid »,« métadonnées de classe »)])),
& Nbsp; ... usine (PersistentReference (
& Nbsp; ... ('un oid »,« métadonnées de classe »))))
& Nbsp; d'enquête (appel le plus récent dernière):
& Nbsp; ...
& Nbsp; ValueError: ne pouvez pas trier de manière fiable
connexion adaptateur basé sur la localisation
La fonction zope.keyreference.connectionOfPersistent adapte des objets à l'aide de connexions une heuristique de géolocalisation simple. Il vérifié pour voir si l'objet a une __parent__ qui a un lien:
& Nbsp; >>> from connectionOfPersistent d'importation zope.keyreference.persistent
& Nbsp; >>> ob3 = PersistentMapping ()
& Nbsp; >>> print connectionOfPersistent (ob3)
& Nbsp; Aucun
& Nbsp; >>> ob3 .__ parent__ = Root2 ['OB1']
& Nbsp; >>> connectionOfPersistent (ob3) est conn2
& Nbsp; Vrai

Ce qui est nouveau dans cette version:

• tests de Fix brisé par l'élimination de zope.testing des dépendances de test: éviter le module de ZODB3 qui en a besoin.

Exigences :

• Python