管道工 1.7

交互 - finalize、管道声明和基类

在代码中。

>>> from plumber import finalize

>>> class Behavior1(Behavior):
...     N = finalize('Behavior1')
...

>>> class Behavior2(Behavior):
...     M = finalize('Behavior2')

>>> class Base(object):
...     K = 'Base'

>>> @plumbing(Behavior1, Behavior2)
... class Plumbing(Base):
...     L = 'Plumbing'

>>> for x in ['K', 'L', 'M', 'N']:
...     print('%s from %s' % (x, getattr(Plumbing, x)))
K from Base
L from Plumbing
M from Behavior2
N from Behavior1

总结

• K-Q: 由行为、管道类和基类定义的属性

• f: finalize 声明

• x: 管道类或基类上的声明

• ?: 基类声明不相关

• Y: 选定的端点

• 冲突: 表示无效的组合，将引发 PlumbingCollision

冲突。

>>> class Behavior1(Behavior):
...     O = finalize(False)

>>> @plumbing(Behavior1)
... class Plumbing(object):
...     O = True
Traceback (most recent call last):
  ...
plumber.exceptions.PlumbingCollision:
    Plumbing class
  with:
    <finalize 'O' of <class 'Behavior1'> payload=False>

>>> class Behavior2(Behavior):
...     P = finalize(False)

>>> @plumbing(Behavior2)
... class Plumbing(object):
...     P = True
Traceback (most recent call last):
  ...
plumber.exceptions.PlumbingCollision:
    Plumbing class
  with:
    <finalize 'P' of <class 'Behavior2'> payload=False>

>>> class Behavior1(Behavior):
...     Q = finalize(False)

>>> class Behavior2(Behavior):
...     Q = finalize(True)

>>> @plumbing(Behavior1, Behavior2)
... class Plumbing(object):
...     pass
Traceback (most recent call last):
  ...
plumber.exceptions.PlumbingCollision:
    <finalize 'Q' of <class 'Behavior1'> payload=False>
  with:
    <finalize 'Q' of <class 'Behavior2'> payload=True>

交互 - override、管道声明和基类

在代码中。

>>> from plumber import override

>>> class Behavior1(Behavior):
...     K = override('Behavior1')
...     M = override('Behavior1')

>>> class Behavior2(Behavior):
...     K = override('Behavior2')
...     L = override('Behavior2')
...     M = override('Behavior2')

>>> class Base(object):
...     K = 'Base'
...     L = 'Base'
...     M = 'Base'

>>> @plumbing(Behavior1, Behavior2)
... class Plumbing(Base):
...     K = 'Plumbing'

>>> for x in ['K', 'L', 'M']:
...     print('%s from %s' % (x, getattr(Plumbing, x)))
K from Plumbing
L from Behavior2
M from Behavior1

总结

• K-M: 由行为、管道类和基类定义的属性

• e: override 声明

• x: 管道类或基类上的声明

• ?: 基类声明不相关

• Y: 选定的端点

交互 - default、管道声明和基类

在代码中。

>>> class Behavior1(Behavior):
...     N = default('Behavior1')

>>> class Behavior2(Behavior):
...     K = default('Behavior2')
...     L = default('Behavior2')
...     M = default('Behavior2')
...     N = default('Behavior2')

>>> class Base(object):
...     K = 'Base'
...     L = 'Base'

>>> @plumbing(Behavior1, Behavior2)
... class Plumbing(Base):
...     L = 'Plumbing'

>>> for x in ['K', 'L', 'M', 'N']:
...     print('%s from %s' % (x, getattr(Plumbing, x)))
K from Base
L from Plumbing
M from Behavior2
N from Behavior1

总结

• K-N: 由行为、管道类和基类定义的属性

• d = default 声明

• x = 管道类或基类上的声明

• ? = 基类声明不相关

• Y = 选定的端点

交互 - finalize 优于 override

在代码中。

>>> class Behavior1(Behavior):
...     K = override('Behavior1')
...     L = finalize('Behavior1')

>>> class Behavior2(Behavior):
...     K = finalize('Behavior2')
...     L = override('Behavior2')

>>> class Base(object):
...     K = 'Base'
...     L = 'Base'

>>> @plumbing(Behavior1, Behavior2)
... class Plumbing(Base):
...     pass

>>> for x in ['K', 'L']:
...     print('%s from %s' % (x, getattr(Plumbing, x)))
K from Behavior2
L from Behavior1

总结

• K-L: 由行为、管道类和基类定义的属性

• e = override 声明

• f = finalize 声明

• ? = 基类声明不相关

• Y = 选定的端点

交互 - finalize 优于 default

在代码中。

>>> class Behavior1(Behavior):
...     K = default('Behavior1')
...     L = finalize('Behavior1')

>>> class Behavior2(Behavior):
...     K = finalize('Behavior2')
...     L = default('Behavior2')

>>> class Base(object):
...     K = 'Base'
...     L = 'Base'

>>> @plumbing(Behavior1, Behavior2)
... class Plumbing(Base):
...     pass

>>> for x in ['K', 'L']:
...     print('%s from %s' % (x, getattr(Plumbing, x)))
K from Behavior2
L from Behavior1

总结

• K-L: 由行为、管道类和基类定义的属性

• d = default 声明

• f = finalize 声明

• ? = 基类声明不相关

• Y = 选定的端点

交互 - override 胜过 default ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+~~~~~~~~~~~~~

在代码中。

>>> class Behavior1(Behavior):
...     K = default('Behavior1')
...     L = override('Behavior1')

>>> class Behavior2(Behavior):
...     K = override('Behavior2')
...     L = default('Behavior2')

>>> class Base(object):
...     K = 'Base'
...     L = 'Base'

>>> @plumbing(Behavior1, Behavior2)
... class Plumbing(Base):
...     pass

>>> for x in ['K', 'L']:
...     print('%s from %s' % (x, getattr(Plumbing, x)))
K from Behavior2
L from Behavior1

总结

• K-L: 由行为、管道类和基类定义的属性

• d = default 声明

• e = override 声明

• ? = 基类声明不相关

• Y = 选定的端点

子类化行为

在代码中。

>>> class Behavior1(Behavior):
...     J = default('Behavior1')
...     K = default('Behavior1')
...     M = override('Behavior1')

>>> class Behavior2(Behavior1):
...     J = default('Behavior2') # overrides ``J`` of ``Behavior1``
...     L = default('Behavior2')
...     M = default('Behavior2') # this one wins, even if ``M`` on
...                              # superclass is ``override`` instruction.
...                              # due to ordinary inheritance behavior.

>>> @plumbing(Behavior2)
... class Plumbing(object):
...     pass

>>> plb = Plumbing()
>>> plb.J
'Behavior2'

>>> plb.K
'Behavior1'

>>> plb.L
'Behavior2'

>>> plb.M
'Behavior2'

一般管道

使用 plumb 和 plumbifexists 装饰器声明管道管道的元素

plumb

标记一个方法作为管道管道的行为使用。此类管道方法的签名是 def foo(next_, self, *args, **kw)。通过 next_ 它传递下一个要调用的管道方法。 self 是管道类的实例，而不是行为。

plumbifexists

类似于 plumb，但仅在存在端点时使用。

管道类用户不知道应该传递哪个next_。因此，在构建完管道后，为每个管道生成一个入口方法，该方法将第一个管道方法作为参数传递正确的next_。每个next_方法都是管道其余部分的入口。

管道按照行为顺序构建，跳过未定义具有相同属性名的管道元素的行为了。

+---+-----------+-----------+-----------+----------+
|   | Behavior1 | Behavior2 | Behavior3 | ENDPOINT |
+---+-----------+-----------+-----------+----------+
|   |      --------------------------------->      |
| E |     x     |           |           |    x     |
| N |      <---------------------------------      |
+ T +-----------+-----------+-----------+----------+
| R |      ----------> --------------------->      |
| A |     y     |     y     |           |    y     |
| N |      <---------- <---------------------      |
+ C +-----------+-----------+-----------+----------+
| E |           |           |      --------->      |
| S |           |           |     z     |    z     |
|   |           |           |      <---------      |
+---+-----------+-----------+-----------+----------+

方法管道

两个管道行为和一个dict作为基类。Behavior1在传递之前将键转换为小写，Behavior2在返回结果之前将它们相乘。

>>> from plumber import plumb

>>> class Behavior1(Behavior):
...     @plumb
...     def __getitem__(next_, self, key):
...         print('Behavior1 start')
...         key = key.lower()
...         ret = next_(self, key)
...         print ('Behavior1 stop')
...         return ret

>>> class Behavior2(Behavior):
...     @plumb
...     def __getitem__(next_, self, key):
...         print('Behavior2 start')
...         ret = 2 * next_(self, key)
...         print('Behavior2 stop')
...         return ret

>>> Base = dict

>>> @plumbing(Behavior1, Behavior2)
... class Plumbing(Base):
...     pass

>>> plb = Plumbing()
>>> plb['abc'] = 6
>>> plb['AbC']
Behavior1 start
Behavior2 start
Behavior2 stop
Behavior1 stop
12

管道管道需要端点。如果没有端点，则会引发AttributeError。

>>> class Behavior1(Behavior):
...     @plumb
...     def foo(next_, self):
...         pass

>>> @plumbing(Behavior1)
... class Plumbing(object):
...     pass
Traceback (most recent call last):
  ...
AttributeError: type object 'Plumbing' has no attribute 'foo'

如果没有端点并且行为不关心这一点，可以使用plumbifexists来仅在端点可用时进行管道连接。

>>> from plumber import plumbifexists

>>> class Behavior1(Behavior):
...     @plumbifexists
...     def foo(next_, self):
...         pass
...
...     @plumbifexists
...     def bar(next_, self):
...         return 2 * next_(self)

>>> @plumbing(Behavior1)
... class Plumbing(object):
...
...     def bar(self):
...         return 6

>>> hasattr(Plumbing, 'foo')
False
>>> Plumbing().bar()
12

这允许一种行为实现，例如为字典发送事件，用于实现__getitem__和__setitem__的读写字典以及仅实现__getitem__而不实现__setitem__的只读字典。

属性管道

只读属性的管道。

>>> class Behavior1(Behavior):
...     @plumb
...     @property
...     def foo(next_, self):
...         return 2 * next_(self)

>>> @plumbing(Behavior1)
... class Plumbing(object):
...
...     @property
...     def foo(self):
...         return 3

>>> plb = Plumbing()
>>> plb.foo
6

可以扩展属性，以设置尚未设置的getter/setter/deleter。

>>> class Behavior1(Behavior):
...     @plumb
...     @property
...     def foo(next_, self):
...         return 2 * next_(self)

>>> class Behavior2(Behavior):
...     def set_foo(self, value):
...         self._foo = value
...     foo = plumb(property(
...         None,
...         override(set_foo),
...         ))

>>> @plumbing(Behavior1, Behavior2)
... class Plumbing(object):
...
...     @property
...     def foo(self):
...         return self._foo

>>> plb = Plumbing()
>>> plb.foo = 4
>>> plb.foo
8

子类化行为

与第1阶段的指令不同，这些指令通过普通子类化的规则扩展了类并相互覆盖，管道指令是聚合的。

>>> class Behavior1(Behavior):
...
...     @plumb
...     def foo(next_, self):
...         return 'Behavior1 ' + next_(self)
...
...     @plumb
...     def bar(next_, self):
...         return 'Behavior1 ' + next_(self)

>>> class Behavior2(Behavior1):
...
...     @plumb
...     def foo(next_, self):
...         return 'Behavior2 ' + next_(self)

>>> @plumbing(Behavior2)
... class Plumbing(object):
...
...     def foo(self):
...         return 'foo'
...
...     def bar(self):
...         return 'bar'

>>> plb = Plumbing()
>>> plb.foo()
'Behavior2 Behavior1 foo'

>>> plb.bar()
'Behavior1 bar'

在同一个管道中混合方法和属性是不可能的

在管道中，所有元素都需要是同一类型，无法混合属性和方法。

>>> class Behavior1(Behavior):
...     @plumb
...     def foo(next_, self):
...         return next_(self)

>>> @plumbing(Behavior1)
... class Plumbing(object):
...
...     @property
...     def foo(self):
...         return 5
Traceback (most recent call last):
  ...
plumber.exceptions.PlumbingCollision:
    <plumb 'foo' of <class 'Behavior1'> payload=<function Behavior1.foo at 0x...>>
  with:
    <class 'Plumbing'>

类、方法和属性的文档字符串

管道声明和行为类的正常文档字符串、管道方法以及管道属性通过以管道声明开始的换行符连接，然后是反向顺序的行为。

>>> class P1(Behavior):
...     """P1
...     """
...     @plumb
...     def foo(self):
...         """P1.foo
...         """
...     bar = plumb(property(None, None, None, 'P1.bar'))

>>> class P2(Behavior):
...     @override
...     def foo(self):
...         """P2.foo
...         """
...     bar = plumb(property(None, None, None, 'P2.bar'))

>>> @plumbing(P1, P2)
... class Plumbing(object):
...     """Plumbing
...     """
...     bar = property(None, None, None, 'Plumbing.bar')

>>> print(Plumbing.__doc__)
Plumbing
<BLANKLINE>
P1
<BLANKLINE>

>>> print(Plumbing.foo.__doc__)
P2.foo
<BLANKLINE>
P1.foo
<BLANKLINE>

>>> print(Plumbing.bar.__doc__)
Plumbing.bar
<BLANKLINE>
P2.bar
<BLANKLINE>
P1.bar

文档字符串的累积是一个实验性功能，可能会更改。

槽和管道

管道类可以像普通类一样有__slots__。

>>> class P1(Behavior):
...     @default
...     def somewhing_which_writes_to_foo(self, foo_val):
...         self.foo = foo_val

>>> @plumbing(P1)
... class WithSlots(object):
...     __slots__ = 'foo'

>>> WithSlots.__dict__['foo']
<member 'foo' of 'WithSlots' objects>

>>> ob = WithSlots()
>>> ob.somewhing_which_writes_to_foo('foo')
>>> assert(ob.foo == 'foo')

zope.interface（如果可用）

管道工不依赖于zope.interface，但它对此有所了解。这意味着它将尝试导入它，如果可用，将检查管道行为以实现接口，并将管道也实现它们。

>>> from zope.interface import Interface
>>> from zope.interface import implementer

一个接口类将作为管道的基类。

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

>>> @implementer(IBase)
... class Base(object):
...     pass

>>> IBase.implementedBy(Base)
True

两个具有相应接口的行为，一个基类也实现了接口。

>>> class IBehavior1(Interface):
...     pass

>>> @implementer(IBehavior1)
... class Behavior1(Behavior):
...     blub = 1

>>> class IBehavior2Base(Interface):
...     pass

>>> @implementer(IBehavior2Base)
... class Behavior2Base(Behavior):
...     pass

>>> class IBehavior2(Interface):
...     pass

>>> @implementer(IBehavior2)
... class Behavior2(Behavior2Base):
...     pass

>>> IBehavior1.implementedBy(Behavior1)
True

>>> IBehavior2Base.implementedBy(Behavior2Base)
True

>>> IBehavior2Base.implementedBy(Behavior2)
True

>>> IBehavior2.implementedBy(Behavior2)
True

基于Base的管道，使用Behavior1和Behavior2，并实现IPlumbingClass。

>>> class IPlumbingClass(Interface):
...     pass

>>> @implementer(IPlumbingClass)
... @plumbing(Behavior1, Behavior2)
... class PlumbingClass(Base):
...     pass

直接声明和继承的接口得到实现。

>>> IPlumbingClass.implementedBy(PlumbingClass)
True

>>> IBase.implementedBy(PlumbingClass)
True

行为实现的接口也得到实现。

>>> IBehavior1.implementedBy(PlumbingClass)
True

>>> IBehavior2.implementedBy(PlumbingClass)
True

>>> IBehavior2Base.implementedBy(PlumbingClass)
True

类的实例提供接口。

>>> plb = PlumbingClass()

>>> IPlumbingClass.providedBy(plb)
True

>>> IBase.providedBy(plb)
True

>>> IBehavior1.providedBy(plb)
True

>>> IBehavior2.providedBy(plb)
True

>>> IBehavior2Base.providedBy(plb)
True