Skip to content

Commit

Permalink
Use zope.interface
Browse files Browse the repository at this point in the history
  • Loading branch information
@baijum
baijum committed Oct 6, 2009
1 parent 2fc0ba9 commit ccde21c
Showing 1 changed file with 50 additions and 73 deletions.
123 changes: 50 additions & 73 deletions zdgbook/source/ComponentsAndInterfaces.rst
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,11 +2,10 @@
Components and Interfaces
#########################

Zope is becoming a component system. Zope components will be Python
objects with interfaces that describe them. Right now only some of
the Zope code base uses interfaces. In coming releases more and more
of Zope will include interfaces. As a Zope developer you can use
interfaces right now to build your Zope components.
Zope uses a component architecture internally in many places. Zope
components is nothing but Python objects with interfaces that
describe them. As a Zope developer you can use interfaces right now
to build your Zope components.

Zope Components
===============
Expand All @@ -21,38 +20,39 @@ Here is a very simple component that says hello. Like all
components, this one generally consists of two pieces, an interface,
and an implementation::

from Interface import Base
from zope.interface import Interface
from zope.interface import implements

class Hello(Base):
class IHello(Interface):
"""The Hello interface provides greetings."""

def hello(self, name):
""" Say hello to the name """
def hello(name):
"""Say hello to the name"""

class HelloComponent:
class HelloComponent(object):

__implements__ = Hello
implements(IHello)

def hello(self, name):
return "hello %s!" % name

Let's take a look at this step by step. Here, you see two Python
class statements. The first statement creates the *interface*, and
the second statement creates the *implementation*.
class statements. The first class statement creates the *interface*,
and the second class statement creates the *implementation*.

The first class statement creates the 'Hello' interface. This
The first class statement creates the 'IHello' interface. This
interface describes one method, called 'hello'. Notice that there is
no implementation for this method, interfaces do not define behavior,
they just describe a specification.

The second 'class' statement creates the 'HelloComponent' class.
This class is the actual component that *does* what 'Hello'
This class is the actual component that *does* what 'IHello'
*describes*. This is usually referred to as the *implementation* of
'Hello'. In order for you to know what interfaces 'HelloComponent'
'IHello'. In order for you to know what interfaces 'HelloComponent'
implements, it must somehow associate itself with an interface. The
'__implements__' class attribute does just that. It says, "I
implement these interfaces". In this case, 'HelloComponent' asserts
that it implements one interface, 'Hello'.
'implements' function call inside the class does just that. It says,
"I implement these interfaces". In this case, 'HelloComponent'
asserts that it implements one interface, 'IHello'.

The interface describes how you would work with the object, but it
doesn't dictate how that description is implemented. For example,
Expand All @@ -61,7 +61,7 @@ here's a more complex implementation of the 'Hello' interface::
import xmlrpclib
class XMLRPCHello:

__implements__ = Hello
implementats(IHello)

def hello(self, name):
"""
Expand Down Expand Up @@ -150,30 +150,30 @@ understand that using Python's class syntax is just a convenience,
and that the resulting object is an *interface*, not a class.

To create an interface object using Python's class syntax, create a
Python class that subclasses from 'Interface.Base'::
Python class that subclasses from 'zope.interface.Interface'::

from Interface import Base
from zope.interface import Interface

class Hello(Base):
class IHello(Interface):

def hello(self, name):
def hello(name):
"""Say hello to the world"""

This interface does not implement behavior for its methods, it just
describes an interface that a typical "Hello" object would realize.
By subclassing the 'Interface.Base' interface, the resulting object
'Hello' is an interface object. The Python interpreter confirms
this::
By subclassing the 'zope.interface.Interface' interface, the
resulting object 'Hello' is an interface object. The Python
interpreter confirms this::

>>> Hello
<Interface Hello at 812cbd4>
>>> IHello
<InterfaceClass __main__.IHello>

Now, you can associate the 'Hello' Interface with your new, concrete
class in which you define your user behavior. For example::

class HelloComponent:

__implements__ = Hello
implements(IHello)

def hello(self, name):
return "Hello %s!" % name
Expand All @@ -188,67 +188,44 @@ objects to the 'HelloComponent' class::

class HelloComponent:

__implements__ = Hello, Item

This '__implements__' attribute is called an *interface assertion*.
An interface assertion can be either an interface, or a sequence of
interface assertions. Here's a more complex example::

class Sandwich:

__implements__ = (Food, (Nourishing, Delicious), (GetsStaleQuickly,
(EdibleWithHands, GoodForLunch)))


Interface assertions allow complex nesting of interfaces. This is
mostly useful when you wish to assert that your class implements some
specific interfaces, along with whatever interfaces your base class
implements::

class Sandwich(Food):

__implements__ = (EdibleWithHands, GoodForLunch, Food.__implements__)

Take care before you assert that your class implements the interfaces
of your base classes.
implements(IHello, IItem)


The Interface Model
===================

Interfaces can extend other interfaces. For example, let's extend
the 'Hello' interface by adding an additional method::
the 'IHello' interface by adding an additional method::

class SmartHello(Hello):
class ISmartHello(IHello):
"""A Hello object that remembers who it's greeted"""

def lastGreeted(self):
"""Returns the name of the last person greeted."""


'SmartHello' extends the 'Hello' interface. It does this by using
'ISmartHello' extends the 'IHello' interface. It does this by using
the same syntax a class would use to subclass another class.


Now, you can ask the 'SmartHello' for a list of the interfaces it
Now, you can ask the 'ISmartHello' for a list of the interfaces it
extends with 'getBases'::

>>> SmartHello.getBases()
[<interface Hello at 80c72c8>]

>>> ISmartHello.getBases()
(<InterfaceClass __main__.IHello>,)

An interface can extend any number of other interfaces, and
'getBases' will return that list of interfaces for you. If you want
to know if 'SmartHello' extends any other interface, you could call
to know if 'ISmartHello' extends any other interface, you could call
'getBases' and search through the list, but a convenience method
called 'extends' is provided that returns true or false for this
purpose::

>>> SmartHello.extends(Hello)
1
>>> SmartHello.extends(Sandwich)
0
>>>
>>> ISmartHello.extends(IHello)
True
>>> ISandwich(Interface):
... pass
>>> ISmartHello.extends(ISandwich)
False

Here you can see 'extends' can be used to determine if one interface
extends another.
Expand Down Expand Up @@ -289,9 +266,9 @@ method.
For example::

>>> User.namesAndDescriptions()
[('getUserName', <Interface.Method.Method instance at 80f38f0>),
('getFavoriteColor', <Interface.Method.Method instance at 80b24f0>),
('getPassword', <Interface.Method.Method instance at 80fded8>)]
[('getUserName', <Interface.Method.Method object at 80f38f0>),
('getFavoriteColor', <Interface.Method.Method object at 80b24f0>),
('getPassword', <Interface.Method.Method object at 80fded8>)]

As you can see, the "description" of the Interface's three items in
these cases are all 'Method' objects. Description objects can be
Expand All @@ -315,7 +292,7 @@ For example::

>>> m=User.namesAndDescriptions()[0][1]
>>> m
<Interface.Method.Method instance at 80f38f0>
<Interface.Method.Method object at 80f38f0>
>>> m.getSignatureString()
'(fullName=1)'
>>> m.getSignatureInfo()
Expand All @@ -333,13 +310,13 @@ You can ask an interface if a certain class or instance that you hand
it implements that interface. For example, say you want to know if
instances of the 'HelloComponent' class implement 'Hello'::

Hello.implementedByInstancesOf(HelloComponent)
IHello.implementedBy(HelloComponent)

This is a true expression. If you had an instance of
'HelloComponent', you can also ask the interface if that instance
implements the interface::

Hello.implementedBy(my_hello_instance)
IHello.implementedBy(my_hello_instance)

This would also return true if *my_hello_instance* was an instance of
*HelloComponent*, or any other class that implemented the *Hello*
Expand Down

0 comments on commit ccde21c

Please sign in to comment.