membres de classe private/protected (yet another try)

Salutations,

long time no see (oui oui je vais éviter l'anglais ;p), à vrai dire depuis les concours c2i diggers, ça date, salut Nix et … wazaaaaa ! ;)

Pour des raisons que je suis prêt à défendre même si ça n'est pas le sujet, j'essaye de mettre en place un mécanisme "fort" de gestion des membres de classes public/protected/private. Fort mais simple, l'idée étant que ça doit rester léger dans l'utilisation …

Après de nombreuses recherches et essais ratés, j'y suis presque, mais ça coince :(

les contraintes :
- doit passer sur toutes les versions de python à partir de la 2.5, sans tests bourrins sur du sys.version_info dans les modules (2.5, 2.6 et 2.7 en activité, 3.x à l'horizon)
- le plus léger possible dans la syntaxe pour ne pas polluer la définition des classes
- toujours pour ne pas polluer, pas de brouzouf au niveau des locales de la classe, tout doit se passer dans les accesseurs
- fonctionnement classique : public sans restriction, private réservé à la classe, protected accessible aux sous-classes
- support complet (get/set/delattr)
- respect des conventions python en cas d'inspection (simple / double underscore)

Mon approche actuelle se base sur les décorateurs qui sont en partie viables dès la 2.5 tant qu'on reste dans une utilisation simple (pas de @property / @prop.setter/deleter, pas de surcharge sale des __setattr__ __getattr__ non plus à l'inverse). Le but étant de me retrouver avec des définition de membres de ce type :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

from MClasses import public, protected, private   class MyClass(object): def __init__(self): self._pub = 42 self._prot = 42 self.__priv = 42           @public def pub(): pass           @protected def prot(): pass           @private def priv(): pass   def assign(self): self.pub = 666 self.prot = 666 self.priv = 666   class MySubClass(MyClass): pass

---

Dans ce contexte, un myclass.assign() doit marcher de bout en bout, un mysubclass.assign() doit lever une exception sur le self.priv, et une affectation de l'extérieur doit péter sur prot et priv.

Je coince pour l'instant à la récupération de la classe d'origine d'un membre dans les decorateurs, étant donné que la classe n'existe justement pas lors du chargement de la définition … j'ai tenté de créer une classe vide juste avant la "vraie" définition (class MyClass(object): pass) pour pouvoir la passer en argument (genre @public(MyClass)), mais l'id diffère (self.__class__ != MyClass), et la recherche d'héritage par issubclass/isinstance échoue, logique.

Quelques bouts de mon implémentation super naïve :

get_call_class.py, pour récupérer la classe de l'objet qui accède à un membre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

import inspect   from get_frame_class import get_frame_class   def get_call_class(depth=1): """class get_call_class(int depth=1)                                                                                                                                                                                                         Returns the current calling class at given depth (1 by default so that we get                                         the first container available)."""   # add 2 depth to avoid get_call_class and get_frame_class levels depth += 2   stack = inspect.stack() if stack and len(stack) > depth and stack[depth]: return get_frame_class(stack[depth][0])   return None

---

get_frame_class.py, pour extraire la classe à partir d'une frame :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

import inspect   def get_frame_class(obj): """class get_frame_class(frame obj)                                                                                                                                                                                                         Returns the class object for the given frame (see inspect module)."""   args, _, _, value_dict = inspect.getargvalues(obj) if len(args) and args[0] == 'self': instance = value_dict.get('self', None) if instance: return getattr(instance, '__class__', None)   return None

---

get_func_class.py pour avoir la classe de l'objet qui a défini un membre / méthode (c'est là que ça bloque ;p)

Code:

---

1 2 3 4 5 6 7 8 9 10

import inspect   def get_func_class(func): if hasattr(func, "im_class"): for cls in inspect.getmro(func.im_class): if func.__name__ in cls.__dict__: return cls   return None

---

safe_decorator.py, un décorateur central appelé par les décorateurs public/private/protected lors de la construction, merci stack overflow !

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

from get_func_class import get_func_class from safe_getattr import safe_getattr from safe_setattr import safe_setattr from safe_delattr import safe_delattr   def safe_decorator(func, scope): ops = func() or {} name = ops.get("prefix", "__" if scope == "private" else "_") + func.__name__   cls = get_func_class(func)   fget = ops.get("fget", lambda self: safe_getattr(self, name, scope, cls)) fset = ops.get("fset", lambda self, value: safe_setattr(self, name, value, scope, cls)) fdel = ops.get("fdel", lambda self: safe_delattr(self, name, scope, cls))   return property(fget, fset, fdel, ops.get("doc", ""))

---

public.py, private.py, protected.py, les surcharges de safe_decorator, passant juste un argument "scope" pour préciser dans quel cas on se trouve :

Code:

---

1 2 3 4 5 6 7 8 9

def public(func): return safe_decorator(func, "public")   def private(func): return safe_decorator(func, "private")   def protected(func): return safe_decorator(func, "protected")

---

safe_setattr.py, le setter générique (laissons de côté les safe_getattr et safe_delattr pour l'instant, il suffit de les remplacer par de simples getattr/delattr)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

from get_call_class import get_call_class   def safe_setattr(self, name, value, scope, cls): caller = get_call_class() print "SETATTR " + name + " " + str(cls) + " " + str(caller)   doit = True if scope == "private": doit = caller == cls elif scope == "protected": doit = cls and issubclass(caller, cls)   if doit: setattr(self, name, value) else: raise AttributeError(str(cls) + "." + name + " is " + scope + " !")

---

La question principale reste donc : comment récupérer la classe de définition d'un membre dans un décorateur, ou en tout cas un élément de comparaison avec la classe appelante ? Toute astuce sera la bienvenue !

La question subsidiaire : l'approche vous semble viable ? réalisable ? pythonesque ? ^^

Quoi qu'il en soit merci aux courageu(x|ses) qui auront eu le courage de lire cet horrible pavé jusqu'au bout !

Tonio

Bonjour,

functools.wraps (ou @abc.abstractmethod mais >2.6) ?

Mais bon... Tout cela me semble bien loin du 'programmeur responsable' Python.

@+

Bonjour,

Le mécanisme intégré à Python pour rendre une méthode "privée" est très simple: il suffit de préfixer son nom avec 2 blancs soulignés ('__'):

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class Test(object):   def fonctionpublique(self): pass   def __fonctionprivee(self): pass   a = Test() a.fonctionpublique() a.__fonctionprivee() # => exception: AttributeError: 'Test' object has no attribute '__fonctionprivee'

---

Toute tentative d'appel externe à la méthode "__fonctionprivee" déclenche une exception: "AttributeError: 'Test' object has no attribute '__fonctionprivee' "

C'est vrai aussi pour les variables d'instance.

Sans vouloir te freiner dans ton élan: tu es sûr que ça ne suffit pas?

Salut,

Citation:

---

Envoyé par tyrtamos

Le mécanisme intégré à Python pour rendre une méthode "privée" est très simple: il suffit de préfixer son nom avec 2 blancs soulignés ('__'): .../... C'est vrai aussi pour les variables d'instance.

---

C'est ça que j'aime bien sur ce forum... Tous les jours, j'apprends! :ccool:

A+

Pfeuh

Salut,
Joli chantier!

Citation:

---

Je coince pour l'instant à la récupération de la classe d'origine d'un membre dans les decorateurs, étant donné que la classe n'existe justement pas lors du chargement de la définition … j'ai tenté de créer une classe vide juste avant la "vraie" définition (class MyClass(object): pass) pour pouvoir la passer en argument (genre @public(MyClass)), mais l'id diffère (self.__class__ != MyClass), et la recherche d'héritage par issubclass/isinstance échoue, logique.

---

Si vous faites abstraction de la possibilité de modifier dynamiquement une classe, i.e. en restant "statique", passer par les "metaclass" pourrait être une possibilité (à explorer): les méthodes __new__ et __init__ étant appelées "avant" l'initialisation des différents attributs de la classe.

- W

Citation:

---

Envoyé par pfeuh

Salut,
C'est ça que j'aime bien sur ce forum... Tous les jours, j'apprends! :ccool:
A+
Pfeuh

---

Ce mécanisme est connu sous le nom de name mangling. Voir la partie 9.6 sur les classes : http://docs.python.org/tutorial/classes.html ^^

Citation:

---

Envoyé par Bktero

Ce mécanisme est connu sous le nom de name mangling. Voir la partie 9.6 sur les classes : http://docs.python.org/tutorial/classes.html ^^

---

Génial, y'a même une ancre sur le titre du chapitre, du coup on peut donner le lien direct:
9.6. Private Variables and Class-local References :lol:

A+

Pfeuh

Oh trop bien ! J'avais essayé de faire un lien direct, mais pas de possibilité de clic sur le titre. J'aurais du essayé le petit logo à droite ! :D

Bonjour, merci pour vos réponses, ça ouvre des perspectives !

@Patrice

L'approche par wraps ne me plait pas trop, ça impose un "wrapper de wrapper" qui si je me souviens bien sera exécuté à chaque accès, et pas seulement en substitution à la déclaration de la classe. Pour l'instant c'est un bouzin pas optimisé du tout, mais j'aimerais éviter à terme de plomber les perfs de mes classes ;)

Je ne suis pas certain de comprendre la notion de "programmeur responsable", est-ce si déplacé de vouloir mettre en place une usine pareille ?

@tyrtamos

En effet le mécanisme class.__priv -> class._classname__priv est la méthode tacite pour cacher un membre, seulement :
- ça ne permet pas de prendre la main sur les accès à ces membres, déterminer le comportement lorsqu'on tape dessus (par exemple surcharger par un @quiet pour stopper les raise).
- ça ne gère pas le cas "protected"
- l'AttributeError qui découle d'un accès est logique mais inadapté, comment faire la différence avec un "vrai" cas d'attribut absent ?

En fait ça va surtout concerner des objets "business", processés par pas mal de scripts auto, plugins maison etc., et ça me permettra donc d'intégrer ça dans les tests unitaires, vérifier régulièrement que tout roule, faire des analyses d'impact etc. C'est beaucoup plus pour de la protection "métier" que pour locker le code.

Mais je suis d'accord, dans l'immédiat il suffirait d'oublier @public (supposé ne rien faire) et @private (trivial)

@wiztricks

C'est effectivement du chantier détente bien sale, il fait trop chaud pour coder "sérieux" en ce moment ;p

L'approche est super intéressante, et viable depuis la 2.2, ça se tente. J'essaye de bricoler un update des wrappers dans le __init__ pour l'instant, pas très concluant, malgré le remplacement des property avant l'instanciation je ne retrouve pas encore mes petits, mais c'est prometteur. Le principe reste léger et limité à la déclaration des classes … sur le papier ça le fait, merci pour la piste !

Tonio

Je vous laisse lire ce post, la méthode "protected" est faisable en python.

Ce que vous demandez ressemble beaucoup à de la modification dynamique de classe et je rejoins la proposition de Wiztricks.

Mais je rejoins l'avis de Patrice, pensez python et non C++ ou java. ;)

Bonjour,

Citation:

---

comment récupérer la classe de définition d'un membre dans un décorateur

---

-> passer par les "metaclass"
-> créer la classe, puis la décorer après. Par exemple

Code:

---

1 2 3 4 5

# a le mérite d'isoler le code gérant les accès après la déf. de la classe class A: def foo(self):pass A.foo= decorator(A.foo,A)

---

Sinon, plutôt que de devoir définir une méthode décorée par attributs (je trouve la syntaxe lourde), pourquoi ne pas préciser globalement les accès en décorant la classe, par exemple

Code:

---

1 2 3

@access(private=('attribut1','method1'), protected=('attribut2','__init__')) class A: pass

---

Même si cela ne suffit pas pour définir/modifier dynamiquement des attributs protégés ; cela rend la déf de la classe plus légère si tu sais à l'avance quels attributs sont protégés.

Citation:

---

Envoyé par fred1599

Je vous laisse lire ce post, la méthode "protected" est faisable en python.

---

Malheureusement, je tente de mettre en place une méthode valable à partir de python 2.5, sans détection de version. Du coup le passage par un @property.setter ne fonctionnera pas !

Citation:

---

Envoyé par fred1599

Mais je rejoins l'avis de Patrice, pensez python et non C++ ou java. ;)

---

Les vieilles recettes ont la peau dure, quand on est habitué à certains mécanismes, mais ça m'a sauvé la mise tellement souvent ! Le python n'est pas le seul langage impliqué dans notre pipeline, du coup j'essaye de maintenir des logiques communes de l'un à l'autre, ne serait-ce que pour éviter les noeuds au cerveau ...

Je crois me souvenir d'un vieux débat PEP sur la pertinence de la gestion d'exception à outrance qui s'était soldée par la conclusion qu'il faut avoir un peu plus confiance : en soi même, en son code, et en ceux qui interviennent dessus ;)

Citation:

---

Envoyé par VV33D

-> créer la classe, puis la décorer après.

---

rah exactement l'inverse de ma minable tentative de :

Code:

---

1 2 3 4 5

class A: pass class A:     @decorator(A) def foo(self): pass

---

et moins de pollution visuelle dans la définition de la classe, ça sonne bien.

Citation:

---

Envoyé par VV33D

Sinon, plutôt que de devoir définir une méthode décorée par attributs (je trouve la syntaxe lourde), pourquoi ne pas préciser globalement les accès en décorant la classe, par exemple

Code:

---

1 2 3

@access(private= ('attribut1','method1'), protected=('attribut2','__init__') class A: pass

---

---

Je suis fan de la notation ! En effet, beaucoup plus léger, ouvert à la protection des méthodes si besoin, parfaitement clair à la lecture du code ... bon, il faut tout recommencer :mouarf:

Tonio

Citation:

---

Malheureusement, je tente de mettre en place une méthode valable à partir de python 2.5, sans détection de version. Du coup le passage par un @property.setter ne fonctionnera pas !

---

à moins d'avoir une très bonne raison (utilisation de pymedia par exemple), la version 2 tend à disparaître.

Citation:

---

bon, il faut tout recommencer

---

Ravi que mes idées te plaisent :P

par contre, avec la syntaxe "classe décorée", il reste un problème à gérer: comment rajouter dynamiquement des attributs protégés (ie. après la création de la classe ou de l'instance).

Souhaites tu une telle fonctionnalité ? Cela aurait il du sens de définir les accès relativement à l'instance, et non à la classe ? Par exemple, 2 instances différentes gérant les accès différemment, que ce soit pour les attributs ou les méthodes.

Citation:

---

Envoyé par T00N3

Je ne suis pas certain de comprendre la notion de "programmeur responsable", est-ce si déplacé de vouloir mettre en place une usine pareille ?

---

Python étant interprété quel que soit le mécanisme de protection que vous pourrez construire, le programmeur pourra toujours passer à côté.
Si vous devez avoir des protections fortes, vous devrez utiliser un langage de programmation "compilé" qui réalise des mécanismes de protection prouvés.
Entre les deux, restent les conventions usuelles... elles pourront être suivies ou pas mais elles ont le mérite d'exister et de ne pas coûter grand chose.

- W

Citation:

---

Envoyé par fred1599

à moins d'avoir une très bonne raison (utilisation de pymedia par exemple), la version 2 tend à disparaître.

---

En fait pas mal des modules déployés sur notre système sont des modules "métier", partagés par différentes applications, différents systèmes, entre autres : osx leopard (2.5), snow leopard (2.6), lion (2.7), windows (2.6), maya 2009 (2.5 custom), maya 2010+ (2.6 custom), tractor (2.6 système), nuke 6.0 (2.5 custom), nuke 6.2+ (2.6 custom) etc.

L'évolution des versions de base sur les os se fait en décalé entre les postes de travail et les serveurs (toujours plus ancien sur les serveurs, surtout osx), et de même pour les applications, sachant qu'on conserve toujours au moins deux ans de "backward compatibility" pour pouvoir ressortir des prods dans leur contexte applicatif/pipe d'origine.

Comme on est une toute petite équipe, que le noyau python n'est pas le seul sujet d'occupation, et que je me vois mal maintenir des branches du pipeline pour chaque version majeure (sans compter l'enfer pour la gestion des environnements) ... j'essaye de faire en sorte que ça passe partout !

Python 3 risque de s'imposer d'ici peu niveau os, c'est pourquoi j'essaye de l'anticiper doucement, mais on reste fortement ancré autour du 2.5 / 2.6 et ça ne risque pas de bouger tout de suite ...

Tonio

Nouvel essai, j'ai simplifié le testcase ;)

l'idée reste d'être capable de déclencher du code (par défaut une exception) lors de l'accès à certains attributs :

- pour des objets de haut niveau uniquement (pour le traitement de datas pures j'ai des structures plus adaptées quand même ...)
- dans le but d'y mettre en place une traçabilité et un système de validation des logiques qui lient ces classes on va dire
- certainement pas pour bloquer les dev ce qui de toute façon est impossible en python
- mais en gardant en tête que les niveaux sont très disparates, et que sans parler des conventions qui sont loin d'être connues de tous, plus la console d'erreur est explicite, moins il y a de questions ^^

Pour la version "décorateur de classes" VV33D, argl, dispo uniquement en python 2.6+ donc j'oublie pour l'instant ... je crois qu'il ne reste plus que l'affectation des properties à l'extérieur de la classe, quitte à faire un

Code:

---

1 2 3 4 5

class A: def foo(self): pass ... declare_attributes(A, private=("foo", "bar"), protected=("toto", "titi"))

---

Pour la curiosité j'essaye de jouer avec les metaclass mais ça n'est pas gagné, soit je comprends mal comment c'est supposé marcher, soit je fais de travers, soit les deux ;p

voici une nettoyée de toute notion de protection, juste pour le principe de passer par un setter et essayer de récupérer la classe d'origine d'un attribut :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

def safe_setattr(self, name, value, base_class): """setattr accessor, checking for base_class permissions""" print "setattr " + name + " base " + str(base_class) setattr(self, name, value)   def safe_decorator(func, base_class=None): """attributes decorator, force safe_setattr on affect"""   # add "_" to the attribute name to avoid clash with the property name = "_" + func.__name__   fget = lambda self: getattr(self, name) fset = lambda self, value: safe_setattr(self, name, value, base_class) fdel = lambda self: delattr(self, name)   # store the base function, to regenerate this decorator later fget.base_func = func   return property(fget, fset, fdel, "docstring for " + func.__name__)   def replace_props(dct, cls): """replace properties : safe_decorator with the source class of each attribute""" ret = dict() for k, v in dct.iteritems(): if type(v) == property: print "forcing base class " + str(cls) + " for " + k ret[k] = safe_decorator(v.fget.base_func, cls) else: ret[k] = v return ret   class meta(type): """meta class, should replace properties with the right class object """   def __new__(cls, name, bases, dct): print "meta __new__ named '" + name + "' class " + str(cls) # broken here, cls is __main__.meta wich is not what we're lookin for   dct = replace_props(dct, cls)   return type.__new__(cls, name, bases, dct)   def __init__(cls, name, bases, dct): print "meta __init__ named '" + name + "' class " + str(cls.__class__) # broken here, cls (self) is __main__.base_class # but properties are not replaced in created objects   # dct = replace_props(dct, cls)   super(meta, cls).__init__(name, bases, dct)   class base_class(object): __metaclass__ = meta   def __init__(self): print "base __init__" self._attr = 42       @safe_decorator def attr(): """place holder for an attribute _attr with attr() property""" pass   class sub_class(base_class): pass   if __name__ == "__main__": obj = base_class() obj.attr = 42 obj = sub_class() obj.attr = 42

---

Merci encore pour toutes vos pistes !

Tonio

Plus je lis vos posts, plus j'ai de difficultés à comprendre ce que vous souhaitez réellement faire.

Vous cherchez à modifier une classe, tout en gardant les attributs privés/protégés de cette classe?

Bonjour Fred, désolé si je suis confus, la clarté n'a jamais été mon fort ...

Je cherche à implémenter la notion de membre private/protected sur un ensemble de classes existantes, donc le plus légèrement possible, et avec les contraintes "contextuelles" listées dans le premier post. Peu importe pour moi le moyen d'y arriver, mais si c'est élégant et efficace tant mieux ;)

Pour ce faire, je dois pouvoir déterminer quelle est la classe "d'origine" d'un attribut (et pas la classe d'un objet qui en aurait hérité pour le protected), et celle de l'objet qui a cherché à le modifier, pour déterminer si l'accès est autorisé ou non.

J'ai essayé d'utiliser les décorateurs dans ce but, ça me semblait approprié et pas trop lourd en inférence, mais ça a bloqué car un décorateur ne sait absolument pas, au moment de sa construction, à quelle classe il est en train de participer ... et il est hors de question que je le détermine à l'exécution !

La proposition de wiztricks d'utiliser une metaclass pour relayer cette information (si j'ai bien compris l'idée ? :/) semblait prometteuse mais je bloque encore à la mise en oeuvre.

La solution de VV33D consistant à affecter les décorateurs après construction de la classe me semble finalement la plus jouable, et light en syntaxe et code, je pense me diriger vers ça.

Je ne suis pas sûr, car j'en ai jamais eu besoin, cela doit s'appeler de l'introspection.

Le module inspect dans ce cas pourrait vous être utile. Il existe depuis la version 2.2

Pour annoncer l'origine d'un objet, on peut créer une fonction du style

Code:

---

1 2 3 4 5 6 7

def print_class(obj, attr): try: getattr(obj, attr) print "l'attribut %s fait partie de \ la classe %s" %(attr, obj.__class__.__name__) except AttributeError: return None

---

Bonjour,

Même si la syntaxe décorateur n'existe qu'à parti de py26 (il me semblait que c'était plus vieux), rien n’empêche de l'écrire en fonctionnel:

Code:

---

1 2 3

class A: pass A= access(private= 'foo', protected= '__init__' ) (A) # décoration sans @

---

Citation:

---

Pour ce faire, je dois pouvoir déterminer quelle est la classe "d'origine" d'un attribut

---

Ca marchera pour les attributs de classe ou les méthodes, mais pour les attributs de l'instance (le __dict__), la situation sera plus compliquée car il faut déterminer à quelle classe appartient la méthode ayant crée l'attribut !

Sinon, je serais intéressé par vos réactions à cette idée:

Citation:

---

Cela aurait il du sens de définir les accès relativement à l'instance, et non à la classe ?

---

Je me suis un peu amusé avec cela. Mon idée est d'utiliser des descripteurs pour contrôler l'accès aux attributs et une méta-classe pour associer ces descripteurs avec la classe dans laquelle ils sont initialement définis.

J'ai un peu changé la spécification par rapport à ce que TOON3 voulait; mais c'est je pense plus cohérent et plus proche de ce qu'on trouve dans d'autres langages: en l'occurence, MySubClass().assign() ne lève pas d'erreur, car la méthode assign est définie dans MyClass et n'est pas redéfinie dans MySubClass. Par contre, MySubClass().bad_assign() (voir code) lève bien une erreur.

Voilà où j'en suis:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130

from functools import wraps import inspect import types   def access_wrap(f): "decorator which checks accessibility of a method by calling the access method of the object"     @wraps(f) def wrapper(self, *args): if self.access(get_lexical_call_class()): return f(self, *args) else: raise AttributeError("Scope Error") return wrapper     class safe_descriptor(object): "base class for accessibility-constrained descriptors" def __init__(self, value=None): self._value = {} # dictionary which maps instances id's to values self._default = value self._owner = None # filled-in by the metaclass       @access_wrap def __get__(self, instance, owner): val = self._value.get(id(instance), self._default) if callable(val): # if val is a function, bind it to the instance return types.MethodType(val, instance) else: return val       @access_wrap def __set__(self, instance, value): self._value[id(instance)] = value       @access_wrap def __delete__(self, instance): if id(instance) in self._value: del self._value[id(instance)]   class public(safe_descriptor): def access(self, caller): return True   class private(safe_descriptor): def access(self, caller): return caller and caller == self._owner   class protected(safe_descriptor): def access(self, caller): return caller and issubclass(caller, self._owner)     class SafeMeta(type): def __new__(cls, name, bases, attrs): kls = type.__new__(cls, name, bases, attrs) for v in attrs.values(): if isinstance(v, safe_descriptor): v._owner = kls return kls   class safe_object(object): __metaclass__ = SafeMeta     def get_lexical_call_class(depth=1): depth += 1 stack = inspect.stack() if stack and len(stack) > depth and stack[depth]: frame,_,_,name,_,_ = stack[depth] cls = get_frame_class(frame) return cls and get_definition_class(name, cls) return None   def get_frame_class(obj): args, _, _, value_dict = inspect.getargvalues(obj) if len(args) and args[0] == 'self': instance = value_dict.get('self', None) if instance: return getattr(instance, '__class__', None) return None   def get_definition_class(name, cls): for c in inspect.getmro(cls): if name in c.__dict__: return c return None     # tests if __name__ == '__main__':   class MyClass(safe_object): pub = public() prot = protected() priv = private()   def __init__(self): self.pub = 42 self.prot = 42 self.priv = 42   def assign(self): self.pub = 666 self.prot = 666 self.priv = 666           @protected def prot_method(self): return 42           @private def priv_method(self): return 666           @public def pub_method(self, n): return n + self.prot_method() + self.priv_method()   class MySubClass(MyClass): def bad_assign(self): self.pub = 666 self.prot = 666 self.priv = 666 # erreur   def pub_method(self): return self.prot_method()   def bad_method(self): return self.priv_method() #erreur

---

Les descripteurs sont utilisables pour déclarer un attribut ainsi que comme décorateurs pour les méthodes.

Mais il reste quelques problèmes. Dont au moins un gros: la méthode que j'utilise pour déterminer les accès ne fonctionnent pas si on utilise super dans une sous-classe...
Par exemple, si on ajoute ceci dans MySubClass:

Code:

---

1 2 3

def __init__(self): super(MySubClass, self).__init__() # MyClass.__init__(self) ne fonctionne pas non plus

---

un erreur est levée alors que cela ne devrait pas être le cas.
Je n'ai pas non plus tenu compte du cas des méthodes de classes ou des méthodes statiques...