[PYTHON] decoratori per permessi agli attributi di una classe

[postgres]

Qualcuno sa come si possa attraverso i decoratori definire permessi di lettura (r), scrittura (w) ed entrambri (rw) agli attributi di una classe?

è un esercizio di università.

Il main è questo:



traceMe = False
def trace(*args):
if traceMe: print('[' + ' '.join(map(str, args)) + ']')
def private(*privates): # privates in enclosing scope
def onDecorator(aClass): # aClass in enclosing scope
class onInstance: # wrapped in instance attribute
def __init__(self, *args, **kargs):
self.wrapped = aClass(*args, **kargs)
def __getattr__(self, attr): # My attrs don’t call getattr
trace('get:', attr) # Others assumed in wrapped
if attr in privates:
raise TypeError('private attribute fetch: ' + attr)
else:
return getattr(self.wrapped, attr)
def __setattr__(self, attr, value): # Outside accesses
trace('set:', attr, value) # Others run normally
if attr == 'wrapped': # Allow my attrs
self.__dict__[attr] = value # Avoid looping
elif attr in privates:
raise TypeError('private attribute change: ' + attr)
else:
setattr(self.wrapped, attr, value) # Wrapped obj attrs
return onInstance # Or use __dict__
return onDecorator

from selectors import *
@private('data', 'size', 'label')
@rw(’data’)
@r(’size’)
@w(’label’)
class D:
def __init__(self, label, start):
self.label = label
self.data = start
self.size = len(self.data)
def double(self):
for i in range(self.size):
self.data[i] = self.data[i] * 2
def display(self):
print(’{0} => {1}’.format(self.label, self.data))
if __name__ == "__main__":
X = D(’X is’, [1, 2, 3])
X.display(); X.double(); X.display()
try:
print(X.size)
except Exception as e: print("{0}: {1}".format(type(e).__name__, e))
try:
print(X.data)
except Exception as e: print("{0}: {1}".format(type(e).__name__, e))
print(X.getData())
X.setData([25])
print(X.getSize())
try:
X.setSize(25)
except Exception as e: print("{0}: {1}".format(type(e).__name__, e))
try:
print(X.getLabel())
except Exception as e: print("{0}: {1}".format(type(e).__name__, e))
X.setLabel(’It has worked!!!’)
X.display()


private rende privati gli attributi.

La stampa è questa:

X is
X is => [1, 2, 3]
X is => [2, 4, 6]
TypeError: private attribute fetch: size
TypeError: private attribute fetch: data
[2, 4, 6]
1
Error: setter inexistent: setSize
Error: getter inexistent: getLabel
It has worked!!! => [25]


Forse vanno usati i setattr e i getattr come in private?
Ho provato così ma non funziona:

def r(*r):
def onDecorator(aClass):
class onInstance:
def __init__(self, *args, **kargs):
self.wrapped = aClass(*args, **kargs)
def getdata(self, attr):
#trace('get:', attr)
if attr in rw:
raise TypeError('getter inexistent: getsize: ' + attr)
else:
return getattr(self.wrapped, attr)
return onInstance # Or use __dict__
return onDecorator

e anche così:

traceMe = False
def trace(*args):
if traceMe: print('[' + ' '.join(map(str, args)) + ']')
def r(*r): # privates in enclosing scope
def onDecorator(aClass):
class onInstance:
def __init__(self, *args, **kargs):
self.wrapped = aClass(*args, **kargs)
def __getattr__(self, attr):
trace('get:', attr)
if attr in pr:
raise TypeError('private attribute fetch: ' + attr)
else:
return getattr(self.wrapped, attr)
def __setattr__(self, attr, value): # Outside accesses
trace('set:', attr, value) # Others run normally
if attr == 'wrapped': # Allow my attrs
self.__dict__[attr] = value # Avoid looping
elif attr in privates:
raise TypeError('private attribute change: ' + attr)
else:
setattr(self.wrapped, attr, value)
return onInstance
return onDecorator

[cdimauro]

L'idea dei decoratori è senz'altro corretta, come pure quella di intercettare i metodi speciali __getattr__ e __setattr__.

Comunque sistema un po' il codice iniziale, perché senza l'indentazione corretta in Python è illeggibile.

[postgres]

si scusa è vero non me ne sono accorto. Ecco la seconda parte indentata


@private('data', 'size', 'label')
#@rw('data')
@r('size')
#@w('label')

class D:
def __init__(self, label, start):
self.label = label
self.data = start
self.size = len(self.data)

def double(self):
for i in range(self.size):
self.data[i] = self.data[i] * 2
def display(self):
print('{0} => {1}'.format(self.label, self.data))


'''
X is
X is => [1, 2, 3]
X is => [2, 4, 6]
TypeError: private attribute fetch: size
TypeError: private attribute fetch: data
[2, 4, 6]
1
Error: setter inexistent: setSize
Error: getter inexistent: getLabel
It has worked!!! => [25]
'''

if __name__ == "__main__":
X = D('X is', [1, 2, 3])
#X.display(); X.double(); X.display()
try:
print(X.size)
except Exception as e: print("{0}: {1}".format(type(e).__name__, e))
try:
print(X.data)
except Exception as e: print("{0}: {1}".format(type(e).__name__, e))
print(X.getData())
X.setData([25])
print(X.getSize())
try:
X.setSize(25)
except Exception as e: print("{0}: {1}".format(type(e).__name__, e))
try:
print(X.getLabel())
except Exception as e: print("{0}: {1}".format(type(e).__name__, e))
X.setLabel('It has worked!!!')
X.display()

[cdimauro]

Questo è un più complicato e mi richiede più tempo per l'analisi del codice e fare qualche prova.

Soltanto un paio di cose:
from selectors import *
Questo immagino sia il modulo dove sono memorizzati gli altri 3 decoratori (r, w, rw).

Poi cosa intendi esattamente per attributo "privato"? Uno che sia accessibile soltanto tramite un metodo definito all'interno della classe stessa?

Giusto per essere chiari, supponendo che x sia definito come attributo privato:
class c:

def __init__(self):
self.x = 'OK'

def Prova(self):
print self.x

i = c()

i.Prova() # Stampa OK, perché x è accessibile dall'interno della classe

i.x # Genera un errore, perché non ci si deve poter accedere dall'esterno