Описание интерфейсов из пакета zope.interface

Объявление реализуемых интерфейсов

Наиболее часто используемый путь для объявления интерфейсов - это использование функции implements в определении класса:

>>> class Foo:
...     zope.interface.implements(IFoo)
...
...     def __init__(self, x=None):
...         self.x = x
...
...     def bar(self, q, r=None):
...         return q, r, self.x
...
...     def __repr__(self):
...         return "Foo(%s)" % self.x

В этом примере мы объявили, что Foo реализует IFoo. Это значит, что экземпляры Foo предоставляют IFoo. После данного объявления есть несколько путей для анализа объявлений. Во-первых мы можем спросить что интерфейс реализован классом:

>>> IFoo.implementedBy(Foo)
True

Также мы можем спросить если интерфейс предоставляется объектами класса:

>>> foo = Foo()
>>> IFoo.providedBy(foo)
True

Конечно Foo не предоставляет IFoo, он реализует его:

>>> IFoo.providedBy(Foo)
False

Мы можем также узнать какие интерфейсы реализуются объектами:

>>> list(zope.interface.implementedBy(Foo))
[<InterfaceClass __main__.IFoo>]

Это ошибка спрашивать про интерфейсы реализуемые не вызываемым объектом:

>>> IFoo.implementedBy(foo)
Traceback (most recent call last):
...
TypeError: ('ImplementedBy called for non-factory', Foo(None))

>>> list(zope.interface.implementedBy(foo))
Traceback (most recent call last):
...
TypeError: ('ImplementedBy called for non-factory', Foo(None))

Также можно узнать какие интерфейсы предоставляются объектами:

>>> list(zope.interface.providedBy(foo))
[<InterfaceClass __main__.IFoo>]
>>> list(zope.interface.providedBy(Foo))
[]

Мы можем объявить интерфейсы реализуемые другими фабриками (кроме классов). Это можно сделать используя декоратор implementer (в стиле Python 2.4). Для версий Python ниже 2.4 это будет выглядеть следующим образом:

>>> def yfoo(y):
...     foo = Foo()
...     foo.y = y
...     return foo
>>> yfoo = zope.interface.implementer(IFoo)(yfoo)

>>> list(zope.interface.implementedBy(yfoo))
[<InterfaceClass __main__.IFoo>]

Надо заметить, что декоратор implementer может модифицировать свои аргументы. Вызывающая сторона не должна предполагать, что всегда будет создаваться новый объект.

Также надо отметить, что как минимум сейчас implementer не может использоваться для классов:

>>> zope.interface.implementer(IFoo)(Foo)
... # doctest: +NORMALIZE_WHITESPACE
Traceback (most recent call last):
  ...
TypeError: Can't use implementer with classes.
Use one of the class-declaration functions instead.

Объявление предоставляемых интерфейсов

Мы можем объявлять интерфейсы напрямую предоставляемые объектами. Предположим что мы хотим документировать что делает метод __init__ класса Foo. Это точно не часть IFoo. Обычно мы не должны напрямую вызывать метод __init__ для экземпляров Foo. Скорее метод __init__ является частью метода __call__ класса Foo:

>>> class IFooFactory(zope.interface.Interface):
...     """Create foos"""
...
...     def __call__(x=None):
...         """Create a foo
...
...         The argument provides the initial value for x ...
...         """

У нас есть класс предоставляющий данный интерфейс, таким образом мы можем объявить интерфейс класса:

>>> zope.interface.directlyProvides(Foo, IFooFactory)

Теперь мы видим, что Foo уже предоставляет интерфейсы:

>>> list(zope.interface.providedBy(Foo))
[<InterfaceClass __main__.IFooFactory>]
>>> IFooFactory.providedBy(Foo)
True

Объявление интерфейсов класса достаточно частая операция и для нее есть специальная функция объявления classProvides, которая позволяет объявлять интерфейсы при определении класса:

>>> class Foo2:
...     zope.interface.implements(IFoo)
...     zope.interface.classProvides(IFooFactory)
...
...     def __init__(self, x=None):
...         self.x = x
...
...     def bar(self, q, r=None):
...         return q, r, self.x
...
...     def __repr__(self):
...         return "Foo(%s)" % self.x

>>> list(zope.interface.providedBy(Foo2))
[<InterfaceClass __main__.IFooFactory>]
>>> IFooFactory.providedBy(Foo2)
True

Похожая функция moduleProvides поддерживает объявление интерфейсов при определении модуля. Для примера смотрите использование вызова moduleProvides в zope.interface.__init__, который объявляет, что пакет zope.interface предоставляет IInterfaceDeclaration.

Иногда мы хотим объявить интерфейсы экземпляров, даже если эти экземпляры уже берут интерфейсы от своих классов. Предположим, что мы создаем новый интерфейс ISpecial:

>>> class ISpecial(zope.interface.Interface):
...     reason = zope.interface.Attribute("Reason why we're special")
...     def brag():
...         "Brag about being special"

Мы можем сделать созданный экземпляр foo специальным предоставив атрибуты reason и brag:

>>> foo.reason = 'I just am'
>>> def brag():
...      return "I'm special!"
>>> foo.brag = brag
>>> foo.reason
'I just am'
>>> foo.brag()
"I'm special!"

и объявив интерфейс:

>>> zope.interface.directlyProvides(foo, ISpecial)

таким образом новый интерфейс включается в список предоставляемых интерфейсов:

>>> ISpecial.providedBy(foo)
True
>>> list(zope.interface.providedBy(foo))
[<InterfaceClass __main__.ISpecial>, <InterfaceClass __main__.IFoo>]

Мы также можем определить, что интерфейсы напрямую предоставляются объектами:

>>> list(zope.interface.directlyProvidedBy(foo))
[<InterfaceClass __main__.ISpecial>]

>>> newfoo = Foo()
>>> list(zope.interface.directlyProvidedBy(newfoo))
[]

Наследуемые объявления

Обычно объявления наследуются:

>>> class SpecialFoo(Foo):
...     zope.interface.implements(ISpecial)
...     reason = 'I just am'
...     def brag(self):
...         return "I'm special because %s" % self.reason

>>> list(zope.interface.implementedBy(SpecialFoo))
[<InterfaceClass __main__.ISpecial>, <InterfaceClass __main__.IFoo>]

>>> list(zope.interface.providedBy(SpecialFoo()))
[<InterfaceClass __main__.ISpecial>, <InterfaceClass __main__.IFoo>]

Иногда мы не хотим наследовать объявления. В этом случае мы можем использовать implementsOnly вместо implements:

>>> class Special(Foo):
...     zope.interface.implementsOnly(ISpecial)
...     reason = 'I just am'
...     def brag(self):
...         return "I'm special because %s" % self.reason

>>> list(zope.interface.implementedBy(Special))
[<InterfaceClass __main__.ISpecial>]

>>> list(zope.interface.providedBy(Special()))
[<InterfaceClass __main__.ISpecial>]

Внешние объявления

Обычно мы создаем объявления реализации как часть объявления класса. Иногда мы можем захотеть создать объявления вне объявления класса. Для примера, мы можем хотеть объявить интерфейсы для классов которые писали не мы. Для этого может использоваться функция classImplements:

>>> class C:
...     pass

>>> zope.interface.classImplements(C, IFoo)
>>> list(zope.interface.implementedBy(C))
[<InterfaceClass __main__.IFoo>]

Мы можем использовать classImplementsOnly для исключения наследуемых интерфейсов:

>>> class C(Foo):
...     pass

>>> zope.interface.classImplementsOnly(C, ISpecial)
>>> list(zope.interface.implementedBy(C))
[<InterfaceClass __main__.ISpecial>]

Объекты объявлений

Когда мы объявляем интерфейсы мы создаем объект объявления. Когда мы запрашиваем объявления возвращается объект объявления:

>>> type(zope.interface.implementedBy(Special))
<class 'zope.interface.declarations.Implements'>

Объекты объявления и объекты интерфейсов во многом похожи друг на друга. На самом деле они даже имеют общий базовый класс. Важно понять, что они могут использоваться там где в объявлениях ожидаются интерфейсы. Вот простой пример:

>>> class Special2(Foo):
...     zope.interface.implementsOnly(
...          zope.interface.implementedBy(Foo),
...          ISpecial,
...          )
...     reason = 'I just am'
...     def brag(self):
...         return "I'm special because %s" % self.reason

Объявление здесь практически такое же как zope.interface.implements(ISpecial), отличие только в порядке интерфейсов в итоговом объявления:

>>> list(zope.interface.implementedBy(Special2))
[<InterfaceClass __main__.IFoo>, <InterfaceClass __main__.ISpecial>]

Наследование в случае определения атрибутов

Интерфейс может переопределять определения атрибутов из базовых интерфейсов. Если два базовых интерфейса определяют один и тот же атрибут атрибут наследуется от более специфичного интерфейса. Для примера:

>>> class IBase(zope.interface.Interface):
...
...     def foo():
...         "base foo doc"

>>> class IBase1(IBase):
...     pass

>>> class IBase2(IBase):
...
...     def foo():
...         "base2 foo doc"

>>> class ISub(IBase1, IBase2):
...     pass

Определение ISub для foo будет из IBase2 т.к. IBase2 более специфичен для IBase:

>>> ISub['foo'].__doc__
'base2 foo doc'

Заметим, что это отличается от поиска в глубину.

Иногда полезно узнать, что интерфейс определяет атрибут напрямую. Мы можем использовать метод direct для получения напрямую определенных атрибутов:

>>> IBase.direct('foo').__doc__
'base foo doc'

>>> ISub.direct('foo')

Спецификации

Интерфейсы и объявления - это специальные случаи спецификаций. Описание выше для наследования интерфейсов можно применить и к объявлениям и к спецификациям. Объявления фактически расширяют интерфейсы которые они объявляют:

>>> class Baz:
...     zope.interface.implements(IBaz)

>>> baz_implements = zope.interface.implementedBy(Baz)
>>> baz_implements.__bases__
(<InterfaceClass __main__.IBaz>,)

>>> baz_implements.extends(IFoo)
True

>>> baz_implements.isOrExtends(IFoo)
True
>>> baz_implements.isOrExtends(baz_implements)
True

Спецификации (интерфейсы и объявления) предоставляют атрибут __sro__ который описывает спецификацию и всех ее предков:

>>> baz_implements.__sro__
(<implementedBy __main__.Baz>,
 <InterfaceClass __main__.IBaz>,
 <InterfaceClass __main__.IFoo>,
 <InterfaceClass __main__.IBlat>,
 <InterfaceClass zope.interface.Interface>)

__adapt__

>>> class I(zope.interface.Interface):
...     pass

Интерфейсы реализуют метод __adapt__ из PEP 246. Этот метод обычно не вызывается напрямую. Он вызывается архитектурой адаптации из PEP 246 и методом __call__ интерфейсов. Метод адаптации отвечает за адаптацию объекта к получателю. Версия по умолчанию возвращает None:

>>> I.__adapt__(0)

если только переданный объект не предоставляет нужный интерфейс:

>>> class C(object):
...     zope.interface.implements(I)

>>> obj = C()
>>> I.__adapt__(obj) is obj
True

Функции для вызова адаптации могут быть добавлены (или удалены) для предоставления адаптации "на заказ". Мы установим глупую функцию которая адаптирует 0 к 42. Мы устанавливаем функцию просто добавляя ее к списку adapter_hooks:

>>> from zope.interface.interface import adapter_hooks
>>> def adapt_0_to_42(iface, obj):
...     if obj == 0:
...         return 42

>>> adapter_hooks.append(adapt_0_to_42)
>>> I.__adapt__(0)
42

Функции должны возвращать либо адаптер, либо None если адаптер не найден. Функции могут быть удалены удалением их из списка:

>>> adapter_hooks.remove(adapt_0_to_42)
>>> I.__adapt__(0)