Как написать метакласс, который предотвратит создание новых атрибутов после __init __()?

Question

В настоящее время я переопределять класс __setattr__() в конце класса метод __init__(), чтобы предотвратить новое создание атрибута -

class Point(object): 
    def __init__(self): 
     self.x = 0 
     self.y = 0 
     Point.__setattr__ = self._setattr 

    def _setattr(self, name, value): 
     if not hasattr(self, name): 
      raise AttributeError("'" + name + "' not an attribute of Point object.") 
     else: 
      super(Point, self).__setattr__(name, value) 

Есть ли способ, чтобы избежать вручную перекрывая __setattr__() и сделать это автоматически с помощью метаклассов?

Ближайший я пришел был -

class attr_block_meta(type): 
    def __new__(meta, cname, bases, dctry): 
     def _setattr(self, name, value): 
      if not hasattr(self, name): 
       raise AttributeError("'" + name + "' not an attribute of " + cname + " object.") 
      object.__setattr__(self, name, value) 

     dctry.update({'x': 0, 'y': 0}) 
     cls = type.__new__(meta, cname, bases, dctry) 
     cls.__setattr__ = _setattr 
     return cls 

class ImPoint(object): 
    __metaclass__ = attr_block_meta 

Есть более общий способ сделать это, например, что априорное знание подкласса атрибутов не требуется?
В принципе, как избежать строки dctry.update({'x': 0, 'y': 0}) и сделать эту работу независимо от того, что такое имена атрибутов класса?

P.S. - FWIW Я уже оценил параметры __slots__ и namedtuple и нашел их в недостатке для моих нужд. Пожалуйста, не сузите свой фокус к рассмотренным пунктам(), которые я использовал для иллюстрации вопроса; фактический прецедент предполагает гораздо более сложный класс.

Answer 1

Будет ли это иметь смысл для вашего дела?

from functools import wraps 

class attr_block_meta(type): 
    def __new__(meta, cname, bases, dctry): 
     def _setattr(self, name, value): 
      if not hasattr(self, name): 
       raise AttributeError("'" + name + "' not an attibute of " + cname + " object.") 
      object.__setattr__(self, name, value) 

     def override_setattr_after(fn): 
      @wraps(fn) 
      def _wrapper(*args, **kwargs): 
       cls.__setattr__ = object.__setattr__ 
       fn(*args, **kwargs) 
       cls.__setattr__ = _setattr 
      return _wrapper 

     cls = type.__new__(meta, cname, bases, dctry) 
     cls.__init__ = override_setattr_after(cls.__init__) 
     return cls 


class ImPoint(object): 
    __metaclass__ = attr_block_meta 
    def __init__(self, q, z): 
     self.q = q 
     self.z = z 

point = ImPoint(1, 2) 
print point.q, point.z 
point.w = 3 # Raises AttributeError 

See this for more details on 'wraps'.

Вы, вероятно, нужно доделать немного больше с ним, чтобы получить его более изящным, но общая идея состоит в том, чтобы переопределить __setattr__ только после инициализации называется.

Сказав, что общий подход к этому просто использовать object.__setattr__(self, field, value) внутренне обойти AttributeError:

class attr_block_meta(type): 
    def __new__(meta, cname, bases, dctry): 
     def _setattr(self, name, value): 
      if not hasattr(self, name): 
       raise AttributeError("'" + name + "' not an attibute of " + cname + " object.") 
      object.__setattr__(self, name, value) 

     cls = type.__new__(meta, cname, bases, dctry) 
     cls.__setattr__ = _setattr 
     return cls 


class ImPoint(object): 
    __metaclass__ = attr_block_meta 
    def __init__(self, q, z): 
     object.__setattr__(self, 'q', q) 
     object.__setattr__(self, 'z', z) 

point = ImPoint(1, 2) 
print point.q, point.z 
point.w = 3 # Raises AttributeError 

Answer 2

Не изобретайте велосипед.

Два простых способов достижения этой цели (без непосредственного использования метакласса) используют:

1. namedtuple с
2. __slots__

Например, при использовании namedtuple (на основании, например, в документы):

Point = namedtuple('Point', ['x', 'y']) 
p = Point(11, 22) 
p.z = 33 # ERROR 

, например, с помощью __slots__:

class Point(object): 
    __slots__ = ['x', 'y'] 
    def __init__(self, x=0, y=0): 
     self.x = x 
     self.y = y 

p = Point(11,22) 
p.z = 33 # ERROR 

Answer 3

Вам не нужно метаклассами решать такого рода проблемы.

Если вы хотите создать данные раньше, а затем, чтобы они были неизменными, я определенно использовал бы namedtuple, как предлагает shx2.

В противном случае просто определите набор допустимых полей в классе и отметьте __setattr__, чтобы узнать, находится ли имя, которое вы пытаетесь установить, в коллекции разрешенных полей. Вам не нужно изменять реализацию __setattr__ частичным способом через __init__ - он будет работать во время __init__, точно так же, как он будет работать позже. Используйте tuple или frozenset как структуру данных для разрешенных полей, если вы хотите отказать в изменении или изменении их в данном классе.

class Point(object): 
    _allowed_attrs = ("x", "y") 

    def __init__(self, x, y): 
     self.x = x 
     self.y = y 

    def __setattr__(self, name, value): 
     if name not in self._allowed_attrs: 
      raise AttributeError(
       "Cannot set attribute {!r} on type {}".format(
        name, self.__class__.__name__)) 
     super(Point, self).__setattr__(name, value) 

p = Point(5, 10) 
p.x = 9 
p.y = "some string" 
p.z = 11 # raises AttributeError 

Это может быть легко вынесен в базовый класс для повторного использования:

class RestrictedAttributesObject(object): 
    _allowed_attrs =() 

    def __setattr__(self, name, value): 
     if name not in self._allowed_attrs: 
      raise AttributeError(
       "Cannot set attribute {!r} on type {}".format(
        name, self.__class__.__name__)) 
     super(RestrictedAttributesObject, self).__setattr__(name, value) 

class Point(RestrictedAttributesObject): 
    _allowed_attrs = ("x", "y") 

    def __init__(self, x, y): 
     self.x = x 
     self.y = y 

Я не думаю, что это будет считаться вещим заблокировать допустимые атрибуты объект таким образом, и это вызовет некоторое усложнение для подклассов, которым нужны дополнительные атрибуты (подкласс должен гарантировать, что поле _allowed_attrs имеет соответствующее ему содержимое).

Answer 4

У меня есть эта же потребность (для развития быстрой хак API). Я не использую метаклассами для этого, только наследование:

class LockedObject(object): 
    def __setattr__(self, name, value): 
     if name == "_locked": 
      object.__setattr__(self, name, value) 
      return 

     if hasattr(self, "_locked"): 
      if not self._locked or hasattr(self, name): 
       object.__setattr__(self, name, value) 
      else: 
       raise NameError("Not allowed to create new attribute {} in locked object".format(name)) 
     else: # never called _lock(), so go on 
      object.__setattr__(self, name, value) 

    def _lock(self): 
     self._locked = True 

    def _unlock(self): 
     self._locked = False 

Тогда:

class Base(LockedObject): 
    def __init__(self): 
     self.a = 0 
     self.b = 1 
     self._lock() 

Если мне нужно создать подкласс Base и добавить дополнительные атрибуты я использую разблокировать:

class Child(Base): 
    def __init__(self): 
     Base.__init__(self) 
     self._unlock() 
     self.c = 2 
     self._lock() 

Если База абстрактная, вы можете пропустить ее блокировку и просто заблокировать дочерние элементы. У меня есть некоторые unittests, которые проверяют, что каждый открытый класс заблокирован после init, чтобы поймать меня, если я забуду замок.