Merge lp:~ccomb/zcadoc/book-fr into lp:~baijum/zcadoc/book

Proposed by Christophe Combelles on 2009-12-08
Status: Merged
Merged at revision: not available
Proposed branch: lp:~ccomb/zcadoc/book-fr
Merge into: lp:~baijum/zcadoc/book
Diff against target: 5672 lines (+2429/-1926)
3 files modified
TODO-fr-generator.py (+0/-178)
TODO-fr.txt (+0/-124)
izca-fr.txt (+2429/-1624)
To merge this branch: bzr merge lp:~ccomb/zcadoc/book-fr
To post a comment you must log in.
lp:~ccomb/zcadoc/book-fr updated on 2009-12-11
106. By Christophe Combelles on 2009-12-09

some fixes on the french translation

107. By Christophe Combelles on 2009-12-09

small fixes

108. By Christophe Combelles on 2009-12-11

fixes

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== removed file 'TODO-fr-generator.py'
2--- TODO-fr-generator.py 2007-12-03 18:27:59 +0000
3+++ TODO-fr-generator.py 1970-01-01 00:00:00 +0000
4@@ -1,178 +0,0 @@
5-from text_table import TextTable
6-from enum import Enum
7-
8-TRANSLATED_STATUS = Enum("WIP", "Y", "N")
9-REREADED_STATUS = Enum("WIP", "Y", "N")
10-DONE_STATUS = Enum("Y", "N")
11-NOTE_LEVEL = Enum("-", "1", "2", "3", "4", "5")
12-
13-
14-heading_content = ("Chapter or section name", "TRANSLATED", "REREADED", "DONE", "NOTE")
15-
16-table_content = (
17- (" * Getting started", TRANSLATED_STATUS.WIP, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
18- (" o Introduction", TRANSLATED_STATUS.Y, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
19- (" o A brief history", TRANSLATED_STATUS.Y, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
20- (" o Installation", TRANSLATED_STATUS.Y, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
21- (" o Experimenting with code", TRANSLATED_STATUS.Y, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
22- (" * An example", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
23- (" o Introduction", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
24- (" o Procedural approach", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
25- (" o Object oriented approach", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
26- (" o The adapter pattern", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
27- (" * Interfaces", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
28- (" o Introduction", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
29- (" o Declaring interfaces", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
30- (" o Implementing interfaces", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
31- (" o Example revisited", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
32- (" o Marker interfaces", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
33- (" o Invariants", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
34- (" * Adapters", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
35- (" o Implementation", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
36- (" o Registration", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
37- (" o Querying adapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
38- (" o Retrieving adapter using interface", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
39- (" o Adapter pattern", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
40- (" * Utility", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
41- (" o Introduction", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
42- (" o Simple utility", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
43- (" o Named utility", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
44- (" o Factory", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
45- (" * Advanced adapters", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
46- (" o Multi adapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
47- (" o Subscription adapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
48- (" o Handler", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
49- (" * ZCA usage in Zope", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
50- (" o ZCML", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
51- (" o Overrides", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
52- (" o NameChooser", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
53- (" o LocationPhysicallyLocatable", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
54- (" o DefaultSized", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
55- (" o ZopeVersionUtility", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
56- (" * Reference", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
57- (" o Attribute", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
58- (" o Declaration", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
59- (" o Interface", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
60- (" o adapts", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
61- (" o alsoProvides", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
62- (" o classImplements", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
63- (" o classImplementsOnly", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
64- (" o classProvides", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
65- (" o ComponentLookupError", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
66- (" o createObject", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
67- (" o directlyProvidedBy", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
68- (" o directlyProvides", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
69- (" o getAdapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
70- (" o getAdapterInContext", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
71- (" o getAdapters", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
72- (" o getAllUtilitiesRegisteredFor", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
73- (" o getFactoriesFor", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
74- (" o getFactoryInterfaces", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
75- (" o getGlobalSiteManager", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
76- (" o getMultiAdapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
77- (" o getSiteManager", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
78- (" o getUtilitiesFor", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
79- (" o getUtility", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
80- (" o handle", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
81- (" o implementedBy", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
82- (" o implementer", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
83- (" o implements", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
84- (" o implementsOnly", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
85- (" o moduleProvides", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
86- (" o noLongerProvides", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
87- (" o provideAdapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
88- (" o provideHandler", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
89- (" o provideSubscriptionAdapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
90- (" o provideUtility", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
91- (" o providedBy", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
92- (" o queryAdapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
93- (" o queryAdapterInContext", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
94- (" o queryMultiAdapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
95- (" o queryUtility", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
96- (" o registerAdapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
97- (" o registeredAdapters", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
98- (" o registeredHandlers", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
99- (" o registeredSubscriptionAdapters", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
100- (" o registeredUtilities", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
101- (" o registerHandler", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
102- (" o registerSubscriptionAdapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
103- (" o registerUtility", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
104- (" o subscribers", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
105- (" o unregisterAdapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
106- (" o unregisterHandler", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
107- (" o unregisterSubscriptionAdapter", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0]),
108- (" o unregisterUtility", TRANSLATED_STATUS.N, REREADED_STATUS.N, DONE_STATUS.N, NOTE_LEVEL[0])
109-)
110-
111-column_greater_size_content = [0, 0, 0, 0, 0]
112-
113-#summary_value = {
114-# "TRANSLATED" : { "YES" : 0, "WIP": 0 },
115-# "REREADED" : { "YES" : 0 },
116-# "DONE" : { "YES" : 0 }
117-#}
118-
119-summary_value = {
120- TRANSLATED_STATUS.Y : 0,
121- TRANSLATED_STATUS.WIP : 0,
122- REREADED_STATUS.Y : 0,
123- REREADED_STATUS.WIP : 0,
124- DONE_STATUS.Y: 0
125-}
126-
127-for row in (heading_content,) + table_content:
128- for col_index in range(0, len(row)):
129- if (len(str(row[col_index])) > column_greater_size_content[col_index]):
130- column_greater_size_content[col_index] = len(str(row[col_index]))
131-
132- if (summary_value.has_key(row[col_index])):
133- summary_value[row[col_index]] = summary_value[row[col_index]] + 1
134-
135-ascii_table_content = TextTable(
136- *tuple([(column_greater_size_content[i], heading_content[i]) for i in range(0, 5)])
137-)
138-
139-for row in table_content:
140- ascii_table_content.row(*(((row[0]),) + tuple([str(row[col_index]).center(column_greater_size_content[col_index]) for col_index in range(1, len(row))])))
141-
142-
143-summary_content = (
144- ("Translated", str(str(summary_value[TRANSLATED_STATUS.Y]) + " / " + str(len(table_content)) + " (" + str((summary_value[TRANSLATED_STATUS.Y] * 100) / len(table_content)) + " %) , " + str(summary_value[TRANSLATED_STATUS.WIP]) + " in WIP")),
145- ("Rereaded", str(str(summary_value[REREADED_STATUS.Y]) + " / " + str(len(table_content)) + " (" + str((summary_value[REREADED_STATUS.Y] * 100) / len(table_content)) + " %) , " + str(summary_value[REREADED_STATUS.WIP]) + " in WIP")),
146- ("Done", str(str(summary_value[DONE_STATUS.Y]) + " / " + str(len(table_content)) + " (" + str((summary_value[DONE_STATUS.Y] * 100) / len(table_content)) + " %)"))
147-)
148-
149-ascii_summary_content = TextTable((12), (28))
150-for row in summary_content:
151- ascii_summary_content.row(*row)
152-
153-print(
154-"""
155-This file contain some informations about the growth of french
156-translation.
157-
158-This file is generate by TODO-fr-generator.py script file.
159-
160-Summary
161-=======
162-""")
163-
164-
165-print(ascii_summary_content.draw())
166-
167-print("""
168-Detail table
169-============
170-
171-Fields values :
172-
173- * Translated column can be Yes, No, WIP (Work In Progress)
174- * Rereaded column can be Yes, No, WIP (Work In Progress)
175- * Done column can be Yes, No
176- * Note column can be "-" or 1 to 5, it's quality note
177-
178-""")
179-
180-print ascii_table_content.draw()
181-
182-
183
184=== removed file 'TODO-fr.txt'
185--- TODO-fr.txt 2007-12-03 18:27:59 +0000
186+++ TODO-fr.txt 1970-01-01 00:00:00 +0000
187@@ -1,124 +0,0 @@
188-
189-This file contain some informations about the growth of french
190-translation.
191-
192-This file is generate by TODO-fr-generator.py script file.
193-
194-Summary
195-=======
196-
197-.--------------+------------------------------.
198-| Translated | 4 / 92 (4 %) , 1 in WIP |
199-| Rereaded | 0 / 92 (0 %) , 0 in WIP |
200-| Done | 0 / 92 (0 %) |
201-'--------------+------------------------------'
202-
203-
204-Detail table
205-============
206-
207-Fields values :
208-
209- * Translated column can be Yes, No, WIP (Work In Progress)
210- * Rereaded column can be Yes, No, WIP (Work In Progress)
211- * Done column can be Yes, No
212- * Note column can be "-" or 1 to 5, it's quality note
213-
214-
215-.---------------------------------------------+------------+----------+------+------.
216-| Chapter or section name | TRANSLATED | REREADED | DONE | NOTE |
217-+---------------------------------------------+------------+----------+------+------+
218-| * Getting started | WIP | N | N | - |
219-| o Introduction | Y | N | N | - |
220-| o A brief history | Y | N | N | - |
221-| o Installation | Y | N | N | - |
222-| o Experimenting with code | Y | N | N | - |
223-| * An example | N | N | N | - |
224-| o Introduction | N | N | N | - |
225-| o Procedural approach | N | N | N | - |
226-| o Object oriented approach | N | N | N | - |
227-| o The adapter pattern | N | N | N | - |
228-| * Interfaces | N | N | N | - |
229-| o Introduction | N | N | N | - |
230-| o Declaring interfaces | N | N | N | - |
231-| o Implementing interfaces | N | N | N | - |
232-| o Example revisited | N | N | N | - |
233-| o Marker interfaces | N | N | N | - |
234-| o Invariants | N | N | N | - |
235-| * Adapters | N | N | N | - |
236-| o Implementation | N | N | N | - |
237-| o Registration | N | N | N | - |
238-| o Querying adapter | N | N | N | - |
239-| o Retrieving adapter using interface | N | N | N | - |
240-| o Adapter pattern | N | N | N | - |
241-| * Utility | N | N | N | - |
242-| o Introduction | N | N | N | - |
243-| o Simple utility | N | N | N | - |
244-| o Named utility | N | N | N | - |
245-| o Factory | N | N | N | - |
246-| * Advanced adapters | N | N | N | - |
247-| o Multi adapter | N | N | N | - |
248-| o Subscription adapter | N | N | N | - |
249-| o Handler | N | N | N | - |
250-| * ZCA usage in Zope | N | N | N | - |
251-| o ZCML | N | N | N | - |
252-| o Overrides | N | N | N | - |
253-| o NameChooser | N | N | N | - |
254-| o LocationPhysicallyLocatable | N | N | N | - |
255-| o DefaultSized | N | N | N | - |
256-| o ZopeVersionUtility | N | N | N | - |
257-| * Reference | N | N | N | - |
258-| o Attribute | N | N | N | - |
259-| o Declaration | N | N | N | - |
260-| o Interface | N | N | N | - |
261-| o adapts | N | N | N | - |
262-| o alsoProvides | N | N | N | - |
263-| o classImplements | N | N | N | - |
264-| o classImplementsOnly | N | N | N | - |
265-| o classProvides | N | N | N | - |
266-| o ComponentLookupError | N | N | N | - |
267-| o createObject | N | N | N | - |
268-| o directlyProvidedBy | N | N | N | - |
269-| o directlyProvides | N | N | N | - |
270-| o getAdapter | N | N | N | - |
271-| o getAdapterInContext | N | N | N | - |
272-| o getAdapters | N | N | N | - |
273-| o getAllUtilitiesRegisteredFor | N | N | N | - |
274-| o getFactoriesFor | N | N | N | - |
275-| o getFactoryInterfaces | N | N | N | - |
276-| o getGlobalSiteManager | N | N | N | - |
277-| o getMultiAdapter | N | N | N | - |
278-| o getSiteManager | N | N | N | - |
279-| o getUtilitiesFor | N | N | N | - |
280-| o getUtility | N | N | N | - |
281-| o handle | N | N | N | - |
282-| o implementedBy | N | N | N | - |
283-| o implementer | N | N | N | - |
284-| o implements | N | N | N | - |
285-| o implementsOnly | N | N | N | - |
286-| o moduleProvides | N | N | N | - |
287-| o noLongerProvides | N | N | N | - |
288-| o provideAdapter | N | N | N | - |
289-| o provideHandler | N | N | N | - |
290-| o provideSubscriptionAdapter | N | N | N | - |
291-| o provideUtility | N | N | N | - |
292-| o providedBy | N | N | N | - |
293-| o queryAdapter | N | N | N | - |
294-| o queryAdapterInContext | N | N | N | - |
295-| o queryMultiAdapter | N | N | N | - |
296-| o queryUtility | N | N | N | - |
297-| o registerAdapter | N | N | N | - |
298-| o registeredAdapters | N | N | N | - |
299-| o registeredHandlers | N | N | N | - |
300-| o registeredSubscriptionAdapters | N | N | N | - |
301-| o registeredUtilities | N | N | N | - |
302-| o registerHandler | N | N | N | - |
303-| o registerSubscriptionAdapter | N | N | N | - |
304-| o registerUtility | N | N | N | - |
305-| o subscribers | N | N | N | - |
306-| o unregisterAdapter | N | N | N | - |
307-| o unregisterHandler | N | N | N | - |
308-| o unregisterSubscriptionAdapter | N | N | N | - |
309-| o unregisterUtility | N | N | N | - |
310-'---------------------------------------------+------------+----------+------+------'
311-
312
313=== modified file 'izca-fr.txt'
314--- izca-fr.txt 2007-12-03 18:27:59 +0000
315+++ izca-fr.txt 2009-12-11 23:53:09 +0000
316@@ -1,246 +1,270 @@
317-===========================
318-Zope Component Architecture
319-===========================
320-
321-
322-:Auteur: Baiju M
323-:Version: 0.4.1
324-:URL: `http://www.muthukadan.net/docs/zca.pdf
325- <http://www.muthukadan.net/docs/zca.pdf>`_
326-:Traducteur: Stéphane Klein <stephane@harobed.org>
327-
328-Copyright (C) 2007 Baiju M <baiju.m.mail AT gmail.com>.
329+========================================================
330+Le guide complet de l'Architecture de Composants de Zope
331+========================================================
332+
333+:Author: Baiju M
334+:Version: 0.5.8
335+:Printed Book: `http://www.lulu.com/content/1561045
336+ <http://www.lulu.com/content/1561045>`_
337+:Online PDF: `http://www.muthukadan.net/docs/zca.pdf
338+ <http://www.muthukadan.net/docs/zca.pdf>`_
339+:Traducteur: Christophe Combelles <ccomb@free.fr>, Stéphane Klein <stephane@harobed.org>
340+
341+Copyright (C) 2007,2008,2009 Baiju M <baiju.m.mail AT gmail.com>.
342
343 Chacun est autorisé à copier, distribuer et/ou modifier ce document
344-suivant les termes de la "GNU Free Documentation License", version 1.2
345-ou (à votre gré) toute version ultérieur publiée par la Free Software
346+suivant les termes de la « GNU Free Documentation License », version 1.3
347+ou toute version ultérieure publiée par la Free Software
348 Foundation.
349
350 Le code source présent dans ce document est soumis aux conditions de
351-la licence Zope Public License, Version 2.1 (ZPL).
352-
353-LE CODE SOURCE DE CE DOCUMENT EST FOURNI "EN L'ETAT" SANS AUCUNE
354-GARANTIE.
355-
356-.. note::
357-
358- Merci à Kent Tenney (Wisconsin, USA) et Brad Allen (Dallas, USA)
359- pour leurs suggestions.
360-
361+la « Zope Public License », Version 2.1 (ZPL).
362+
363+THE SOURCE CODE IN THIS DOCUMENT AND THE DOCUMENT ITSELF IS PROVIDED
364+"AS IS" AND ANY AND ALL EXPRESS OR IMPLIED WARRANTIES ARE DISCLAIMED,
365+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF TITLE,
366+MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS FOR A PARTICULAR
367+PURPOSE.
368+
369+.. sidebar:: Remerciements
370+
371+ De nombreuses personnes m'ont aidé à écrire ce livre. Le brouillon initial a été
372+ relu par mon collègue Brad Allen. Quand j'ai annoncé ce livre sur mon blog, j'ai
373+ reçu de nombreux encouragements pour poursuivre ce travail. Kent Tenney a
374+ modifié de nombreuses parties du livre et a également réécrit l'application
375+ servant d'exemple. De nombreuses autres personnes m'ont envoyé des corrections
376+ et des commentaires, dont Lorenzo Gil Sanchez, Michael Haubenwallner, Nando
377+ Quintana, Stephane Klein, Tim Cook, Kamal Gill et Thomas Herve. Lorenzo a
378+ traduit ce travail en espagnol et Stephane initié la traduction en français. Merci à
379+ toutes ces personnes !
380
381 .. contents::
382 .. .. sectnum::
383
384
385-Premiers pas
386-------------
387+Mise en route
388+-------------
389
390
391 Introduction
392 ~~~~~~~~~~~~
393
394-Le développement de logiciels de grandes tailles (grande quantité de
395-lignes de code...) est toujours une tâche très complexe. L'expérience
396-montre que l'utilisation d'une approche orienté objet simplifie
397-l'analyse, la modélisation et l'implémentation de programmes
398-complexes. Les logiciels informatiques basés sur une architecture et
399-une programmation oriénté composant sont de nos jours de plus en plus
400-populaire. Une grande partie des langages de programmations disposent
401-de framework qui permettent ou simplifient la programmation orienté
402-composant. Certain de ces frameworks sont même compatibles avec
403-plusieurs langages. Parmi ces frameworks orientés composants on trouve
404-par exemple la technologie COM de Microsoft ou alors la technologie
405+Le développement de grands systèmes logiciels est toujours une tâche ardue
406+L'expérience montre que l'approche orientée objet est bien appropriée à
407+l'analyse, à la modélisation et à la programmation des systèmes complexes. La
408+conception orientée composants et la programmation basée sur des composants
409+deviennent actuellement très populaires. L'approche basée composants est d'une
410+grande aide pour l'écriture et la maintenance de systèmes logiciels et
411+de leurs tests unitaires. Il existe de nombreux frameworks permettant la
412+conception basée sur des composants dans différents langages, certains étant
413+même indépendants du langage. On peut citer comme exemple : COM de Microsoft, ou
414 XPCOM de Mozilla.
415
416-L'architecture composant de Zope (nommé ZCA : Zope Component
417-Architecture) est un framework qui permet d'écrire des programmes
418-orientés composants en langage Python. ZCA est très bien adapté pour
419-écrire des programmes Python complexes. Ce framework n'est pas limité
420-au serveur web d'application Zope, il peut être utilisé pour
421-l'écriture de tout type d'application Python, peut être même qu'il
422-devrait être nommé `Python Component Architecture` plutôt que Zope
423-Component Architecture.
424-
425-ZCA dépend principalement de deux paquets:
426-
427- - ``zope.interface`` utilisé pour définir l'interface des
428+La **Zope Component Architecture (ZCA)** est un framework en Python qui autorise
429+la conception et la programmation basée sur des composants. Elle est très bien
430+adaptée au développement de grands systèmes logiciels. La ZCA n'est
431+pas liée au serveur d'application Zope : elle peut être utilisée pour développer
432+n'importe quelle application en Python. Peut-être devrait-elle s'appeler la «
433+Python Component Architecture ».
434+
435+Le but de la ZCA est d'utiliser des objets Python de manière efficace. Les
436+composants sont des objets réutilisables fournissant une interface que l'on peut
437+introspecter. Une interface est un objet qui décrit comment on peut travailler
438+avec un composant particulier. Autrement dit, un composant fournit une interface
439+implémentée dans une classe ou tout autre objet appelable (*callable*). La façon
440+dont le composant est implémenté n'a pas d'importance : ce qui compte est que
441+celui-ci soit en accord avec l'interface. Grâce à la ZCA, vous pouvez éclater la
442+complexité d'un système dans plusieurs composants travaillant ensemble. Elle
443+vous aide à créer notamment deux types de composants : les « adaptateurs » et les «
444+utilitaires ».
445+
446+Trois paquets composent la ZCA :
447+
448+ - ``zope.interface`` est utilisé pour la définition d'une interface.
449+
450+ - ``zope.event`` fournit un système simple d'événements.
451+
452+ - ``zope.component`` sert à la création, l'inscription et la récupération des
453 composants.
454
455- - ``zope.component`` pour réaliser les opérations d'enregistrements
456- et de recherches de composants.
457-
458-ZCA dispose de tout ce qu'il faut pour utiliser efficacement des
459-objets Python. Les composants sont des objets réutilisables disposant
460-d'interface est introspectable. Un composant est un objet disposant
461-d'une interface implémenté par une classe ou tout autre objet
462-exécutable. L'implémentation d'un composant n'est pas l'élément le
463-plus important, ce qui compte avant tout c'est sa conformité avec le
464-"contrat" défini par son interface. L'utilisation d'une architecture
465-orienté composant vous permet de diviser la compléxité d'un système à
466-travers de multiples composants coopératifs. L'architecture composant
467-de Zope vous aide à créer deux types de composants de base : des
468-`adapter` et des `utility`.
469-
470-Notez bien que l'architecture composant de Zope ne vous aide pas à
471-écrire les composants eux-mêmes mais elle vous permet la création,
472-l'enregistrement et la recherche de composants.Notez aussi qu'un
473-composant `adapter` est une classe Python tout à fait normal (ou en
474-général une fabrique d'objet (factory)) et qu'un composant `utility`
475-est un objet Python exécutable standard.
476-
477-L'architecture composant Zope est développé comme une partie distincte
478-du projet Zope 3. ZCA, comme indiqué plus tôt, est un framework
479-purement Python, il peut être utilisé pour développer n'importe quel
480-type d'application. Actuellement à la fois Zope 3 et Zope 2 utilisent
481-très fortement ce framework mais il existe de nombreux autres projets
482-et même des applications non orientés Internet qui utilisent
483-l'architecture composant de Zope [#projects]_.
484+Souvenez-vous que la ZCA ne fournit pas de composants par elle-même. Elle n'a
485+pour but que de créer, inscrire et récupérer des composants. Gardez également à
486+l'esprit qu'un adaptateur est une classe Python tout à fait normale (en général
487+une fabrique) et qu'un utilitaire est un simple objet Python appelable.
488+
489+Le framework ZCA est développé comme une partie du projet Zope 3. Comme
490+mentionné plus haut, c'est un framework purement Python et il peut être utilisé
491+dans n'importe quelle application Python. Actuellement, Zope 3, Zope 2 et Grok
492+l'utilisent abondamment. De nombreux autres projets l'utilisent, y compris des
493+applications non liées au web [#projects]_.
494+
495+.. [#projects] http://wiki.zope.org/zope3/ComponentArchitecture
496
497
498 Petit historique
499 ~~~~~~~~~~~~~~~~
500
501-Le développement de la ZCA a débuté en 2001 dans le cadre du projet
502-Zope 3. Ce framework est le fruit de l'expérience aquise durant le
503-développement d'application d'envergure en Zope 2. Jim Fulton est le
504-père de ce projet. De nombreuses personnes ont participé à la
505-conception de ce framework, parmit eux on peut citer : Stephan
506-Richter, Philipp von Weitershausen, Guido van Rossum (créateur du
507-langage Python), Tres Seaver, Phillip J Eby et Martijn Faassen.
508-
509-Par rapport à la version actuel, les premières versions de ZCA
510-disposaient de quelques composants supplémentaires : les composants
511-`services` et les composants `views`. Ils ont été supprimé car les
512-développeurs ont réalisé que le composant `utility` pouvait remplacer
513-le composant `service` et le composant `multi-adapter` pouvait
514-remplacer le composant `view`. La ZCA comporte actuellement un nombre
515-réduit de type de type de composant :les `utility`, les `adapter`, les
516-`subscribers` et les `handler`. En fait, les composants `subscriber`
517-et `handler` sont tous deux des adaptateurs spécialisés.
518-
519-Pendant le cycle de développement de Zope 3.2, Jim Fulton a proposé
520-une importante simplification de l'achitecture composant de Zope
521-[#proposal]_. Parmit ces simplications, on trouve la possibilité en
522-passant par une interface unique de déclarer à la fois des composants
523-globaux et locaux.
524-
525-Le paquet ``zope.component`` a une longue liste de dépendances, parmit
526-elles beaucoup ne sont pas nécessaire aux applications non Zope 3.
527-Pendant le PyCon 2007, Jim Fulton a ajouté à setuptools une nouvelle
528-fonctionnalité nommée `extras_require`. Elle permet de séparer les
529-fonctionnalités constituant le coeur de ZCA des fonctionnalités
530+Le développement de la ZCA a débuté en 2001 dans le cadre du projet Zope 3. Ce
531+framework est le fruit de l'expérience acquise pendant le développement
532+d'applications d'envergure avec Zope 2. Jim Fulton est le père de ce projet. De
533+nombreuses personnes ont participé à sa conception et à son implémentation,
534+notamment Stephan Richter, Philipp von Weitershausen, Guido van Rossum (*aka.
535+Python BDFL*), Tres Seaver, Phillip J Eby et Martijn Faassen.
536+
537+À ses débuts, la ZCA définissait des types de composants supplémentaires : les
538+*services* et les *vues*, mais les développeurs ont fini par réaliser qu'un
539+*utilitaire* peut remplacer un *service* et qu'un *multi-adaptateur* peut
540+remplacer une *vue*. Aujourd'hui, la ZCA comporte un nombre très réduit de types
541+de composants de base : les *utilitaires* (en anglais *utilities*), les *adaptateurs*
542+(*adapters*), les *abonnés* (*subscribers*) et les *gestionnaires* (*handlers*).
543+Et encore, les *abonnés* et les *gestionnaires* sont des cas particuliers de
544+l'*adaptateur*.
545+
546+Pendant le cycle de développement de Zope 3.2, Jim Fulton a proposé une
547+importante simplification de la ZCA [#proposal]_. Grâce à cette simplification,
548+une nouvelle interface unique (`IComponentRegistry`) a été créée pour
549+l'inscription des composants globaux et locaux.
550+
551+.. [#proposal] http://wiki.zope.org/zope3/LocalComponentManagementSimplification
552+
553+Le paquet ``zope.component`` avait une longue liste de dépendances, dont une
554+grande partie n'était pas nécessaire pour une application non liée à Zope 3.
555+Pendant PyCon 2007, Jim Fulton a ajouté la fonctionnalité `extras_require` à
556+setuptools pour permettre d'extraire le cœur de la ZCA des fonctionnalités
557 annexes [#extras]_.
558
559-Maintenant, le projet Zope Component Architecture est un projet
560-indépendant avec son propre cycle de version et son propre dépôt
561-Subversion. Toutefois, les bugs et problèmes sont encore traités à
562-l'intérieur du projet Zope 3 [#bugs]_, et la liste de diffusion
563-zope-dev est utilisé pour les discussions liées aux développements
564-[#discussions]_.
565+.. [#extras] http://peak.telecommunity.com/DevCenter/setuptools#declaring-dependencies
566+
567+En mars 2009, Tres Seaver a supprimé les dépendances à ``zope.deferredimport`` et
568+``zope.proxy``.
569+
570+Aujourd'hui, le projet ZCA est indépendant et possède son propre cycle de
571+publications et son propre dépôt Subversion. Il est fourni avec le framework
572+Zope. [#framework]_. Cependant, les anomalies et les bogues sont toujours pris
573+en charge au travers du projet Zope 3 [#bugs]_ et la liste de diffusion
574+zope-dev est utilisée pour débattre du développement [#discussions]_. Il existe
575+également une liste pour les utilisateurs de Zope 3 (`zope3-users`) qui peut
576+être utilisée pour toute demande au sujet de la ZCA [#z3users]_.
577+
578+.. [#framework] http://docs.zope.org/zopeframework/
579+.. [#bugs] https://bugs.launchpad.net/zope3
580+.. [#discussions] http://mail.zope.org/mailman/listinfo/zope-dev
581+.. [#z3users] http://mail.zope.org/mailman/listinfo/zope3-users
582
583
584 Installation
585 ~~~~~~~~~~~~
586
587-Les paquets ``zope.component`` et ``zope.interface`` forment
588-ensemble le coeur de l'architecture composant de Zope. Ils fournissent
589-les fonctionnalités permettant de définir, déclarer et retrouver des
590-composants. Le paquet ``zope.component`` et ses dépendances sont
591-disponibles sous forme de PythonEggs dans le dépôt PyPI (Python Package
592-Index) [#pypi]_.
593-
594-Vous pouvez utiliser `easy_install` [#easyinstall]_ pour installer
595-``zope.component`` et ses dépendances :
596+Les paquets ``zope.component``, ``zope.interface`` et ``zope.event`` constituent
597+le cœur de la *Zope Component Architecture*. Ils fournissent des outils
598+permettant de définir, inscrire et rechercher des composants. Le paquet
599+``zope.component`` et ses dépendances sont disponibles sous forme d'*egg* dans
600+l'index des paquets Python (PyPI) [#pypi]_.
601+
602+.. [#pypi] Dépôt des paquets Python : http://pypi.python.org/pypi
603+
604+Vous pouvez installer ``zope.component`` et ses dépendances avec `easy_install`
605+[#easyinstall]_ ::
606
607 $ easy_install zope.component
608
609-Cette commande télécharge ``zope.component`` et ses depandances depuis
610-le dépôt PyPI et les installe sur votre système.
611-
612-D'une manière alternative, vous pouvez télécharger manuellement le
613-paquet ``zope.component`` et ses dépendances depuis PyPi puis les
614-installer manuellement. L'ordre d'installation des paquets vous est
615-donné ci-dessous. Sous Windows, vous aurais besoin du paquet binaire
616-de ``zope.interface`` et ``zope.proxy``.
617+.. [#easyinstall] http://peak.telecommunity.com/DevCenter/EasyInstall
618+
619+Cette commande télécharge ``zope.component`` et ses dépendances depuis PyPI et
620+l'installe dans votre *Python path*.
621+
622+Une autre manière de procéder est de télécharger ``zope.component`` et ses
623+dépendances depuis PyPI et de les installer. Il faut installer les paquets dans
624+l'ordre donné ci-dessous. Sous Windows, vous aurez probablement besoin du paquet
625+binaire de ``zope.interface``.
626
627 1. ``zope.interface``
628- 2. ``zope.proxy``
629- 3. ``zope.deferredimport``
630- 4. ``zope.event``
631- 5. ``zope.deprecation``
632- 6. ``zope.component``
633-
634-Pour installer ces paquets après les avoir téléchagré, vous pouvez
635-utiliser la commande ``easy_install`` avec le nom des paquets comme
636-argument (vous pouvez aussi donner la totalité des noms des paquets
637-en argument sur la même ligne)::
638-
639- $ easy_install /path/to/zope.interface-3.4.x.tar.gz
640- $ easy_install /path/to/zope.proxy-3.4.x.tar.gz
641- ...
642-
643-Cette méthode install le framework ZCA dans votre `system Python`, dans
644-le répertoire ``site-packages``... ce qui peut poser certain soucis.
645-Dans un poste présent dans la liste de diffusion Zope 3, Jim Fulton
646-est défavorable à l'utilisation du `system Python` [#systempython]_
647-(c'est à dire à l'installation dans ``site-packages``).
648-
649-
650-Environement d'expérimentation
651-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
652-
653-``virtualenv`` et ``zc.buildout`` sont des outils qui permettent
654-l'installation de la ZCA dans un environement isolé. L'utilisation de
655-ces outils est conseillé lors l'expérimentation de code. De plus, il
656-est bénéfique de se familiariser avec eux car ils sont très pratiques autant
657-lors de la phase de développement que lors du déploiement d'applications.
658-
659-Vous pouvez installer``virtualenv`` via ``easy_install``::
660+ 2. ``zope.event``
661+ 3. ``zope.component``
662+
663+Pour installer ces paquet, après téléchargement, vous pouvez utiliser la
664+commande ``easy_install`` avec les eggs comme argument (éventuellement en
665+fournissant tous les eggs sur la même ligne de commande) ::
666+
667+ $ easy_install /path/to/zope.interface-3.x.x.tar.gz
668+ $ easy_install /path/to/zope.event-3.x.x.tar.gz
669+ $ easy_install /path/to/zope.component-3.x.x.tar.gz
670+
671+Vous pouvez aussi installer ces paquets en les décompressant séparément. Par
672+exemple ::
673+
674+ $ tar zxvf /path/to/zope.interface-3.x.x.tar.gz
675+ $ cd zope.interface-3.x.x
676+ $ python setup.py build
677+ $ python setup.py install
678+
679+Ces méthodes installeront la ZCA dans votre *Python système*, dans le dossier
680+``site-packages``, ce qui peut être problématique. Dans un message sur la liste
681+de diffusion Zope 3, Jim Fulton déconseille d'utiliser le Python système
682+[#systempython]_. Vous pouvez utiliser ``virtualenv`` ou ``zc.buildout`` pour
683+jouer avec n'importe quel paquet Python, et également pour les déploiements.
684+
685+.. [#systempython] http://article.gmane.org/gmane.comp.web.zope.zope3/21045
686+
687+
688+Méthode pour expérimenter
689+~~~~~~~~~~~~~~~~~~~~~~~~~
690+
691+Il existe deux approches populaires en Python pour construire un environnement
692+de travail isolé. La première est ``virtualenv`` créé par Ian Biking, la
693+deuxième est ``zc.buildout`` créé par Jim Fulton. Il est même possible
694+d'utiliser ces paquets ensemble. Ils vous aideront à installer
695+``zope.component`` et d'autres dépendances dans un environnement de
696+développement isolé. Passer un peu de temps à se familiariser avec ces outils
697+vous sera bénéfique lors des développements et des déploiements.
698+
699+**virtualenv**
700+
701+Vous pouvez installer ``virtualenv`` grâce à ``easy_install`` ::
702
703 $ easy_install virtualenv
704
705-Vous pouvez créez ensuite un nouvel environement comme ceci::
706-
707- $ virtualenv myve
708-
709-Cette command a pour effet de créer un nouvel environement virtuel dans le
710-dossier ``myve``. Maintenant, à partir du dossier ``myve``, vous
711-pouvez installer ``zope.component`` et ses dépendances en utilisant
712-l'exécutable ``easy_install`` qui se trouve dans le dossier
713-``myve/bin``::
714+Puis vous pouvez créer un nouvel environnement de cette façon ::
715+
716+ $ virtualenv --no-site-packages myve
717+
718+Ceci crée un nouvel environnement virtuel dans le dossier ``myve``.
719+Maintenant, depuis ce dossier, vous pouvez installer ``zope.component`` et ses
720+dépendances avec le script ``easy_install`` situé dans ``myve/bin`` ::
721
722 $ cd myve
723 $ ./bin/easy_install zope.component
724
725-Vous pouvez maintenant importer les modules ``zope.interface`` et
726-``zope.component`` a partir de votre nouvel interpréteur ``python``
727-qui se trouve dans le dossier ``myve/bin||::
728+Ensuite vous pouvez importer ``zope.interface`` et ``zope.component`` depuis
729+le nouvel interprète ``python`` situé dans ``myve/bin`` ::
730
731 $ ./bin/python
732
733-Cette commande vous donnera une invite de commande Python que vous
734-pouvez utiliser pour exécuter les codes sources de ce livre.
735-
736-L'utilisation de la recette ``zc.recipe.egg`` du paquet
737-``zc.buildout`` vous permet de créer un interpréteur python avec des
738-PythonEggs spécifique. Premièrement, installez ``zc.buildout`` en
739-utilisant la commande ``easy_install`` (Vous pouvez aussi faire cela à
740-l'intérieur d'un environement virtuel). Pour créer un nouveau buildout
741-pour expériement des PythonEggs, commencez par créer un nouveau
742-dossier et initialisez le en utilisant la command ``buildout init``::
743+Cette commande démarre un interprète Python que vous pourrez utiliser pour
744+lancer le code de ce livre.
745+
746+
747+**zc.buildout**
748+
749+En combinant ``zc.buildout`` et la recette ``zc.recipe.egg``, vous pouvez créer
750+un interprète Python ayant accès aux eggs Python spécifiés. Tout d'abord,
751+installez ``zc.buildout`` grâce à la commande ``easy_install`` (vous pouvez le
752+faire à l'intérieur de l'environnement virtuel). Pour créer un nouveau
753+*buildout* servant à expérimenter des eggs Python, commencez par créer un
754+dossier, puis initialisez-le grâce à la commande ``buildout init`` ::
755
756 $ mkdir mybuildout
757 $ cd mybuildout
758 $ buildout init
759
760-Maintenant, le nouveau dossier ``mybuildout`` est un buildout. Le
761-fichier de configuration par défaut du buildout est `buildout.cfg`.
762-Après l'initilisation, il a pour contenu::
763+De cette façon, le dossier ``mybuildout`` devient un « buildout ». Le fichier de
764+configuration de buildout est par défaut `buildout.cfg`. Après initialisation,
765+il doit contenir les lignes suivantes ::
766
767 [buildout]
768 parts =
769
770-Vous pouvez le modifier comme ceci::
771+Vous pouvez le modifier pour qu'il corresponde à ceci ::
772
773 [buildout]
774 parts = py
775@@ -250,319 +274,314 @@
776 interpreter = python
777 eggs = zope.component
778
779-Maintenant exécutez la commande ``buildout`` disponible dans le
780-dossier ``mybuildout/bin`` sans aucun argument. Cela a pour effet de
781-créer un nouvel interpréteur à l'intérieur du dossier
782-``mybuildout/bin``::
783+Si maintenant vous lancez la commande ``buildout`` disponible à l'intérieur du
784+dossier ``mybuildout/bin``, vous obtiendrez un nouvel interprète Python dans le
785+dossier ``mybuildout/bin`` ::
786
787 $ ./bin/buildout
788 $ ./bin/python
789
790-Cette commande vous donnera un invite de commande Python que vous
791-pourrez utiliser pour tester le code source de ce livre.
792-
793-.. [#projects] http://wiki.zope.org/zope3/ComponentArchitecture
794-.. [#proposal] http://wiki.zope.org/zope3/LocalComponentManagementSimplification
795-.. [#extras] http://peak.telecommunity.com/DevCenter/setuptools#declaring-dependencies
796-.. [#bugs] https://bugs.launchpad.net/zope3
797-.. [#discussions] http://mail.zope.org/mailman/listinfo/zope-dev
798-.. [#pypi] Repository of Python packages: http://pypi.python.org/pypi
799-.. [#easyinstall] http://peak.telecommunity.com/DevCenter/EasyInstall
800-.. [#systempython] http://article.gmane.org/gmane.comp.web.zope.zope3/21045
801-
802-
803-An example
804+Cette commande démarre un interprète Python que vous pourrez utiliser pour
805+lancer le code de ce livre.
806+
807+
808+Un exemple
809 ----------
810
811
812 Introduction
813 ~~~~~~~~~~~~
814
815-Consider a business application for registering guests staying in a
816-hotel. Python can implement this in a number of ways. We will start
817-with a brief look at a procedural implementation, and then move to a
818-basic object oriented approach. As we examine the object oriented
819-approach, we will see how we can benefit from the classic design
820-patterns, `adapter` and `interface`. This will bring us into the
821-world of the Zope Component Architecture.
822-
823-
824-Procedural approach
825-~~~~~~~~~~~~~~~~~~~
826-
827-In any business application, data storage is very critical. For
828-simplicity, this example use a Python dictionary as the storage. Key
829-of the dictionary will be the unique Id for a particular guest. And
830-value will be another dictionary with key as the property name::
831-
832- >>> guests_db = {} #key: unique Id, value: details in a dictionary
833-
834-In a simplistic method, a function which accepts details as arguments
835-is enough to do the registration. You also required a supporting
836-function to get the next Id for your data storage.
837-
838-The supporting function, for getting the next Id can be implemented
839-like this::
840+Imaginez une application servant à enregistrer les clients d'un hôtel. En
841+Python, il est possible de faire ceci de différentes manières. Nous allons
842+commencer par étudier rapidement la méthode procédurale, puis nous diriger vers
843+une approche basique orientée objet. En examinant l'approche orientée objet,
844+nous verrons comment nous pouvons bénéficier des motifs de conception
845+`adaptateur` et `interface`. Cela nous fera entrer dans le monde de la Zope
846+Component Architecture.
847+
848+
849+Approche procédurale
850+~~~~~~~~~~~~~~~~~~~~
851+
852+Dans toute application professionnelle, le stockage des données est un point
853+critique. Pour une question de simplicité, cet exemple utilise un simple
854+dictionnaire Python comme méthode de stockage. Nous allons générer des
855+identifiants uniques pour le dictionnaire, la valeur associée sera elle-même un
856+dictionnaire contenant les détails de l'enregistrement.
857+
858+ >>> bookings_db = {} #key: unique ID, value: details in a dictionary
859+
860+Une implémentation minimaliste nécessite une fonction à laquelle on transmet les
861+détails de l'enregistrement et une fonction annexe qui fournit les
862+identifiants uniques utilisés comme clés du dictionnaire de stockage.
863+
864+Nous pouvons obtenir un identifiant unique de cette façon ::
865
866 >>> def get_next_id():
867- ... db_keys = guests_db.keys()
868+ ... db_keys = bookings_db.keys()
869 ... if db_keys == []:
870 ... next_id = 1
871 ... else:
872 ... next_id = max(db_keys) + 1
873 ... return next_id
874
875-As you can see, the `get_next_id` function implementation is very
876-simple. Well, this is not the ideal way, but it is sufficient to
877-explain concepts. The function first get all keys of storage as list
878-and check whether it is empty or not. If the list is empty, so no
879-item is stored, it return `1` as the next Id. And if the list is not
880-empty, the next Id is calculated by adding `1` to the maximum value of
881-list.
882-
883-The function to register guest can get next unique Id using
884-`get_next_id` function, then assign the details of guest using a
885-dictionary. Here is the function to get details and store in the
886-database::
887-
888- >>> def register_guest(name, place):
889+Comme vous pouvez voir, l'implémentation de la fonction `get_next_id` est très
890+simple. La fonction récupère une liste de clés et vérifie si la liste est vide.
891+Si c'est le cas, nous savons que nous en sommes au premier enregistrement et
892+nous renvoyons `1`. Sinon, nous ajoutons `1` à la valeur maximale de la liste et
893+nous renvoyons la nouvelle valeur en résultant.
894+
895+Ensuite, pour créer des enregistrements dans le dictionnaire bookings_db, nous
896+utilisons la fonction suivante ::
897+
898+ >>> def book_room(name, place):
899 ... next_id = get_next_id()
900- ... guests_db[next_id] = {
901+ ... bookings_db[next_id] = {
902 ... 'name': name,
903- ... 'place': place
904+ ... 'room': place
905 ... }
906
907-We will end our discussion of the procedural approach here.
908-It will be much easier to add required features such as data
909-persistence, design flexibility, and code testability using objects.
910-
911-
912-Object oriented approach
913-~~~~~~~~~~~~~~~~~~~~~~~~
914-
915-.. ??? should this paragraph talk about "creating an object for
916- handling registration" or "creating a class to handle registration"?
917-
918-In object oriented methodology, you can think of a registrar object
919-handling the registration. There are many advantages for creating an
920-object for handling registration. Most importantly, the abstraction
921-provided by the registrar object makes the code easier to understand.
922-It offers a way to group related functionality, and can be extended
923-via inheritance. As features are added, such as canceling and updating
924-registration, the registrar object can grow to provide them, or
925-delegate them to another object.
926-
927-Lets look at the implementation details of a registrar object
928-implemented as a class::
929-
930- >>> class guestRegistrar(object):
931+Une application de gestion des enregistrements d'hôtel a besoin de données
932+supplémentaires :
933+
934+ - les numéros de téléphone
935+ - les options des chambres
936+ - les méthodes de paiement
937+ - ...
938+
939+Et de code pour gérer les données :
940+
941+ - annuler une réservation
942+ - Modifier une réservation
943+ - payer une chambre
944+ - stocker les données
945+ - assurer la sécurité des données
946+ - ...
947+
948+Si nous devions continuer l'exemple procédural, il faudrait créer plusieurs
949+fonctions, en renvoyant les données de l'une à l'autre. Au fur à mesure que les
950+fonctionnalités seraient ajoutées, le code deviendrait de plus en plus difficile
951+à maintenir et les bogues deviendraient difficiles à trouver et à corriger.
952+
953+Nous n'irons pas plus loin dans l'approche procédurale. Il sera beaucoup plus
954+facile d'assurer la persistance des données, la flexibilité de la conception et
955+l'écriture de tests unitaires en utilisant des objets.
956+
957+
958+Approche orientée objet
959+~~~~~~~~~~~~~~~~~~~~~~~
960+
961+Notre discussion sur la conception orientée objet nous amène à la notion de
962+« classe » qui sert à encapsuler les données et le code qui les gère.
963+
964+Notre classe principale sera « FrontDesk ». Le FrontDesk et d'autres classes
965+auxquelles il délèguera du traitement, sauront comment gérer les données de
966+l'hôtel. Nous allons créer des instances de FrontDesk pour appliquer cette
967+connaissance au métier de la gestion d'hôtel.
968+
969+L'expérience a montré qu'en consolidant le code et les contraintes sur les
970+données via des objets, on aboutit à un code qui est plus facile à comprendre, à
971+tester et à modifier.
972+
973+Observons les détails d'implémentation de la classe FrontDesk ::
974+
975+ >>> class FrontDesk(object):
976 ...
977- ... def register(self, name, place):
978+ ... def book_room(self, name, place):
979 ... next_id = get_next_id()
980- ... guests_db[next_id] = {
981+ ... bookings_db[next_id] = {
982 ... 'name': name,
983 ... 'place': place
984 ... }
985
986-In this implementation, the registrar object (an instance of
987-`GuestRegistrar` class) is handling the registration. With this
988-design, a particular registrar object can perform multiple
989-registrations.
990-
991-This is how you can use the current registrar implementation::
992-
993- >>> registrar = GuestRegistrar()
994- >>> registrar.register("Jack", "Bangalore")
995-
996-Requirement changes are unavoidable in any real world project.
997-Consider this case, after some time, a new requirement is arising: the
998-guests also required to provide phone number to admit them. You will
999-be required to change the implementation of registrar object to
1000-support it.
1001-
1002-You can achieve this requirement by adding one argument to `registrar`
1003-method and use that argument in the dictionary of values. Here is the
1004-new implementation for this requirement::
1005-
1006- >>> class GuestRegistrar(object):
1007+Dans cette implémentation, l'objet `frontdesk` (une instance de la classe
1008+FrontDesk) est capable de prendre en charge les réservations. Nous pouvons
1009+l'utiliser de la façon suivante ::
1010+
1011+ >>> frontdesk = FrontDesk()
1012+ >>> frontdesk.book_room("Jack", "Bangalore")
1013+
1014+Dans tout projet, on est confronté à des changements de besoins. Dans notre cas,
1015+la direction a décidé que chaque client devait fournit un numéro de téléphone,
1016+donc nous devons changer le code.
1017+
1018+Nous pouvons satisfaire ce nouveau besoin en ajoutant un argument à la méthode
1019+`book_room` qui sera ajouté au dictionnaire des valeurs ::
1020+
1021+ >>> class FrontDesk(object):
1022 ...
1023- ... def register(self, name, place, phone):
1024+ ... def book_room(self, name, place, phone):
1025 ... next_id = get_next_id()
1026- ... guests_db[next_id] = {
1027+ ... bookings_db[next_id] = {
1028 ... 'name': name,
1029 ... 'place': place,
1030 ... 'phone': phone
1031 ... }
1032
1033-Other than migrating the data to new schema, now you have to change
1034-the usage of `GuestRegistrar` in all places. If you can abstract the
1035-details of guest into an object and use it for registration, the code
1036-changes can be minimized. If you follow this design, you have to pass
1037-that guest object instead of more arguments to the function. The new
1038-implementation with guest object will look like this::
1039-
1040- >>> class GuestRegistrar(object):
1041+En plus de devoir migrer les données vers le nouveau schéma, nous devons changer
1042+tous les appels à la classe ``FrontDesk``. Si nous incorporons les coordonnées
1043+de chaque client dans un objet et que nous utilisons cet objet pour les
1044+réservations, les modifications de code pourront être minimisées. Nous pouvons
1045+maintenant changer les détails de l'objet client sans avoir à changer les appels
1046+à FrontDesk.
1047+
1048+Nous avons donc ::
1049+
1050+ >>> class FrontDesk(object):
1051 ...
1052- ... def register(self, guest):
1053+ ... def book_room(self, guest):
1054 ... next_id = get_next_id()
1055- ... guests_db[next_id] = {
1056+ ... bookings_db[next_id] = {
1057 ... 'name': guest.name,
1058 ... 'place': guest.place,
1059 ... 'phone': guest.phone
1060 ... }
1061
1062-Well, even in this implementation you have to change code. Code
1063-change for requirement is unavoidable, your goal should be to minimize
1064-changes and make it maintainable.
1065+Nous devons toujours modifier le code pour répondre aux nouvelles demandes.
1066+C'est inévitable, cependant notre but est de minimiser ces changements et donc
1067+d'améliorer la maintenabilité.
1068
1069 .. note::
1070
1071- You should have the courage to make any change, major or minor, at
1072- any time. Immediate feedback is the only way you can get the
1073- courage. Using automated testing, you can get the immediate
1074- feedback and so the courage to make changes. For more details about
1075- this subject, you can read the book called `Extreme Programming
1076- Explained` by Kent Beck.
1077-
1078-By introducing the guest object, you saved some typing. More than
1079-that, the abstraction of guest object made the system much simpler and
1080-easy to understand. The better understanding leads to better
1081-restructuring and hence maintainable code.
1082-
1083-
1084-The adapter pattern
1085-~~~~~~~~~~~~~~~~~~~
1086-
1087-In a real application, as you noted earlier, the registrar object may
1088-have cancellation and/or updation functionalities. Suppose there are
1089-two more methods like, `cancel_registration` and
1090-`update_registration`. In the new design you will be required to pass
1091-the guest object for each methods. You can solve this problem by
1092-setting guest object as an attribute of registrar object.
1093-
1094-Here is the new implementation of registrar object which set guest
1095-object as an attribute::
1096-
1097- >>> class GuestRegistrarNG(object):
1098+ Lors du développement il ne faut jamais hésiter à faire des changements sans
1099+ craindre de casser l'application. L'avertissement nécessaire doit être
1100+ immédiatement obtenu grâce à des tests automatisés. Avec des tests bien écrits
1101+ (et un bon contrôle de versions), vous pouvez faire impunément des changements
1102+ aussi importants que vous souhaitez. Une bonne source d'informations à propos de
1103+ cette philosophie de programmation est l'ouvrage `Extreme Programming Explained`
1104+ par Kent Beck.
1105+
1106+En introduisant l'objet guest, vous avez économisé un peu de temps. Mais plus
1107+important, l'abstraction apportée par l'objet guest a rendu le système plus
1108+simple et mieux compréhensible. Par conséquent, le code est plus facile à
1109+restructurer et à maintenir.
1110+
1111+
1112+Le motif `adaptateur`
1113+~~~~~~~~~~~~~~~~~~~~~
1114+
1115+Dans une vraie application, l'objet frontdesk devra gérer des fonctionnalités
1116+comme les annulations et les modifications. Avec la conception actuelle, nous
1117+devons transmettre l'objet `guest` au frontdesk à chaque fois que nous appelons
1118+les méthodes `cancel_booking` et `update_booking`.
1119+
1120+Nous pouvons éviter ceci si nous transmettons l'objet `guest` à
1121+FrontDesk.__init__() et si nous le stockons en attribut de l'instance.
1122+
1123+ >>> class FrontDeskNG(object):
1124 ...
1125 ... def __init__(self, guest):
1126 ... self.guest = guest
1127 ...
1128- ... def register(self):
1129+ ... def book_room(self):
1130 ... guest = self.guest
1131 ... next_id = get_next_id()
1132- ... guests_db[next_id] = {
1133+ ... bookings_db[next_id] = {
1134 ... 'name': guest.name,
1135 ... 'place': guest.place,
1136 ... 'phone': guest.phone
1137 ... }
1138-
1139-The solution you reached is a common design pattern called, `Adapter`.
1140-With this design, now you can add more methods, so more functionality,
1141-if required.
1142-
1143-In this implementation, while creating the instance you have to pass
1144-the guest object which has the values as attributes. Now you also
1145-required to create separate instances of `GuestRegistrarNG` for each
1146-guest object.
1147-
1148-Now just step back and think differently. Suppose you are the creator
1149-of this software and selling it to many hotel customers. Consider a
1150-case where your different clients requires different storages. For
1151-example, one registrar might store the details in a relational
1152-database and another one might store them in Zope Object Database
1153-(ZODB). It would be better if you can replace the registrar object
1154-with another one which store guest details in a different way. So, a
1155-mechanism to change implementation based on some configuration would
1156-be useful.
1157-
1158-Zope component architecture provides a mechanism to replace components
1159-based on configuration. Using Zope component architecture you can
1160-register components in a registry called component registry. Later,
1161-retrieve component based on the configuration.
1162-
1163-The `GuestRegistrarNG` class follows, as you noted, a pattern called
1164-`Adapter`. The `GuestRegistrarNG` is the adapter which adapts the
1165-guest object (adaptee). As you can see, the adapter should contain
1166-the component it adapts (adaptee). This is a typical implementation
1167-of adapter::
1168+ ...
1169+ ... def cancel_booking(self):
1170+ ... guest = self.guest
1171+ ... #code for cancellations goes here ...
1172+ ...
1173+ ... def update_booking(self):
1174+ ... guest = self.guest
1175+ ... #code for updatiion goes here ...
1176+
1177+
1178+ La solution que nous avons obtenue est un motif de conception courant appelé
1179+ `adaptateur`. Le `Gang of Four` [#patternbook]_ résume ainsi l'*esprit* de
1180+ l'adaptateur ::
1181+
1182+ « Convertir l'interface d'une classe en une autre interface
1183+ à laquelle le client s'attend. L'adaptateur permet à des
1184+ classes de fonctionner ensemble même si elles ont des
1185+ interfaces incompatibles. »
1186+
1187+En général, un objet adaptateur *contient* un objet adapté ::
1188
1189 >>> class Adapter(object):
1190 ...
1191 ... def __init__(self, adaptee):
1192 ... self.adaptee = adaptee
1193
1194-Now the adapter can make use adaptee (call its methods or access
1195-attributes). An adapter may adapt more than one component. Zope
1196-component architecture provides a mechanism to effectively use these
1197-kind of objects. So, which component should be used will become a
1198-matter of configuration.
1199-
1200-This is a common scenario where you want to use different objects
1201-doing same things, but the details may change. There are many
1202-situations in programming where you want to use different
1203-implementations for same type of objects. Here is a small list of
1204-other common scenarios:
1205-
1206- - A wiki engine with support for multiple markups (STX, reST, Plain
1207- text, etc.)
1208-
1209- - An object browser which shows size of different types of objects.
1210-
1211- - Different types of output formats for text data (PDF, HTML etc.)
1212-
1213- - When developing an application for multiple clients, their
1214- requirements may change. Maintaining separate code bases of the
1215- same application for different clients is difficult. A better
1216- approach would be to create reusable components and configure them
1217- based on client-specific requirements.
1218-
1219-All these examples points to situations where you want to make
1220-applications extensible or pluggable. Do not use `adapter`
1221-components where you do not want extensibility or pluggability.
1222-
1223-Zope component architecture provides `adapter` components to solve
1224-these kinds of problems. In fact, `GuestRegistrarNG` is an adapter
1225-without explicit interface declaration. This tutorial will discuss
1226-adapters after introducing the concept of interfaces. Interfaces are
1227-one of the foundations of Zope components, so understanding the
1228-concept and usage of interfaces is very important.
1229+Ce motif sera utile lorsqu'on sera confronté à des détails d'implémentation qui
1230+dépendent de considérations telles que:
1231+
1232+- modification des besoins client
1233+- modification des méthodes de stockage (ZODB, RDBM, XML)
1234+- modification des méthodes de sortie (HTML, PDF, texte pur)
1235+- modification de la source utilisée (ReST, Markdown, Textile)
1236+
1237+La ZCA utilise des adaptateurs et un *registre de composants* pour fournir la
1238+capacité de changer les détails d'implémentation du code via de la
1239+*configuration*.
1240+
1241+Comme nous pouvons le constater dans la section sur les adaptateurs de la ZCA,
1242+la capacité de configurer les détails d'implémentation fournit des avantages
1243+intéressants :
1244+
1245+- on peut interchanger les implémentations
1246+- on peut ajouter de nouvelles implémentations si besoin
1247+- on améliore les possibilités de réutilisation, aussi bien d'un code existant que
1248+ du code utilisant la ZCA.
1249+
1250+Ces possibilités mènent à du code qui est flexible, évolutif et réutilisable. Il
1251+y a un cependant un coût : maintenir le registre de composants ajoute un niveau
1252+de complexité à l'application. Si une application n'a pas besoin de ces
1253+avantages, la ZCA n'est pas pas nécessaire.
1254+
1255+Nous sommes maintenant prêts à étudier la Zope Component Architecture, en
1256+commençant avec les interfaces.
1257
1258
1259 Interfaces
1260 ----------
1261
1262-
1263 Introduction
1264 ~~~~~~~~~~~~
1265
1266-`Design Patterns` is a classic book in software engineering by the
1267-`Gang of Four` [#patternbook]_. In this book they recommend: "Program
1268-to an interface, not an implementation". Defining formal interfaces
1269-helps you better understand system. Moreover interface brings you all
1270-the benefits of ZCA.
1271-
1272-Interface define the behavior and state of objects. An interface
1273-describes how you work with the object. If you like metaphor, think
1274-of interface as a `contract for object`. Another metaphor which may
1275-help is `blueprint for objects`. In the code, methods and attributes
1276-are forming the object's interface.
1277-
1278-The notion of interface is very explicit in modern languages like
1279-Java, C#, VB.NET etc. Also these languages provide some syntax for
1280-defining interfaces. Python has the notion interfaces, but it is not
1281-very explicit. To simulate a formal definition of interfaces in C++,
1282-`Gang of Four` used classes with virtual functions in `Design
1283-Patterns` book. In a similar fashion, Zope component architecture use
1284-``zope.interface.Interface`` inherited meta-class for defining an
1285-interface.
1286-
1287-The base of object-orientation is the communication between objects.
1288-Messages are used for the communication between objects. In Python,
1289-functions, methods or any other callable can be used to handle
1290-messages.
1291-
1292-For example, consider this class::
1293+Le fichier README.txt [#readmes]_ dans chemin/vers/zope/interface définit les
1294+interfaces de cette manière ::
1295+
1296+ Les interfaces sont des objets qui spécifient (documentent) le
1297+ comportement externe des objets qui les « fournissent ».
1298+ Une interface spécifie un comportement au travers :
1299+
1300+ - de documentation informelle dans une docstring
1301+
1302+ - de définitions d'attributs
1303+
1304+ - d'invariants qui sont des conditions posées sur les objets
1305+ fournissant l'interface.
1306+
1307+L'ouvrage de référence `Design Patterns` [#patternbook]_ par le `Gang of Four`
1308+recommande que vous devez « programmer pour une interface, pas pour une
1309+implémentation ». Définir une interface formelle est utile dans la compréhension
1310+d'un système. De plus, les interfaces vous apportent tous les bénéfices de la
1311+ZCA.
1312+
1313+.. [#readmes] L'arborescence du code de Zope contient de nombreux fichiers README.txt
1314+ qui offrent une très bonne documentation.
1315+.. [#patternbook] http://en.wikipedia.org/wiki/Design_Patterns
1316+
1317+Une interface spécifie les caractéristiques d'un objet, son comportement et ses
1318+capacités. Elle décrit le « quoi » d'un objet. Pour apprendre le « comment »,
1319+vous devez regarder l'implémentation.
1320+
1321+Les métaphores couramment utilisées pour les interfaces sont `contrat` ou
1322+`plan`, des termes légaux et architecturaux pour représenter un jeu de
1323+spécifications.
1324+
1325+Dans certains langages de programmation comme Java, C# ou VB.NET, les
1326+interfaces sont un aspect explicite du langage. Étant donné que Python ne
1327+possède pas nativement d'interfaces, la ZCA les implémente comme des
1328+meta-classes desquelles on hérite.
1329+
1330+Voici un exemple classique de Hello World ::
1331
1332 >>> class Host(object):
1333 ...
1334@@ -571,24 +590,23 @@
1335 ...
1336 ... return "Good morning, %s!" % name
1337
1338-In the above class, you defined a `goodmorning` method. If you call
1339-the `goodmorning` method from an object created using this class, it
1340-will return `Good morning, ...!` ::
1341+Dans la classe ci-dessus, on a défini une méthode `goodmorning`. Si vous appelez
1342+cette méthode depuis un objet créé en utilisant cette classe, vous obtiendrez un
1343+`Good morning, ...!` ::
1344
1345 >>> host = Host()
1346 >>> host.goodmorning('Jack')
1347 'Good morning, Jack!'
1348
1349-Here ``host`` is the actual object. The implementation details of
1350-this object is the class ``Host``. Now, how to find how the object
1351-looks like, that is, what are the methods and attributes of the
1352-object. For this, either you have go through the implementation
1353-details (``Host`` class) of the object or a separate API documentation
1354-[#api]_ will be required.
1355-
1356-You can use the ``zope.interface`` package to define the interface of
1357-objects. For the class given above you can specify the interface like
1358-this::
1359+Ici, ``host`` est l'objet réel que votre code utilise. Si vous voulez
1360+examiner les détails d'implémentation, vous devez accéder à la classe ``Host``,
1361+soit via le code source, soit au travers d'un outil de documentation d'API
1362+[#api]_.
1363+
1364+.. [#api] http://en.wikipedia.org/wiki/Application_programming_interface
1365+
1366+Maintenant nous allons commencer à utiliser les interfaces de la ZCA. Pour la
1367+classe ci-dessus, vous pouvez définir l'interface comme suit ::
1368
1369 >>> from zope.interface import Interface
1370
1371@@ -597,21 +615,18 @@
1372 ... def goodmorning(guest):
1373 ... """Say good morning to guest"""
1374
1375-As you can see, the interface is defined using Python class statement.
1376-We use (abuse?) Python's class statement to define interfaces. To
1377-make a class an interface, it must be inherited from
1378-``zope.interface.Interface`` . The ``I`` prefix for interface name is
1379-a convention.
1380-
1381-
1382-Declaring interfaces
1383-~~~~~~~~~~~~~~~~~~~~
1384-
1385-You have already seen how to declare an interface using
1386-``zope.interface`` in previous section. This section will explain the
1387-concepts in detail.
1388-
1389-Consider this example interface::
1390+Vous pouvez constater que l'interface hérite de zope.interface.Interface. C'est
1391+de cette façon (abusive ?) que la ZCA définit des interfaces. Le préfixe « I »
1392+pour le nom de la classe est une convention utile.
1393+
1394+
1395+Déclarer des interfaces
1396+~~~~~~~~~~~~~~~~~~~~~~~
1397+
1398+Vous avez déjà vu comment déclarer une interface en utilisant ``zope.interface``
1399+dans la section précédente. Cette section va expliquer les concepts en détail.
1400+
1401+Prenez cette exemple d'interface ::
1402
1403 >>> from zope.interface import Interface
1404 >>> from zope.interface import Attribute
1405@@ -624,60 +639,58 @@
1406 ... def goodmorning(guest):
1407 ... """Say good morning to guest"""
1408
1409-The interface, ``IHost`` has two attributes, ``name`` and
1410-``goodmorning``. Recall that, at least in Python, methods are also
1411-attributes of classes. The ``name`` attribute is defined using
1412-``zope.interface.Attribute`` class. When you add the attribute
1413-``name`` to the ``IHost`` interface, you don't set an initial value.
1414-The purpose of defining the attribute ``name`` here is merely to
1415-indicate that any implementation of this interface will feature an
1416-attribute named ``name``. In this case, you don't even say what type
1417-of attribute it has to be!. You can pass a documentation string as a
1418-first argument to ``Attribute``.
1419-
1420-The other attribute, ``goodmorning`` is a method defined using a
1421-function definition. Note that `self` is not required in interfaces,
1422-because `self` is an implementation detail of class. For example, a
1423-module can implement this interface. If a module implement this
1424-interface, there will be a ``name`` attribute and ``goodmorning``
1425-function defined. And the ``goodmorning`` function will accept one
1426-argument.
1427-
1428-Now you will see how to connect `interface-class-object`. So object
1429-is the real living thing, objects are instances of classes. And
1430-interface is the actual definition of the object, so classes are just
1431-the implementation details. This is why you should program to an
1432-interface and not to an implementation.
1433-
1434-Now you should familiarize two more terms to understand other
1435-concepts. First one is `provide` and the other one is `implement`.
1436-Object provides interfaces and classes implement interfaces. In other
1437-words, objects provide interfaces that their classes implement. In
1438-the above example ``host`` (object) provides ``IHost`` (interface) and
1439-``Host`` (class) implement ``IHost`` (interface). One object can
1440-provide more than one interface also one class can implement more than
1441-one interface. Objects can also provide interfaces directly, in
1442-addition to what their classes implement.
1443+L'interface ``IHost`` possède deux attributs, ``name`` et ``goodmorning``.
1444+Rappelez-vous qu'en Python les méthodes des classes sont aussi des attributs.
1445+L'attribut ``name`` est défini en utilisant la classe
1446+``zope.interface.Attribute``. Quand vous ajoutez l'attribut ``name`` à
1447+l'interface ``IHost``, vous ne définissez pas de valeur initiale. La raison de
1448+définir l'attribut ``name`` ici est simplement d'indiquer que toute
1449+implémentation de cette interface doit fournir un attribut nommé ``name``. Dans
1450+ce cas, vous n'indiquez même pas de quel type doit être l'attribut ! Vous pouvez
1451+juste fournir une chaîne de documentation comme premier argument à
1452+``Attribute``.
1453+
1454+L'autre attribut, ``goodmorning`` est une méthode définie en utilisant une
1455+fonction. Notez bien que ``self`` n'est pas nécessaire dans les interfaces, car
1456+``self`` est un détail d'implémentation de la classe. Il est possible pour un
1457+module d'implémenter cette interface. Si un module implémente cette interface,
1458+cela signifiera qu'un attribut ``name`` et une fonction ``goodmorning`` seront
1459+définis. Et la fonction ``goodmorning`` devra accepter un argument.
1460+
1461+Nous allons maintenant voir comment effectuer le lien entre les objets, les
1462+classes et les interfaces. Seuls les objets sont vivants : ce sont des instances
1463+de classes. Et les interfaces représentent la définition des objets, donc les
1464+classes ne sont qu'un détail d'implémentation. C'est pour cette raison que vous
1465+devez programmer pour une interface, pas pour une implémentation.
1466+
1467+Nous devons nous familiariser avec deux termes supplémentaires pour comprendre
1468+les autres concepts. Le premier est `fournir`, le deuxième est `implémenter`.
1469+Les objets fournissent des interfaces, tandis que les classes implémentent des
1470+interfaces. Autrement dit, les objets fournissent les interfaces que les classes
1471+implémentent. Dans l'exemple ci-dessus, l'objet ``host`` fournit l'interface
1472+``IHost`` et la classe ``Host`` implémente l'interface ``IHost``. Un objet peut
1473+fournir plusieurs interfaces. Les objets peuvent également fournir directement
1474+des interfaces, en plus de celles implémentées par leur classe.
1475
1476 .. note::
1477
1478- Classes are the implementation details of objects. In Python,
1479- classes are callable objects, so why other callable objects can't
1480- implement an interface. Yes, it is possible. For any `callable
1481- object` you can declare that it produces objects that provide some
1482- interfaces by saying that the `callable object` implements the
1483- interfaces. The `callable objects` are generally called as
1484- `factories`. Since functions are callable objects, a function can
1485- be an `implementer` of an interface.
1486-
1487-
1488-Implementing interfaces
1489-~~~~~~~~~~~~~~~~~~~~~~~
1490-
1491-To declare a class implements a particular interface, use the function
1492-``zope.interface.implements`` in the class statement.
1493-
1494-Consider this example, here ``Host`` implements ``IHost``::
1495+ Les classes sont les détails d'implémentation des objets. En Python, les
1496+ classes sont des objets appelables (`callable`). Pourquoi un autre objet
1497+ appelable ne pourrait-il pas implémenter une interface ? En fait c'est possible.
1498+ Pour n'importe quel objet appelable, vous pouvez déclarer qu'il produit des
1499+ objets qui fournissent une interface donnée, en disant simplement que cet objet
1500+ appelable implémente l'interface. Ces objets appelables sont généralement
1501+ nommés des « fabriques ». Étant donné que les fonctions sont des objets
1502+ appelables, une fonction peut implémenter une interface.
1503+
1504+
1505+Implémentation des interfaces
1506+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1507+
1508+Pour déclarer qu'une classe implémente une interface donnée, utilisez la
1509+fonction ``zope.interface.implements`` dans la déclaration de classe.
1510+
1511+Considérons cet exemple. Ici, ``Host`` implémente ``IHost`` ::
1512
1513 >>> from zope.interface import implements
1514
1515@@ -694,55 +707,54 @@
1516
1517 .. note::
1518
1519- If you wonder how ``implements`` function works, refer the blog post
1520- by James Henstridge
1521+ Si vous vous demandez comment ``implements`` fonctionne, faites un tour sur
1522+ l'article de blog de James Henstridge
1523 (http://blogs.gnome.org/jamesh/2005/09/08/python-class-advisors/) .
1524- In the adapter section, you will see an ``adapts`` function, it is
1525- also working similarly.
1526+ Dans la section sur les adaptateurs, vous allez voir une fonction ``adapts``,
1527+ celle-ci fonctionne de manière similaire.
1528
1529-Since ``Host`` implements ``IHost``, instances of ``Host`` provides
1530-``IHost``. There are some utility methods to introspect the
1531-declarations. The declaration can write outside the class also. If
1532-you don't write ``interface.implements(IHost)`` in the above example,
1533-then after defining the class statement, you can write like this::
1534+Comme ``Host`` implémente ``IHost``, les instances de ``Host`` fournissent
1535+``IHost``. Il existe des méthodes permettant d'introspecter les déclarations. La
1536+déclaration peut également s'écrire en dehors de la classe. Au lieu d'écrire
1537+``interface.implements(IHost)`` comme dans l'exemple ci-dessus, vous pouvez
1538+écrire la chose suivante après la déclaration de classe ::
1539
1540 >>> from zope.interface import classImplements
1541 >>> classImplements(Host, IHost)
1542
1543
1544-Example revisited
1545-~~~~~~~~~~~~~~~~~
1546+L'exemple revisité
1547+~~~~~~~~~~~~~~~~~~
1548
1549-Now, return to the example application. Here you will see how to
1550-define the interface of the registrar object::
1551+Maintenant retournons à notre application exemple. Voici comment définir
1552+l'interface de l'objet frontdesk ::
1553
1554 >>> from zope.interface import Interface
1555
1556- >>> class IRegistrar(Interface):
1557- ... """A registrar will register object's details"""
1558+ >>> class IDesk(Interface):
1559+ ... """A frontdesk will register object's details"""
1560 ...
1561 ... def register():
1562 ... """Register object's details"""
1563 ...
1564
1565-Here, first you imported ``Interface`` class from ``zope.interface``
1566-module. If you define a subclass of this ``Interface`` class, it will
1567-be an interface from Zope component architecture point of view. An
1568-interface can be implemented, as you already noted, in a class or any
1569-other callable object.
1570-
1571-The registrar interface defined here is ``IRegistrar``. The
1572-documentation string for interface gives an idea about the object. By
1573-defining a method in the interface, you made a contract for the
1574-component, that there will be a method with same name available. For
1575-the method definition interface, the first argument should not be
1576-`self`, because an interface will never be instantiated nor will its
1577-methods ever be called. Instead, the interface class merely documents
1578-what methods and attributes should appear in any normal class that
1579-claims to implement it, and the `self` parameter is an implementation
1580-detail which doesn't need to be documented.
1581-
1582-As you know, an interface can also specify normal attributes::
1583+Nous avons d'abord importé la classe ``Interface`` depuis le module
1584+``zope.interface``. Si vous définissez une sous-classe de cette classe
1585+``Interface``, ce sera considéré comme une interface, du point de vue de
1586+l'Architecture de Composants. Une interface peut être implémentée, comme nous
1587+l'avons vu, dans une classe ou tout autre objet appelable.
1588+
1589+L'interface de frontdesk ici définie est ``IDesk``. La chaîne de documentation
1590+de l'interface donne une idée sur la nature de l'objet. En définissant une
1591+méthode dans l'interface, vous avez passé un contrat avec le composant, imposant
1592+la présence d'une méthode du même nom. Dans la déclaration de la méthode côté
1593+interface, le premier argument ne doit pas être `self`, car une interface ne
1594+sera jamais instanciée et ses méthodes ne seront jamais appelées. Le rôle d'une
1595+interface est simplement de documenter quels arguments et quelles méthodes
1596+doivent apparaître dans une classe qui l'implémente, et le paramètre `self`
1597+n'est qu'un détail d'implémentation qui n'a pas besoin d'être documenté.
1598+
1599+Comme vous le savez, une interface peut aussi spécifier des attributs normaux ::
1600
1601 >>> from zope.interface import Interface
1602 >>> from zope.interface import Attribute
1603@@ -752,26 +764,25 @@
1604 ... name = Attribute("Name of guest")
1605 ... place = Attribute("Place of guest")
1606
1607-In this interface, guest object has two attributes specified with
1608-documentation. An interface can also specify both attributes and
1609-methods together. An interface can be implemented in a class, module
1610-or any other objects. For example a function can dynamically create
1611-the component and return, in this case the function is an implementer
1612-for the interface.
1613-
1614-Now you know what is an interface and how to define and use it. In
1615-the next chapter you can see how an interface is used to define an
1616-adapter component.
1617-
1618-
1619-Marker interfaces
1620-~~~~~~~~~~~~~~~~~
1621-
1622-An interface can be used to declare that a particular object belongs
1623-to a special type. An interface without any attribute or method is
1624-called `marker interface`.
1625-
1626-Here is a `marker interface`::
1627+Dans cette interface, l'objet guest a deux attributs contenant de la
1628+documentation. Une interface peut spécifier à la fois des méthodes et des
1629+attributs. Une interface peut être implémentée dans une classe, un module ou
1630+tout autre objet. Par exemple une fonction peut créer dynamiquement le composant
1631+et le renvoyer, auquel cas on dit que la fonction implémente l'interface.
1632+
1633+Vous savez maintenant ce qu'est une interface, comment la créer et l'utiliser.
1634+Dans le chapitre suivant nous allons voir comment une interface peut être
1635+utilisée pour définir un composant adaptateur.
1636+
1637+
1638+Interfaces marqueurs
1639+~~~~~~~~~~~~~~~~~~~~
1640+
1641+Une interface peut être utilisée pour déclarer qu'un objet appartient à un
1642+type donné. Une interface sans aucun attribut ni aucune méthode est appelée une
1643+« interface marqueur ».
1644+
1645+Voici une `interface marqueur` ::
1646
1647 >>> from zope.interface import Interface
1648
1649@@ -779,24 +790,25 @@
1650 ... """A special guest"""
1651
1652
1653-This interface can be used to declare an object is a special guest.
1654+Cette interface peut être utilisée pour déclarer qu'un objet est un client
1655+spécial.
1656
1657
1658 Invariants
1659 ~~~~~~~~~~
1660
1661-Sometimes you will be required to use some rule for your component
1662-which involve one or more normal attributes. These kind of rule is
1663-called `invariants`. You can use ``zope.interface.invariant`` for
1664-setting `invariants` for your objects in their interface.
1665-
1666-Consider a simple example, there is a `person` object. A person
1667-object has `name`, `email` and `phone` attributes. How do you
1668-implement a validation rule that says either email or phone have to
1669-exist, but not necessarily both.
1670-
1671-First you have to make a callable object, either a simple function or
1672-callable instance of a class like this::
1673+Parfois vous aurez besoin de définir des règles ou des contraintes sur les
1674+attributs de vos composants. Ces types de règles sont appelés des `invariants`.
1675+Vous pouvez utiliser ``zope.interface.invariant`` pour définir des
1676+``invariants`` sur vos objets dans leur interface.
1677+
1678+Considérons un exemple simple, avec un objet `person`. Une objet `person` a un
1679+attribut `nom`, un attribut `email` et un attribut `phone`. Comment peut-on
1680+implémenter une règle de validation qui oblige à définir au choix le `phone` ou
1681+l'`email` mais pas forcément les deux ?
1682+
1683+Créez tout d'abord un objet appelable, soit une simple fonction soit une
1684+instance appelable d'une classe de la façon suivante ::
1685
1686 >>> def contacts_invariant(obj):
1687 ...
1688@@ -804,8 +816,8 @@
1689 ... raise Exception(
1690 ... "At least one contact info is required")
1691
1692-Then define the `person` object's interface like this. Use the
1693-``zope.interface.invariant`` function to set the invariant::
1694+Ensuite définissez l'interface de l'objet `person` en utilisant la fonction
1695+``zope.interface.invariant`` pour définir l'invariant ::
1696
1697 >>> from zope.interface import Interface
1698 >>> from zope.interface import Attribute
1699@@ -819,7 +831,8 @@
1700 ...
1701 ... invariant(contacts_invariant)
1702
1703-Now use `validateInvariants` method of the interface to validate::
1704+Maintenant, utilisez la méthode `validateInvariants` de l'interface pour
1705+effectuer la validation ::
1706
1707 >>> from zope.interface import implements
1708
1709@@ -839,37 +852,34 @@
1710 ...
1711 Exception: At least one contact info is required
1712
1713-As you can see `jack` object validated without raising any
1714-exception. But `jill` object didn't validated the invariant
1715-constraint, so it raised exception.
1716-
1717-.. [#patternbook] http://en.wikipedia.org/wiki/Design_Patterns
1718-.. [#api] http://en.wikipedia.org/wiki/Application_programming_interface
1719-
1720-
1721-Adapters
1722---------
1723-
1724-
1725-Implementation
1726+Vous constatez que l'ojet `jack` est validé sans erreur. Mais l'objet `jill` n'a
1727+pas pu valider la contrainte de l'invariant, il a donc levé une exception.
1728+
1729+
1730+Adaptateurs
1731+-----------
1732+
1733+
1734+Implémentation
1735 ~~~~~~~~~~~~~~
1736
1737-This section will describe adapters in detail. Zope component
1738-architecture, as you noted, helps to effectively use Python objects.
1739-Adapter components are one of the basic components used by Zope
1740-component architecture for effectively using Python objects. Adapter
1741-components are Python objects, but with well defined interface.
1742+Cette section décrit les adaptateurs en détail. L'Architecture de Composants,
1743+comme vous l'avez remarqué, fournit une aide dans l'utilisation efficace des objets
1744+Python. Les composants adaptateurs sont l'un des composants basiques utilisés
1745+par l'Architecture de Composants de Zope pour utiliser efficacement des objets
1746+Python. Les adaptateurs sont aussi des objets Python, mais avec une interface bien
1747+définie.
1748
1749-To declare a class is an adapter use `adapts` function defined in
1750-``zope.component`` package. Here is a new `GuestRegistrarNG` adapter
1751-with explicit interface declaration::
1752+Pour déclarer qu'une classe est un adaptateur, utilisez la fonction `adapts`
1753+définie dans le paquet ``zope.component``. Voici un nouvel adaptateur
1754+`FrontDeskNG` avec une déclaration explicite d'interface ::
1755
1756 >>> from zope.interface import implements
1757 >>> from zope.component import adapts
1758
1759- >>> class GuestRegistrarNG(object):
1760+ >>> class FrontDeskNG(object):
1761 ...
1762- ... implements(IRegistrar)
1763+ ... implements(IDesk)
1764 ... adapts(IGuest)
1765 ...
1766 ... def __init__(self, guest):
1767@@ -878,17 +888,16 @@
1768 ... def register(self):
1769 ... guest = self.guest
1770 ... next_id = get_next_id()
1771- ... guests_db[next_id] = {
1772+ ... bookings_db[next_id] = {
1773 ... 'name': guest.name,
1774 ... 'place': guest.place,
1775 ... 'phone': guest.phone
1776 ... }
1777
1778
1779-What you defined here is an `adapter` for `IRegistrar`, which adapts
1780-`IGuest` object. The `IRegistrar` interface is implemented by
1781-`GuestRegistrarNG` class. So, an instance of this class will provide
1782-`IRegistrar` interface.
1783+Ce que nous avons défini ici est un `adaptateur` pour `IDesk`, qui s'adapte à
1784+l'objet `IGuest`. L'interface `IDesk` est implémentée par la classe
1785+`FrontDeskNG`. Donc une instance de cette classe fournira l'interface `IDesk`.
1786
1787 ::
1788
1789@@ -901,252 +910,254 @@
1790 ... self.place = place
1791
1792 >>> jack = Guest("Jack", "Bangalore")
1793- >>> jack_registrar = GuestRegistrarNG(jack)
1794+ >>> jack_frontdesk = FrontDeskNG(jack)
1795
1796- >>> IRegistrar.providedBy(jack_registrar)
1797+ >>> IDesk.providedBy(jack_frontdesk)
1798 True
1799
1800-The `GuestRegistrarNG` is just one adapter you created, you can also
1801-create other adapters which handles guest registration differently.
1802-
1803-
1804-Registration
1805-~~~~~~~~~~~~
1806-
1807-To use this adapter component, you have to register this in a
1808-component registry also known as site manager. A site manager
1809-normally resides in a site. A site and site manager will be more
1810-important when developing a Zope 3 application. For now you only
1811-required to bother about global site and global site manager ( or
1812-component registry). A global site manager will be in memory, but a
1813-local site manager is persistent.
1814-
1815-To register your component, first get the global site manager::
1816+`FrontDeskNG` est juste un adaptateur que nous avons créé. Vous pouvez créer
1817+d'autres adaptateurs qui prendront en charge le bureau d'enregistrement différemment.
1818+
1819+
1820+Inscription
1821+~~~~~~~~~~~
1822+
1823+Pour utiliser ce composant adaptateur, vous devez l'inscrire dans un registre de
1824+composants (appelé également « gestionnaire de site »). Un gestionnaire de site
1825+réside normalement à l'intérieur d'un site. Le site et le gestionnaire de site
1826+prendront leur importance lors du développement d'une application Zope 3. Pour
1827+l'instant vous avez juste besoin de connaître les notions de site global et de
1828+gestionnaire global de site (ou registre de composant). Un gestionnaire global
1829+de site est situé en mémoire, alors qu'un gestionnaire de site local est
1830+persistant.
1831+
1832+Pour inscrire votre composant, commencez par récupérer le gestionnaire global de
1833+site ::
1834
1835 >>> from zope.component import getGlobalSiteManager
1836 >>> gsm = getGlobalSiteManager()
1837- >>> gsm.registerAdapter(GuestRegistrarNG,
1838- ... (IGuest,), IRegistrar, 'ng')
1839-
1840-To get the global site manager, you have to call
1841-``getGlobalSiteManager`` function available in ``zope.component``
1842-package. In fact, the global site manager is available as an
1843-attribute (``globalSiteManager``) of ``zope.component`` package. So,
1844-you can directly use ``zope.component.globalSiteManager`` attribute.
1845-To register the adapter in component, as you can see above, use
1846-``registerAdapter`` method of component registry. The first argument
1847-should be your adapter class/factory. The second argument is a tuple
1848-of `adaptee` objects, i.e, the object which you are adapting. In this
1849-example, you are adapting only `IGuest` object. The third argument is
1850-the interface provided by the adapter component. The fourth argument
1851-is optional, that is the name of the particular adapter. Since you
1852-gave a name for this adapter, this is a `named adapter`. If name is
1853-not given, it will default to an empty string ('').
1854-
1855-In the above registration, you have given the adaptee interface and
1856-interface to be provided by the adapter. Since you have already given
1857-these details in adapter implementation, it is not required to specify
1858-again. In fact, you could have done the registration like this::
1859-
1860- >>> gsm.registerAdapter(GuestRegistrarNG, name='ng')
1861-
1862-There are some old API to do the registration, which you should avoid.
1863-The old API functions starts with `provide`, eg: ``provideAdapter``,
1864-``provideUtility`` etc. While developing a Zope 3 application you can
1865-use Zope configuration markup language (ZCML) for registration of
1866-components. In Zope 3, local components (persistent components) can
1867-be registered from Zope Management Interface (ZMI) or you can do it
1868-programmatically also.
1869-
1870-You registered `GuestRegistrarNG` with a name `ng`. Similarly you can
1871-register other adapters with different names. If a component is
1872-registered without name, it will default to an empty string.
1873+ >>> gsm.registerAdapter(FrontDeskNG,
1874+ ... (IGuest,), IDesk, 'ng')
1875+
1876+Pour récupérer le gestionnaire global de site, vous devez appeler la fonction
1877+``getGlobalSiteManager` disponible dans le paquet ``zope.component``.
1878+En fait, le gestionnaire global de site est disponible dans un attribut
1879+(``globalSiteManager``) du paquet ``zope.component``. Vous pouvez donc utiliser
1880+directement l'attribut ``zope.component.globalSiteManager``.
1881+Pour inscrire l'adaptateur comme un composant, utilisez la méthode
1882+``registerAdapter`` du registre de composants. Le premier argument doit être
1883+votre classe ou fabrique d'adaptateur. Le deuxième argument est un tuple d'objets
1884+adaptés, c'est à dire les objets sur lesquels vous vous adaptez. Dans cet
1885+exemple, vous vous adaptez seulement à l'objet `IGuest`. Le troisième argument
1886+est l'interface implémentée par le composant adaptateur. Le quatrième argument
1887+est optionnel, il s'agit du nom de cet adaptateur particulier. Si vous donnez un
1888+nom à l'adaptateur, celui devient un `adaptateur nommé`. Si aucun nom n'est
1889+donné, la valeur transmise par défaut est une chaîne vide ('').
1890+
1891+Dans l'inscription ci-dessus, vous avez donné l'interface de l'objet adapté et
1892+l'interface fournie par l'adaptateur. Comme vous avez déjà donné ces
1893+informations dans l'implémentation de l'adaptateur, il est inutile de les
1894+spécifier à nouveau. En réalité, vous pouvez effectuer l'inscription de la
1895+manière suivante ::
1896+
1897+ >>> gsm.registerAdapter(FrontDeskNG, name='ng')
1898+
1899+Pour effectuer l'inscription, il existe d'anciennes API que vous devriez
1900+éviter. Les fonctions de l'ancienne API commencent par `provide`, par exemple :
1901+``provideAdapter``, ``provideUtility``, etc. Si vous développez une application
1902+Zope 3, vous pouvez utiliser le langage ZCML (Zope Configuration Markup
1903+Language) pour effectuer les inscriptions des composants. Avec Zope 3, les
1904+composants locaux (persistants) peut être inscrits depuis la ZMI (Zope
1905+Management Interface), ou bien par programmation.
1906+
1907+Vous avez inscrit `FrontDeskNG` avec le nom `ng`. De la même manière, vous
1908+pouvez inscrire d'autre adaptateurs avec différents noms. Si un composant est
1909+inscrit sans nom, son nom sera la chaîne vide par défaut.
1910
1911 .. note::
1912
1913- Local components are persistent components but global components are
1914- in memory. Global components will be registered based on the
1915- configuration of application. Local components are taken to memory
1916- from database while starting the application.
1917-
1918-
1919-Querying adapter
1920-~~~~~~~~~~~~~~~~
1921-
1922-Retrieving registered components from component registry is achieved
1923-through two functions available in ``zope.component`` package. One of
1924-them is ``getAdapter`` and the other is ``queryAdapter`` . Both
1925-functions accepts same arguments. The ``getAdapter`` will raise
1926-``ComponentLookupError`` if component lookup fails on the other hand
1927-``queryAdapter`` will return `None`.
1928-
1929-You can import the methods like this::
1930+ Les composants locaux sont persistants mais les composants globaux sont en
1931+ mémoire. Les composants globaux sont inscrits en fonction de la configuration de
1932+ l'application. Les composants locaux sont récupérés dans la base de données au
1933+ démarrage de l'application.
1934+
1935+
1936+récupération d'un adaptateur
1937+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1938+
1939+La récupération des composants inscrits dans le registre est effectuée grâce à
1940+deux fonctions disponibles dans le paquet ``zope.component``. La première est
1941+``getAdapter``, la deuxième ``queryAdapter``. Les deux fonctions prennent les
1942+mêmes arguments. ``getAdapter`` lève une exception ``ComponentLookupError`` si
1943+la recherche de composant échoue, tandis que ``queryAdapter`` renvoie `None`.
1944+
1945+Vous pouvez importer ces fonctions comme ceci ::
1946
1947 >>> from zope.component import getAdapter
1948 >>> from zope.component import queryAdapter
1949
1950-In the previous section you have registered a component for guest
1951-object (adaptee) which provides `IRegistrar` interface with name as
1952-'ng'. In the first section of this chapter, you have created a guest
1953-object named `jack` .
1954-
1955-This is how you can retrieve a component which adapts the interface of
1956-`jack` object (`IGuest`) and provides `IRegistrar` interface also with
1957-name as 'ng'. Here both ``getAdapter`` and ``queryAdapter`` works
1958-similarly::
1959-
1960- >>> getAdapter(jack, IRegistrar, 'ng') #doctest: +ELLIPSIS
1961- <GuestRegistrarNG object at ...>
1962- >>> queryAdapter(jack, IRegistrar, 'ng') #doctest: +ELLIPSIS
1963- <GuestRegistrarNG object at ...>
1964-
1965-As you can see, the first argument should be adaptee then, the
1966-interface which should be provided by component and last the name of
1967-adapter component.
1968-
1969-If you try to lookup the component with an name not used for
1970-registration but for same adaptee and interface, the lookup will fail.
1971-Here is how the two methods works in such a case::
1972-
1973- >>> getAdapter(jack, IRegistrar, 'not-exists') #doctest: +ELLIPSIS
1974+Dans la section précédente, nous avons inscrit un composant qui fournit
1975+l'interface `IDesk` avec un nom `ng`, et qui s'adapte à l'objet guest.
1976+Dans la première section nous avons créé un objet nommé `jack`.
1977+
1978+Voici maintenant comment récupérer un composant qui s'adapte à l'interface de l'objet
1979+`jack` (`IGuest`) et qui fournit l'interface `IDesk` également avec le nom `ng`.
1980+Ici, ``getAdapter`` et ``queryAdapter`` fonctionnent de la même manière ::
1981+
1982+ >>> getAdapter(jack, IDesk, 'ng') #doctest: +ELLIPSIS
1983+ <FrontDeskNG object at ...>
1984+ >>> queryAdapter(jack, IDesk, 'ng') #doctest: +ELLIPSIS
1985+ <FrontDeskNG object at ...>
1986+
1987+Vous pouvez constater que le premier argument doit être l'objet adapté, puis
1988+l'interface qui doit être fournie par le composant et finalement le nom du
1989+composant adaptateur.
1990+
1991+Si vous essayez de récupérer le composant grâce à un nom inutilisé pour
1992+l'inscription mais pour le même objet adapté et la même interface, la recherche
1993+échouera. Voici dans ce cas comment fonctionnent les deux méthodes ::
1994+
1995+ >>> getAdapter(jack, IDesk, 'not-exists') #doctest: +ELLIPSIS
1996 Traceback (most recent call last):
1997 ...
1998 ComponentLookupError: ...
1999 >>> reg = queryAdapter(jack,
2000- ... IRegistrar, 'not-exists') #doctest: +ELLIPSIS
2001+ ... IDesk, 'not-exists') #doctest: +ELLIPSIS
2002 >>> reg is None
2003 True
2004
2005-As you can see above, ``getAdapter`` raised a ``ComponentLookupError``
2006-exception, but ``queryAdapter`` returned `None` when lookup failed.
2007-
2008-The third argument, the name of registration, is optional. If the
2009-third argument is not given it will default to empty string ('').
2010-Since there is no component registered with an empty string,
2011-``getAdapter`` will raise ``ComponentLookupError`` . Similarly
2012-``queryAdapter`` will return `None`, see yourself how it works::
2013-
2014- >>> getAdapter(jack, IRegistrar) #doctest: +ELLIPSIS
2015+``getAdapter`` a levé une exception ``ComponentLookupError`` mais
2016+``queryAdapter`` a renvoyé `None`.
2017+
2018+Le troisième argument, le nom d'inscription, est optionnel. Si le troisième
2019+argument n'est pas fourni, sa valeur par défaut est la chaîne vide (''). Comme
2020+il n'y a aucun composant inscrit avec la chaîne vide comme nom, ``getAdapter``
2021+lève l'exception ``ComponentLookupError``. De la même manière, ``queryAdapter``
2022+renvoie `None`. Voyez vous-même comment cela fonctionne ::
2023+
2024+ >>> getAdapter(jack, IDesk) #doctest: +ELLIPSIS
2025 Traceback (most recent call last):
2026 ...
2027 ComponentLookupError: ...
2028- >>> reg = queryAdapter(jack, IRegistrar) #doctest: +ELLIPSIS
2029+ >>> reg = queryAdapter(jack, IDesk) #doctest: +ELLIPSIS
2030 >>> reg is None
2031 True
2032
2033-In this section you have learned how to register a simple adapter and
2034-how to retrieve it from component registry. These kind of adapters is
2035-called single adapter, because it adapts only one adaptee. If an
2036-adapter adapts more that one adaptee, then it is called multi
2037-adapter.
2038-
2039-
2040-Retrieving adapter using interface
2041-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2042-
2043-Adapters can be directly retrieved using interfaces, but it will only
2044-work for non-named single adapters. The first argument is the adaptee
2045-and the second argument is a keyword argument. If adapter lookup
2046-fails, second argument will be returned.
2047-
2048- >>> IRegistrar(jack, alternate='default-output')
2049- 'default-output'
2050-
2051- Keyword name can be omitted:
2052-
2053- >>> IRegistrar(jack, 'default-output')
2054- 'default-output'
2055-
2056- If second argument is not given, it will raise `TypeError`:
2057-
2058- >>> IRegistrar(jack) #doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
2059+Dans cette section, vous avez appris à inscrire un simple adaptateur et à le
2060+récupérer depuis le registre de composants. Ce type d'adaptateurs est appelé un
2061+adaptateur simple, car il ne s'adapte qu'à un seul objet. Si un adaptateur
2062+s'adapte à plusieurs objets, on l'appelle un multi-adaptateur.
2063+
2064+
2065+Récupérer un adaptateur en utilisant l'interface
2066+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2067+
2068+Les adaptateurs peuvent être récupérés directement en utilisant les interfaces,
2069+mais cela ne fonctionne qu'avec les adaptateurs simples. Le premier argument est
2070+l'objet adapté, le deuxième argument est un argument mot-clé. Si la recheche
2071+d'adaptateur échoue, le deuxième argument est renvoyé.
2072+
2073+ >>> IDesk(jack, alternate='default-output')
2074+ 'default-output'
2075+
2076+ Le mot-clé peut être omis :
2077+
2078+ >>> IDesk(jack, 'default-output')
2079+ 'default-output'
2080+
2081+ Si le deuxième argument n'est pas fourni, une erreur `TypeError` est levée :
2082+
2083+ >>> IDesk(jack) #doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
2084 Traceback (most recent call last):
2085 ...
2086 TypeError: ('Could not adapt',
2087 <Guest object at ...>,
2088- <InterfaceClass __builtin__.IRegistrar>)
2089-
2090- Here `GuestRegistrarNG` is registered without name:
2091-
2092- >>> gsm.registerAdapter(GuestRegistrarNG)
2093-
2094- Now the adapter lookup should succeed:
2095-
2096- >>> IRegistrar(jack, 'default-output') #doctest: +ELLIPSIS
2097- <GuestRegistrarNG object at ...>
2098-
2099-For simple cases, you may use interface to get adapter components.
2100-
2101-
2102-Adapter pattern
2103-~~~~~~~~~~~~~~~
2104-
2105-The adapter concept in Zope Component Architecture and the classic
2106-`adapter pattern` as described in Design Patterns book are very
2107-similar. But the intent of ZCA adapter usage is more wider than the
2108-`adapter pattern` itself. The intent of `adapter pattern` is to
2109-convert the interface of a class into another interface clients
2110-expect. This allows classes work together that couldn't otherwise
2111-because of incompatible interfaces. But in the `motivation` section
2112-of Degisgn Patterns book, GoF says: "Often the adapter is responsible
2113-for functionality the adapted class doesn't provide". ZCA adapter has
2114-more focus on adding functionalities than creating a new interface for
2115-an adapted object (adaptee). ZCA adapter lets adapter classes extend
2116-functionality by adding methods. (It would be interesting to note
2117-that `Adapter` was known as `Feature` in earlier stage of ZCA
2118-design. ) [#feature]_
2119-
2120-The above paragraph has a quote from Gang of Four book, it ends like
2121-this: " ...adapted class doesn't provide". But in the next sentence I
2122-used "adapted object" instead of "adapted class", because GoF
2123-describes about two variants of adapters based on implementations.
2124-The first one is called `class adapter` and the other one is called
2125-`object adapter`. A class adapter uses multiple inheritance to adapt
2126-one interface to another, on the other hand an object adapter relies
2127-on object composition. ZCA adapter is following object adapter
2128-pattern, which use delegation as a mechanism for composition. GoF's
2129-second principle of object-oriented design goes like this: "Favor
2130-object composition over class inheritance". For more details about
2131-this subject please read Design Patterns book.
2132-
2133-The major attraction of ZCA adapter are the explicit interface for
2134-components and the component registry. ZCA adapter components are
2135-registered in component registry and looked up by client objects using
2136-interface and name when required.
2137+ <InterfaceClass __builtin__.IDesk>)
2138+
2139+ Ici, `FrontDeskNG` est inscrit sans nom :
2140+
2141+ >>> gsm.registerAdapter(FrontDeskNG)
2142+
2143+ Maintenant la récupération de l'adaptateur doit réussir :
2144+
2145+ >>> IDesk(jack, 'default-output') #doctest: +ELLIPSIS
2146+ <FrontDeskNG object at ...>
2147+
2148+Pour les cas simples, vous pouvez utiliser l'interface pour récupérer des
2149+adaptateurs.
2150+
2151+
2152+Motif adaptateur
2153+~~~~~~~~~~~~~~~~
2154+
2155+Le principe de l'adaptateur dans l'Architecture de Composants de Zope est très
2156+similaire au `motif adaptateur` classique, tel que décrit dans le livre « Design
2157+Patterns ». Mais l'objectif visé par l'utilisation des adaptateurs dans la ZCA
2158+est plus large que le principe de l'adaptateur lui-même. Le but de l'adaptateur
2159+est de convertir l'interface d'une classe en une autre interface attendue par le
2160+client. Ceci permet de faire fonctionner des classes ensemble même si elles ont
2161+des interfaces incompatibles entre elles. Mais dans la section `motivations` du
2162+livre « Design Patterns », le GoF dit : « souvent, l'adaptateur est responsable
2163+d'une fonctionnalité que la classe adaptée ne fournit pas ». Un adaptateur de la
2164+ZCA se concentre effectivement plus sur l'ajout de fonctionnalités que sur la
2165+création d'une nouvelle interface pour un objet adapté. L'adaptateur de la ZCA
2166+permet aux classes adaptateurs d'étendre des fonctionnalités par ajout de
2167+méthodes. (Il peut être intéressant de remarquer que l'adaptateur était appelé
2168+`Fonctionnalité` (`feature`) dans les premières étapes de conception de la ZCA.) [#feature]_
2169
2170 .. [#feature] Thread discussing renaming of `Feature` to `Adapter`:
2171 http://mail.zope.org/pipermail/zope3-dev/2001-December/000008.html
2172
2173-
2174-Utility
2175--------
2176+La citation du Gang of Four dans le paragraphe ci-dessus se termine de la façon
2177+suivante : « ... que la classe adaptée ne fournit pas ». Mais dans la phrase
2178+suivante nous avons utilisé « objet adapté » plutôt que « classe adaptée », car
2179+le GoF décrit deux variantes d'adaptateurs selon les implémentations.
2180+Le premier est appelé `adaptateur de classe`, le deuxième `adaptateur d'objet`.
2181+Un adaptateur de classe utilise l'héritage multiple pour adapter une interface à
2182+une autre, alors que l'adaptateur d'objet se base sur la composition d'objet.
2183+L'adaptateur de la ZCA utilise le principe de l'adaptateur d'objet, qui utilise
2184+la délégation comme mécanisme de composition. Le second principe du GoF à propos
2185+de la conception orientée objets est la suivante : « favorisez la composition
2186+d'objets plutôt que l'héritage de classes ». Pour approfondir le sujet,
2187+reportez-vous au livre « Design Patterns ».
2188+
2189+Les principaux atouts des adaptateurs de la ZCA sont les interfaces explicites
2190+et les registres de composants. Les composants adaptateurs de la ZCA sont inscrits
2191+dans le registre de composants et sont récupérés par les objets clients via leur
2192+interface et leur nom si besoin.
2193+
2194+
2195+Utilitaires
2196+-----------
2197
2198
2199 Introduction
2200 ~~~~~~~~~~~~
2201
2202-Now you know the concept of interface, adapter and component registry.
2203-Sometimes it would be useful to register an object which is not
2204-adapting anything. Database connection, XML parser, object returning
2205-unique Ids etc. are examples of these kinds of objects. These kind of
2206-components provided by Zope component architecture are called
2207-``utility`` components.
2208-
2209-Utilities are just objects that provide an interface and that are
2210-looked up by an interface and a name. This approach creates a global
2211-registry by which instances can be registered and accessed by
2212-different parts of your application, with no need to pass the
2213-instances around as parameters.
2214-
2215-You need not to register all component instances like this. Only
2216-register components which you want to make replaceable.
2217-
2218-
2219-Simple utility
2220-~~~~~~~~~~~~~~
2221-
2222-Before implementing the utility, as usual, define its interface. Here
2223-is a `greeter` interface::
2224+Vous connaissez maintenant le principe des interfaces, des adaptateurs et du
2225+registre de composants. Parfois, il peut être utile d'inscrire un objet qui ne
2226+s'adapte à rien du tout, par exemple une connexion à une base de données, un analyseur XML
2227+ou un objet retournant des identifiants uniques. Ce type de composant
2228+fourni par la ZCA est appelé un « utilitaire » (*utility*).
2229+
2230+Les utilitaires sont simplement des objets qui fournissent une interface et qui sont
2231+récupérés à partir de cette interface et d'un nom. Cette approche permet de créer
2232+un registre global dans lequel des instances peuvent être inscrites et
2233+récupérées à différents endroits de votre application, sans avoir besoin de
2234+transmettre les instances comme paramètres.
2235+
2236+Vous n'avez pas besoin d'inscrire toutes les instances de composants de cette
2237+façon. Inscrivez seulement les composants que vous voulez rendre
2238+interchangeables.
2239+
2240+
2241+Utilitaire simple
2242+~~~~~~~~~~~~~~~~~
2243+
2244+Un utilitaire peut être inscrit avec ou sans nom. Un utilitaire inscrit avec un nom
2245+est appelé un `utilitaire nommé`. Vous le verrez dans la prochaine section.
2246+Avant d'implémenter l'utilitaire, comme d'habitude, définissez son interface.
2247+Voici une interface qui dit bonjour ::
2248
2249 >>> from zope.interface import Interface
2250 >>> from zope.interface import implements
2251@@ -1154,9 +1165,10 @@
2252 >>> class IGreeter(Interface):
2253 ...
2254 ... def greet(name):
2255- ... "say hello"
2256+ ... """Say hello"""
2257
2258-Here is a possible implementation of the above interface::
2259+Comme un adaptateur, un utilitaire peut avoir plusieurs implémentations. Voici
2260+une implémentation possible de l'interface ci-dessus ::
2261
2262 >>> class Greeter(object):
2263 ...
2264@@ -1165,7 +1177,10 @@
2265 ... def greet(self, name):
2266 ... return "Hello " + name
2267
2268-You can register an instance of this class using ``registerUtility``::
2269+L'utilitaire réel sera une instance de cette classe. Pour utiliser cet
2270+utilitaire, vous devez l'inscrire, puis vous pourrez la récupérer en
2271+utilisant l'API de la ZCA. Vous pouvez inscrire une instance de cette classe
2272+(`utilitaire`) grâce à ``registerUtility`` ::
2273
2274 >>> from zope.component import getGlobalSiteManager
2275 >>> gsm = getGlobalSiteManager()
2276@@ -1173,9 +1188,9 @@
2277 >>> greet = Greeter()
2278 >>> gsm.registerUtility(greet, IGreeter)
2279
2280-In this example you registered the utility as providing the `IGreeter`
2281-interface. You can look the interface up with either `queryUtility`
2282-or `getUtility`::
2283+Dans cet exemple, vous avez inscrit l'utilitaire en fournissant l'interface
2284+`IGreeter`. Vous pouvez récupérer l'utilitaire avec `queryUtility` ou
2285+`getUtility` ::
2286
2287 >>> from zope.component import queryUtility
2288 >>> from zope.component import getUtility
2289@@ -1186,24 +1201,27 @@
2290 >>> getUtility(IGreeter).greet('Jack')
2291 'Hello Jack'
2292
2293-As you can see, adapters are normally classes, but utilities are
2294-normally instances of classes.
2295-
2296-
2297-Named utility
2298-~~~~~~~~~~~~~
2299-
2300-When registering a utility component, like adapter, you can use a
2301-name.
2302-
2303-For example consider this:
2304+Comme vous pouvez le constater, alors que les adaptateurs sont habituellement
2305+des classes, les utilitaires sont habituellement des instances de classes. vous
2306+ne créez une instance d'utilitaire qu'une fois, alors que les instances
2307+d'adaptateurs sont créées à chaque fois que vous les récupérez.
2308+
2309+
2310+Utilitaire nommé
2311+~~~~~~~~~~~~~~~~
2312+
2313+Lorsque vous inscrivez un composant utilitaire, de la même manière que pour les
2314+adaptateurs, vous pouvez utiliser un nom. Comme mentionné dans la section
2315+précédente, un utilitaire inscrit avec un nom est appelé un `utilitaire nommé`.
2316+
2317+Voici comment inscrire l'utilitaire `greeter` avec un nom ::
2318
2319 >>> greet = Greeter()
2320 >>> gsm.registerUtility(greet, IGreeter, 'new')
2321
2322-In this example you registered the utility with a name as providing
2323-the `IGreeter` interface. You can look the interface up with either
2324-`queryUtility` or `getUtility`::
2325+Dans cet exemple, nous avons inscrit l'utilitaire avec un nom en fournissant
2326+l'interface `IGreeter`. Vous pouvez récupérer l'utilitaire avec `queryUtility`
2327+ou `getUtility` ::
2328
2329 >>> from zope.component import queryUtility
2330 >>> from zope.component import getUtility
2331@@ -1214,28 +1232,25 @@
2332 >>> getUtility(IGreeter, 'new').greet('Jill')
2333 'Hello Jill'
2334
2335-As you can see here, while querying you have to use the `name` as
2336-second argument.
2337-
2338-.. note::
2339-
2340- Calling `getUtility` function without a name (second argument) is
2341- equivalent to calling with an empty string ('') as the name.
2342- Because, the default value for second (keyword) argument is an empty
2343- string. Then, component lookup mechanism will try to find the
2344- component with name as empty string (''), and it will fail. When
2345- component lookup fails it will raise `ComponentLookupError`
2346- exception. Remember, it will not return some random component
2347- registered with some other name.
2348-
2349-
2350-Factory
2351-~~~~~~~
2352-
2353-A ``Factory`` is a utility component which provides ``IFactory``
2354-interface.
2355-
2356-To create a factory, first define the interface of the object::
2357+Remarquez que vous devez utiliser le nom de l'utilitaire comme second argument
2358+pour que la récupération fonctionne.
2359+
2360+Appeler `getUtility` sans nom (comme second argument) est équivalent à l'appeler
2361+avec un nom vide (''), car la valeur par défaut pour ce second argument est
2362+justement la chaîne vide. Donc le mécanisme de recherche de composant essaiera
2363+de trouver le composant ayant une chaîne vide comme nom et il échouera.
2364+Lorsqu'une recherche de composant échoue, le résultat est une exception
2365+``ComponentLookupError``. Souvenez-vous qu'aucun composant aléatoire avec un
2366+autre nom ne sera renvoyé. Les fonctions de récupération d'adaptateurs,
2367+`getAdapter` et `queryUtility` fonctionnent de manière similaire.
2368+
2369+
2370+Fabrique
2371+~~~~~~~~
2372+
2373+Une ``fabrique`` est un composant utilitaire qui fournit l'interface ``IFactory``.
2374+
2375+Pour créer une fabrique, commencez par définir l'interface de l'objet ::
2376
2377 >>> from zope.interface import Attribute
2378 >>> from zope.interface import Interface
2379@@ -1246,7 +1261,7 @@
2380 ... def getConnection():
2381 ... """Return connection object"""
2382
2383-Here is fake implementation of `IDatabase` interface::
2384+Voici une implémentation factice de l'interface `IDatabase` ::
2385
2386 >>> class FakeDb(object):
2387 ...
2388@@ -1255,13 +1270,13 @@
2389 ... def getConnection(self):
2390 ... return "connection"
2391
2392-You can create a factory using ``zope.component.factory.Factory``::
2393+Vous pouvez créer une fabrique en utilisant ``zope.component.factory.Factory`` ::
2394
2395 >>> from zope.component.factory import Factory
2396
2397 >>> factory = Factory(FakeDb, 'FakeDb')
2398
2399-Now you can register it like this::
2400+Maintenant vous pouvez l'inscrire de cette façon ::
2401
2402 >>> from zope.component import getGlobalSiteManager
2403 >>> gsm = getGlobalSiteManager()
2404@@ -1269,29 +1284,32 @@
2405 >>> from zope.component.interfaces import IFactory
2406 >>> gsm.registerUtility(factory, IFactory, 'fakedb')
2407
2408-To use the factory, you may do it like this::
2409+Pour utiliser la fabrique, vous pouvez faire comme ceci ::
2410
2411 >>> from zope.component import queryUtility
2412 >>> queryUtility(IFactory, 'fakedb')() #doctest: +ELLIPSIS
2413 <FakeDb object at ...>
2414
2415-There is a shortcut to use factory::
2416+Voici l'écriture simplifiée pour utiliser une fabrique ::
2417
2418 >>> from zope.component import createObject
2419 >>> createObject('fakedb') #doctest: +ELLIPSIS
2420 <FakeDb object at ...>
2421
2422
2423-Advanced adapters
2424------------------
2425-
2426-
2427-Multi adapter
2428-~~~~~~~~~~~~~
2429-
2430-A simple adapter normally adapts only one object, but an adapter can
2431-adapt more than one object. If an adapter adapts more than one
2432-objects, it is called as multi-adapter.
2433+Adaptateurs avancés
2434+-------------------
2435+
2436+Ce chapître traite de concepts avancés comme les multi-adaptateurs, les
2437+abonnés (subscribers) et les gestionnaires (handles).
2438+
2439+
2440+Multi-adaptateur
2441+~~~~~~~~~~~~~~~~
2442+
2443+Un adaptateur simple s'adapte normalement à un seul objet, mais un adaptateur
2444+peut s'adapter à plusieurs objets. Si un adaptateur s'adapte à plus d'un objet,
2445+il s'appelle un multi-adaptateur.
2446
2447 ::
2448
2449@@ -1342,16 +1360,16 @@
2450 <Two object at ...>
2451
2452
2453-Subscription adapter
2454-~~~~~~~~~~~~~~~~~~~~
2455-
2456-Unlike regular adapters, subscription adapters are used when we want
2457-all of the adapters that adapt an object to a particular adapter.
2458-Subscription adapter is also known as `subscriber` .
2459-
2460-Consider a validation problem. We have objects and we want to assess
2461-whether they meet some sort of standards. We define a validation
2462-interface::
2463+Adaptateur d'abonnement
2464+~~~~~~~~~~~~~~~~~~~~~~~
2465+
2466+À la différence des adaptateurs habituels, les adaptateurs d'abonnement sont
2467+utilisés quand on veut récupérer tous les adaptateurs qui adaptent un objet à
2468+une interface donnée. Un adaptateur d'abonnement est également appelé `abonné`.
2469+
2470+Considérons un problème de validation. Nous avons des objets et nous voulons
2471+vérifier s'ils satisfont à un certain critère. Nous définissons une interface
2472+de validation ::
2473
2474 >>> from zope.interface import Interface
2475 >>> from zope.interface import Attribute
2476@@ -1367,7 +1385,7 @@
2477 ... object is valid.
2478 ... """
2479
2480-Perhaps we have documents::
2481+Nous avons également des documents ::
2482
2483 >>> class IDocument(Interface):
2484 ...
2485@@ -1381,9 +1399,9 @@
2486 ... def __init__(self, summary, body):
2487 ... self.summary, self.body = summary, body
2488
2489-Now, we may want to specify various validation rules for
2490-documents. For example, we might require that the summary be a single
2491-line:
2492+Maintenant, nous pouvons avoir besoin de préciser différentes règles de
2493+validation pour les documents. Par exemple, nous voulons que le résumé tienne
2494+sur une seule ligne ::
2495
2496 >>> from zope.component import adapts
2497
2498@@ -1401,7 +1419,7 @@
2499 ... else:
2500 ... return ''
2501
2502-Or we might require the body to be at least 1000 characters in length:
2503+Ou bien nous voulons que le corps du document fasse au moins 1000 caractères ::
2504
2505 >>> class AdequateLength(object):
2506 ...
2507@@ -1417,7 +1435,7 @@
2508 ... else:
2509 ... return ''
2510
2511-We can register these as subscription adapters:
2512+Nous pouvons inscrire ces deux composants comme des adaptateurs d'abonnement ::
2513
2514 >>> from zope.component import getGlobalSiteManager
2515 >>> gsm = getGlobalSiteManager()
2516@@ -1425,7 +1443,7 @@
2517 >>> gsm.registerSubscriptionAdapter(SingleLineSummary)
2518 >>> gsm.registerSubscriptionAdapter(AdequateLength)
2519
2520-We can then use the subscribers to validate objects:
2521+Nous pouvons ensuite utiliser ces abonnés pour valider les objets ::
2522
2523 >>> from zope.component import subscribers
2524
2525@@ -1448,36 +1466,37 @@
2526 ['too short']
2527
2528
2529-Handler
2530-~~~~~~~
2531-
2532-Handlers are subscription adapter factories that don't produce
2533-anything. They do all of their work when called. Handlers are
2534-typically used to handle events. Handlers are also known as event
2535-subscribers or event subscription adapters.
2536-
2537-Event subscribers are different from other subscription adapters in
2538-that the caller of event subscribers doesn't expect to interact with
2539-them in any direct way. For example, an event publisher doesn't
2540-expect to get any return value. Because subscribers don't need to
2541-provide an API to their callers, it is more natural to define them
2542-with functions, rather than classes. For example, in a
2543-document-management system, we might want to record creation times for
2544-documents::
2545+Gestionnaire
2546+~~~~~~~~~~~~
2547+
2548+Les gestionnaires sont des fabriques d'abonnés qui ne
2549+produisent rien du tout. Ils font la totalité de leur travail lorsqu'ils sont
2550+appelés. Les gestionnaires sont typiquement utilisés pour gérer des événements.
2551+Les gestionnaires sont aussi connus sous le nom d'``abonnés
2552+à des événements`` ou ``adaptateurs d'abonnement à des événements``.
2553+
2554+Les abonnés à des événements sont différents des autres abonnés car l'objet qui
2555+appelle les abonnés ne s'attend pas à interagir avec eux d'une quelconque façon.
2556+Par exemple, un publicateur d'événements ne s'attend pas à récupérer une valeur
2557+de retour. Comme les abonnés n'ont pas besoin de fournir une API aux objets qui
2558+les appellent, il est plus naturel de les définir avec des fonctions, plutôt
2559+qu'avec des classes. Par exemple, dans un système de gestion de documents, nous
2560+pouvons avoir besoin de gérer les heures de création des documents ::
2561
2562 >>> import datetime
2563
2564 >>> def documentCreated(event):
2565 ... event.doc.created = datetime.datetime.utcnow()
2566
2567-In this example, we have a function that takes an event and performs
2568-some processing. It doesn't actually return anything. This is a
2569-special case of a subscription adapter that adapts an event to
2570-nothing. All of the work is done when the adapter "factory" is
2571-called. We call subscribers that don't actually create anything
2572-"handlers". There are special APIs for registering and calling them.
2573+Dans cet exemple, nous avons une fonction qui prend un événement et effectue un
2574+traitement. La fonction ne retourne en fait rien du tout. C'est un cas
2575+particulier de l'adaptateur d'abonnement qui s'adapte à un événement et ne
2576+fournit rien. Tout le travail est effectué lorsque la fabrique de l'adaptateur
2577+est appelée. Nous appelons les abonnés qui ne fabriquent rien des « gestionnaires ».
2578+Il existe des APIs spécialisées dans leur inscription et leur récupération.
2579
2580-To register the subscriber above, we define a document-created event::
2581+Pour inscrire l'abonné ci-dessus, nous définissons un événement « document créé
2582+» ::
2583
2584 >>> from zope.interface import Interface
2585 >>> from zope.interface import Attribute
2586@@ -1494,7 +1513,7 @@
2587 ... def __init__(self, doc):
2588 ... self.doc = doc
2589
2590-We'll also change our handler definition to:
2591+Nous modifions également notre définition du gestionnaire ::
2592
2593 >>> def documentCreated(event):
2594 ... event.doc.created = datetime.datetime.utcnow()
2595@@ -1505,17 +1524,18 @@
2596 ... def documentCreated(event):
2597 ... event.doc.created = datetime.datetime.utcnow()
2598
2599-This marks the handler as an adapter of `IDocumentCreated` events.
2600+Ceci marque le gestionnaire comme étant un adaptateur des événements
2601+`IDocumentCreated`.
2602
2603-Now we'll register the handler::
2604+Nous inscrivons le gestionnaire ::
2605
2606 >>> from zope.component import getGlobalSiteManager
2607 >>> gsm = getGlobalSiteManager()
2608
2609 >>> gsm.registerHandler(documentCreated)
2610
2611-Now, if we can create an event and use the `handle` function to call
2612-handlers registered for the event::
2613+Il est maintenant possible de créer un événement et d'utiliser la fonction
2614+`handle` pour appeler les gestionnaires inscrits à l'événement ::
2615
2616 >>> from zope.component import handle
2617
2618@@ -1524,29 +1544,34 @@
2619 'datetime'
2620
2621
2622-ZCA usage in Zope
2623------------------
2624+Usage de la ZCA dans Zope
2625+-------------------------
2626
2627-Zope Component Architecture is used in both Zope 3 and Zope 2. This
2628-chapter go through ZCA usage in Zope.
2629+L'Architecture de Composants de Zope est utilisée dans Zope 2 et dans Zope 3. Ce
2630+chapitre traite de l'usage de la ZCA dans Zope.
2631
2632
2633 ZCML
2634 ~~~~
2635
2636-The Zope Configuration Markup Language (ZCML) is an XML based
2637-configuration system for registration of components. So, instead of
2638-using Python API for registration, you can use ZCML. But to use ZCML,
2639-unfortunately, you will be required to install more dependency
2640-packages.
2641+Le **Zope Configuration Markup Language (ZCML)** est un système de configuration
2642+pour l'inscription des composants. Au lieu d'utiliser l'API Python pour les
2643+inscriptions, vous pouvez utiliser le ZCML. Pour pouvoir utiliser le ZCML,
2644+vous devez installer des paquets supplémentaires.
2645
2646-To install these packages::
2647+Vous pouvez installer ``zope.component`` avec la prise en charge du ZCML en
2648+utilisant easy_install comme ceci ::
2649
2650 $ easy_install "zope.component [zcml]"
2651
2652-To register an adapter::
2653+Un fichier ZCML doit commencer par une directive ``configure`` avec la
2654+déclaration d'espace de nom appropriée ::
2655
2656 <configure xmlns="http://namespaces.zope.org/zope">
2657+ ...
2658+ </configure>
2659+
2660+La directive `adapter` peut être utilisée pour inscrire des adaptateurs ::
2661
2662 <adapter
2663 factory=".company.EmployeeSalary"
2664@@ -1554,73 +1579,59 @@
2665 for=".interfaces.IEmployee"
2666 />
2667
2668-The `provides` and `for` attributes are optional, provided you have
2669-declared it in the implementation::
2670-
2671- <configure xmlns="http://namespaces.zope.org/zope">
2672+Les attributs `provides` et `for` sont optionnels, à condition que vous ayez
2673+fait les déclaration correspondantes dans l'implémentation ::
2674
2675 <adapter
2676 factory=".company.EmployeeSalary"
2677 />
2678
2679-If you want to register the component as named adapter, you can give a
2680-`name` attribute::
2681-
2682-
2683- <configure xmlns="http://namespaces.zope.org/zope">
2684+Si vous voulez inscrire le composant comme un adaptateur nommé, vous pouvez
2685+utiliser l'attribut `name` ::
2686
2687 <adapter
2688 factory=".company.EmployeeSalary"
2689 name="salary"
2690 />
2691
2692-Utilities are also registered similarly.
2693-
2694-To register an utility::
2695-
2696- <configure xmlns="http://namespaces.zope.org/zope">
2697+Un utilitaire peut être inscrit avec la directive `utility` ::
2698
2699 <utility
2700 component=".database.connection"
2701 provides=".interfaces.IConnection"
2702 />
2703
2704-The `provides` attribute is optional, provided you have declared it in
2705-the implementation::
2706-
2707- <configure xmlns="http://namespaces.zope.org/zope">
2708-
2709- <utility
2710- component=".database.connection"
2711- />
2712-
2713-If you want to register the component as named adapter, you can give a
2714-`name` attribute::
2715-
2716-
2717- <configure xmlns="http://namespaces.zope.org/zope">
2718-
2719- <utility
2720- component=".database.connection"
2721- name="Database Connection"
2722- />
2723-
2724-Instead of directly using the component, you can also give a factory::
2725-
2726- <configure xmlns="http://namespaces.zope.org/zope">
2727+L'attribut `provides` est optionnel, à condition que vous ayez fait la
2728+déclaration correspondante dans l'implémentation ::
2729+
2730+ <configure xmlns="http://namespaces.zope.org/zope">
2731+
2732+ <utility
2733+ component=".database.connection"
2734+ />
2735+
2736+Si vous voulez inscrire le composant comme un utilitaire nommé, vous pouvez
2737+utiliser l'attribut `name` ::
2738+
2739+ <utility
2740+ component=".database.connection"
2741+ name="db_connection"
2742+ />
2743+
2744+Plutôt que d'utiliser directement le composant, vous pouvez aussi fournir une
2745+fabrique ::
2746
2747 <utility
2748 factory=".database.Connection"
2749 />
2750
2751
2752-Overrides
2753-~~~~~~~~~
2754+Surchargements
2755+~~~~~~~~~~~~~~
2756
2757-When you register components using Python API (``register*`` methods),
2758-the last registered component will replace previously registered
2759-component, if both are registered with same type of arguments. For
2760-example, consider this example::
2761+Lorsque vous inscrivez des composants avec l'API Python (méthodes
2762+``register*``), le dernier composant inscrit remplace le précédent, si les deux
2763+sont inscrits avec les mêmes arguments. Considérons l'exemple suivant ::
2764
2765 >>> from zope.interface import Attribute
2766 >>> from zope.interface import Interface
2767@@ -1665,22 +1676,21 @@
2768 >>> getAdapter(a, IP) #doctest: +ELLIPSIS
2769 <AP object at ...>
2770
2771- If you register another adapter, the existing one will be replaced:
2772+Si vous inscrivez un autre adaptateur, celui existant sera surchargé ::
2773
2774 >>> gsm.registerAdapter(AP2)
2775
2776 >>> getAdapter(a, IP) #doctest: +ELLIPSIS
2777 <AP2 object at ...>
2778
2779-But when registering components using ZCML, the second registration
2780-will raise a conflict error. This is a hint for you, otherwise there
2781-is a chance for overriding registration by mistake. This may lead to
2782-hard to track bugs in your system. So, using ZCML is a win for the
2783-application.
2784+Mais lorsque vous inscrivez des composants en ZCML, la deuxième inscription
2785+provoquera un conflit. Ceci est fait pour éviter les surchargements accidentels
2786+d'inscriptions, qui sont difficiles à retrouver et corriger.
2787+L'utilisation de ZCML est donc un avantage pour votre application.
2788
2789-Sometimes you will be required to override existing registration.
2790-ZCML provides ``includeOverrides`` directive for this. Using this,
2791-you can write your overrides in a separate file::
2792+Parfois vous aurez besoin de surcharger une inscription existante. ZCML fournit
2793+une directive ``includeOverrides`` à cet effet. Avec la directive ci-dessous,
2794+vous pouvez écrire vos surcharges dans un fichier séparé ::
2795
2796 <includeOverrides file="overrides.zcml" />
2797
2798@@ -1688,12 +1698,11 @@
2799 NameChooser
2800 ~~~~~~~~~~~
2801
2802-Location: `zope.app.container.contained.NameChooser`
2803-
2804-This is an adapter for choosing a unique name for an object inside a
2805-container.
2806-
2807-The registration of adapter is like this::
2808+Emplacement : `zope.app.container.contained.NameChooser`
2809+
2810+C'est un adaptateur qui choisit un nom unique pour un objet dans un conteneur.
2811+
2812+L'inscription de l'adaptateur ressemble à ceci ::
2813
2814 <adapter
2815 provides=".interfaces.INameChooser"
2816@@ -1701,40 +1710,37 @@
2817 factory=".contained.NameChooser"
2818 />
2819
2820-From the registration, you can see that the adaptee is a
2821-``IWriteContainer`` and the adapter provides ``INameChooser``.
2822+Dans cette inscription, vous pouvez observer qu'on s'adapte à un
2823+``IWriteContainer`` et que l'adaptateur fournit ``INameChooser``.
2824
2825-This adapter provides a very convenient functionality for Zope
2826-programmers. The main implementations of ``IWriteContainer`` in
2827-Zope 3 are ``zope.app.container.BTreeContainer`` and
2828-``zope.app.folder.Folder``. Normally you will be inheriting from
2829-these implementations for creating your own container classes.
2830-Suppose there is no interface called ``INameChooser`` and
2831-adapter, then you will be required to implement this functionality
2832-for every implementations separately.
2833+Cet adaptateur fournit une fonctionnalité très pratique pour les développeurs
2834+Zope. Les implémentations principales de ``IWriteContainer`` dans Zope 3 sont
2835+`zope.app.container.BTreeContainer`` et ``zope.app.folder.Folder``. Normalement
2836+vous hériterez de ces implémentations pour créer vos propres classes de
2837+conteneurs. Supposez qu'il n'y ait pas d'interface ``INameChooser`` ni
2838+d'adaptateur : vous seriez obligé de recréer cette fonctionnalité séparément
2839+pour chaque implémentation.
2840
2841
2842 LocationPhysicallyLocatable
2843 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
2844
2845-Location:
2846+Emplacement :
2847 ``zope.location.traversing.LocationPhysicallyLocatable``
2848
2849-This adapter is frequently used in Zope 3 applications, but
2850-normally it is called through an API in ``zope.traversing.api``.
2851-(Some old code even use ``zope.app.zapi`` functions, which is
2852-again one more indirection)
2853+Cet adaptateur est fréquemment utilisé dans les applications Zope 3, mais
2854+habituellement il est appelé au travers d'une API dans ``zope.traversing.api``.
2855+(Certains vieux codes utilisent même les fonctions ``zope.app.zapi`` qui ne sont
2856+qu'une indirection supplémentaire).
2857
2858-The registration of adapter is like this::
2859+L'inscription de l'adaptateur ressemble à ceci ::
2860
2861 <adapter
2862 factory="zope.location.traversing.LocationPhysicallyLocatable"
2863 />
2864
2865-The interface provided and adaptee interface is given in the
2866-implementation.
2867-
2868-Here is the beginning of implementation::
2869+L'interface fournie et l'interface adaptée sont données dans l'implémentation,
2870+dont voici le début ::
2871
2872 class LocationPhysicallyLocatable(object):
2873 """Provide location information for location objects
2874@@ -1743,43 +1749,41 @@
2875 zope.interface.implements(IPhysicallyLocatable)
2876 ...
2877
2878-Normally, almost all persistent objects in Zope 3 application
2879-will be providing the ``ILocation`` interface. This interface
2880-has only two attribute, ``__parent__`` and ``__name__``. The
2881-``__parent__`` is the parent in the location hierarchy. And
2882-``__name__`` is the name within the parent.
2883-
2884-The ``IPhysicallyLocatable`` interface has four methods:
2885-``getRoot``, ``getPath``, ``getName``, and ``getNearestSite``.
2886-
2887- - ``getRoot`` function will return the physical root object.
2888-
2889- - ``getPath`` return the physical path to the object as a
2890- string.
2891-
2892- - ``getName`` return the last segment of the physical path.
2893-
2894- - ``getNearestSite`` return the site the object is contained
2895- in. If the object is a site, the object itself is returned.
2896-
2897-If you learn Zope 3, you can see that these are the important
2898-things which you required very often. To understand the beauty
2899-of this system, you must see how Zope 2 actually get the physical
2900-root object and how it is implemented. There is a method called
2901-``getPhysicalRoot`` virtually for all container objects.
2902+Normalement, presque tous les objets persistants d'une application Zope 3
2903+fournissent l'interface ``ILocation``. Cette interface n'a que deux attributs,
2904+``__parent__`` et ``__name__``. ``__parent__`` est le parent dans la hiérarchie
2905+des objets et ``__name__`` est le nom, vu depuis le parent.
2906+
2907+L'interface ``IPhysicallyLocatable`` a quatre méthodes:
2908+``getRoot``, ``getPath``, ``getName``, et ``getNearestSite``.
2909+
2910+ - ``getRoot`` renvoie l'objet racine physique.
2911+
2912+ - ``getPath`` renvoie une chaîne donnant le chemin physique vers l'objet.
2913+
2914+ - ``getName`` renvoie le dernier segment du chemin physique.
2915+
2916+ - ``getNearestSite`` renvoie le site dans lequel l'objet est contenu. Si
2917+ l'objet est lui-même un site, il est renvoyé.
2918+
2919+Si vous apprenez Zope 3, ce sont des choses importantes dont vous aurez besoin
2920+très souvent. Pour comprendre la beauté de ce système, vous devriez regarder
2921+comment Zope 2 récupère l'objet racine physique et comment ceci est implémenté.
2922+Il existe une méthode ``getPhysicalRoot`` virtuellement pour tous les objets
2923+conteneurs.
2924
2925
2926 DefaultSized
2927 ~~~~~~~~~~~~
2928
2929-Location: ``zope.size.DefaultSized``
2930-
2931-This adapter is just a default implementation of ``ISized`` interface.
2932-This adapter is registered for all kind of objects. If you want to
2933-register this adapter for a particular interface, then you have to
2934-override this registration for your implementation.
2935-
2936-The registration of adapter is like this::
2937+Emplacement : ``zope.size.DefaultSized``
2938+
2939+Cet adaptateur n'est qu'une implémentation par défaut de l'interface ``ISized``.
2940+Il est inscrit pour tous les types d'objets. Si vous voulez inscrire cet
2941+adaptateur pour une interface particulière, vous devez surcharger cette
2942+inscription avec votre implémentation.
2943+
2944+L'inscription de l'adaptateur ressemble à ceci ::
2945
2946 <adapter
2947 for="*"
2948@@ -1788,10 +1792,10 @@
2949 permission="zope.View"
2950 />
2951
2952-As you can see, the adaptee interface is `*`, so it can adapt any kind
2953-of objects.
2954+Comme vous pouvez voir, l'interface adaptée est « * », pour pouvoir s'adapter à
2955+tous les types d'objets.
2956
2957-The ``ISized`` is a simple interface with two method contracts::
2958+``ISized`` est une interface simple possédant deux méthodes ::
2959
2960 class ISized(Interface):
2961
2962@@ -1806,112 +1810,793 @@
2963 """Returns a string giving the size.
2964 """
2965
2966-You can see another ``ISized`` adapter registered for ``IZPTPage`` in
2967-``zope.app.zptpage`` package.
2968+Vous pouvez trouver un autre adaptateur ``ISized`` pour ``IZPTPage`` dans le
2969+paquet ``zope.app.zptpage``.
2970
2971
2972 ZopeVersionUtility
2973 ~~~~~~~~~~~~~~~~~~
2974
2975-Location: ``zope.app.applicationcontrol.ZopeVersionUtility``
2976-
2977-This utility gives version of the running Zope.
2978-
2979-The registration goes like this::
2980+Emplacement : ``zope.app.applicationcontrol.ZopeVersionUtility``
2981+
2982+Cet utilitaire donne la version de Zope en fonctionnement.
2983+
2984+L'inscription est la suivante ::
2985
2986 <utility
2987 component=".zopeversion.ZopeVersionUtility"
2988 provides=".interfaces.IZopeVersion" />
2989
2990-The interface provided, ``IZopeVersion``, has only one method named
2991-``getZopeVersion``. This method return a string containing the Zope
2992-version (possibly including SVN information).
2993-
2994-The default implementation, ``ZopeVersionUtility``, get version info
2995-from a file ``version.txt`` in `zope/app` directory. If Zope is
2996-running from subversion checkout, it will show the latest revision
2997-number. If none of the above works it will set it to:
2998-`Development/Unknown`.
2999-
3000+L'interface fournie, ``IZopeVersion``, n'a qu'une méthode nommée
3001+``getZopeVersion``. Cette méthode renvoie une chaîne contenant la version de
3002+Zope (avec éventuellement un changeset SVN).
3003+
3004+L'implémentation par défaut, ``ZopeVersionUtility``, récupère le numéro de
3005+version dans un fichier ``version.txt`` du répertoire `zope/app`. Si Zope
3006+fonctionne depuis un espace de travail Subversion, il montre le dernier numéro
3007+de révision. Si aucun des deux ne fonctionne il renvoie `DevCenter/Unknown`.
3008+
3009+
3010+Étude de cas
3011+------------
3012+
3013+.. note::
3014+
3015+ Ce chapitre n'est pas terminé. Merci d'envoyer vos suggestions !
3016+
3017+Introduction
3018+~~~~~~~~~~~~
3019+
3020+Ce chapitre est un exemple de création d'une application lourde avec la
3021+bibliothèque d'interface graphique PyGTK et la ZCA. Cette application utilise
3022+également deux types différents de mécanismes de persistance des données : le
3023+premier est une base de données objet (ZODB), l'autre est une base de données
3024+relationnelle (SQLite). Cependant, en pratique, un seul des deux mécanismes peut
3025+être utilisé dans une installation donnée. L'utilisation de deux types de
3026+persistance est là pour démontrer comment utiliser la ZCA pour brancher des
3027+composants entre eux. La majorité de code de cette application est lié à PyGTK.
3028+
3029+Lorsque l'application grossit, vous pouvez utiliser les composants de la ZCA aux
3030+endroits où vous souhaitez fournir de la modularité ou de l'extensibilité.
3031+Utilisez des objets Python classiques quand vous n'avez pas besoin de ces
3032+propriétés.
3033+
3034+Il n'y a pas de différence entre l'utilisation de la ZCA pour une application
3035+web, pour une application graphique lourde, ou pour toute autre application ou
3036+framework. Il est préférable de suivre une convention pour l'emplacement où vous
3037+allez inscrire les composants. Cette application utilise une convention qui peut
3038+être étendue en plaçant des inscriptions ou des composants similaires dans des
3039+modules séparés et en les important plus tard depuis le module principal
3040+d'inscription. Dans cette application, le module principal pour l'inscription
3041+est `register.py`.
3042+
3043+Le code source de cette application peut être téléchargé sur :
3044+http://www.muthukadan.net/downloads/zcalib.tar.bz2
3045+
3046+
3047+Cas d'utilisation
3048+~~~~~~~~~~~~~~~~~
3049+
3050+L'application que nous allons créer ici est un système de gestion de
3051+bibliothèque avec des fonctionnalités minimales. Les besoins peuvent être
3052+résumés comme ceci:
3053+
3054+- Ajouter des membres avec un numéro et un nom uniques.
3055+
3056+- Ajouter des livres avec un code barre, un auteur et un titre.
3057+
3058+- Prêter des livres
3059+
3060+- Récupérer des livres
3061+
3062+
3063+L'application peut être conçue de telle façon que les grandes fonctionnalités
3064+seront utilisées dans une fenêtre unique. La fenêtre principale peut être conçue
3065+de cette façon :
3066+
3067+.. image:: mainwindow.png
3068+ :align: center
3069+
3070+Depuis la fenêtre des membres, l'utilisateur devrait être capable de gérer des
3071+membres. Donc il devrait être possible d'*ajouter*, *modifier* et *effacer* des
3072+membres comme dans l'image ci-dessous :
3073+
3074+.. image:: memberwindow.png
3075+ :align: center
3076+
3077+Similaire à la fenêtre des membres, la fenêtre du catalogue permet aux
3078+utilisateurs d'*ajouter*, *modifier* et *effacer* des livres :
3079+
3080+.. image:: catalogwindow.png
3081+ :align: center
3082+
3083+La fenêtre de circulation doit avoir ce qu'il faut pour prêter et récupérer des
3084+livres :
3085+
3086+.. image:: circulationwindow.png
3087+ :align: center
3088+
3089+
3090+Survol du code PyGTK
3091+~~~~~~~~~~~~~~~~~~~~
3092+
3093+Vous pouvez constater que la majorité du code est en rapport avec PyGTK.
3094+Sa structure est très similaire pour les différentes fenêtres. Les écrans
3095+de cette application sont conçus avec le créateur d'interface graphiques Glade.
3096+Vous devriez donner des noms appropriés aux widgets que vous allez utiliser dans
3097+votre code. Dans la fenêtre principale, tous les éléments de menu ont des noms
3098+du type : circulation, catalog, member, quit et about.
3099+
3100+La classe ``gtk.glade.XML`` est utilisée pour analyser le fichier Glade, et donc
3101+pour créer les objets widgets de l'interface graphique. Voici comment faire ::
3102+
3103+ import gtk.glade
3104+ xmlobj = gtk.glade.XML('/path/to/file.glade')
3105+ widget = xmlobj.get_widget('widget_name')
3106+
3107+Dans mainwindow.py, vous pouvez voir le code suivant ::
3108+
3109+ curdir = os.path.abspath(os.path.dirname(__file__))
3110+ xml = os.path.join(curdir, 'glade', 'mainwindow.glade')
3111+ xmlobj = gtk.glade.XML(xml)
3112+
3113+ self.mainwindow = xmlobj.get_widget('mainwindow')
3114+
3115+Le nom du widget fenêtre principal est `mainwindow`. Les autres widgets sont
3116+créés de la même manière ::
3117+
3118+ circulation = xmlobj.get_widget('circulation')
3119+ member = xmlobj.get_widget('member')
3120+ quit = xmlobj.get_widget('quit')
3121+ catalog = xmlobj.get_widget('catalog')
3122+ about = xmlobj.get_widget('about')
3123+
3124+Ensuite ces widgets sont connectés à certains événements ::
3125+
3126+ self.mainwindow.connect('delete_event', self.delete_event)
3127+ quit.connect('activate', self.delete_event)
3128+ circulation.connect('activate', self.on_circulation_activate)
3129+ member.connect('activate', self.on_member_activate)
3130+ catalog.connect('activate', self.on_catalog_activate)
3131+ about.connect('activate', self.on_about_activate)
3132+
3133+L'événement `delete_event` est celui correspondant à la fermeture de la fenêtre lors
3134+de l'appui sur le bouton de fermeture. L'événement `activate` est émis lorsque
3135+le menu est sélectionné. Les widgets sont connectés à des fonctions de rappel
3136+pour certains événements.
3137+
3138+Vous pouvez voir dans le code ci-dessus que la fenêtre principale est connectée
3139+à la méthode `on_delete_event` pour l'événement `delete_event`. Le widget `quit`
3140+est aussi connecté aux mêmes méthodes pour l'événement `activate` ::
3141+
3142+ def on_delete_event(self, *args):
3143+ gtk.main_quit()
3144+
3145+La fonction de rappel lance juste la fonction `main_quit`.
3146+
3147+
3148+Le code
3149+~~~~~~~
3150+
3151+Voici `zcalib.py` ::
3152+
3153+ import registry
3154+ import mainwindow
3155+
3156+ if __name__ == '__main__':
3157+ registry.initialize()
3158+ try:
3159+ mainwindow.main()
3160+ except KeyboardInterrupt:
3161+ import sys
3162+ sys.exit(1)
3163+
3164+Ici, deux modules sont importés : `registry` et `mainwindow`.
3165+Ensuite le registre est initialisé et la fonction `main` de la fenêtre
3166+principale est appelée. Si l'utilisateur essaye de fermer l'application en
3167+appuyant sur `Ctrl-C`, celle-ci s'arrête normalement car nous avons intercepté
3168+l'exception `KeyboardInterrupt`.
3169+
3170+Voici `registry.py` ::
3171+
3172+ import sys
3173+ from zope.component import getGlobalSiteManager
3174+
3175+ from interfaces import IMember
3176+ from interfaces import IBook
3177+ from interfaces import ICirculation
3178+ from interfaces import IDbOperation
3179+
3180+
3181+ def initialize_rdb():
3182+ from interfaces import IRelationalDatabase
3183+ from relationaldatabase import RelationalDatabase
3184+ from member import MemberRDbOperation
3185+ from catalog import BookRDbOperation
3186+ from circulation import CirculationRDbOperation
3187+
3188+ gsm = getGlobalSiteManager()
3189+ db = RelationalDatabase()
3190+ gsm.registerUtility(db, IRelationalDatabase)
3191+
3192+ gsm.registerAdapter(MemberRDbOperation,
3193+ (IMember,),
3194+ IDbOperation)
3195+
3196+ gsm.registerAdapter(BookRDbOperation,
3197+ (IBook,),
3198+ IDbOperation)
3199+
3200+ gsm.registerAdapter(CirculationRDbOperation,
3201+ (ICirculation,),
3202+ IDbOperation)
3203+
3204+ def initialize_odb():
3205+ from interfaces import IObjectDatabase
3206+ from objectdatabase import ObjectDatabase
3207+ from member import MemberODbOperation
3208+ from catalog import BookODbOperation
3209+ from circulation import CirculationODbOperation
3210+
3211+ gsm = getGlobalSiteManager()
3212+ db = ObjectDatabase()
3213+ gsm.registerUtility(db, IObjectDatabase)
3214+
3215+ gsm.registerAdapter(MemberODbOperation,
3216+ (IMember,),
3217+ IDbOperation)
3218+
3219+ gsm.registerAdapter(BookODbOperation,
3220+ (IBook,),
3221+ IDbOperation)
3222+
3223+ gsm.registerAdapter(CirculationODbOperation,
3224+ (ICirculation,),
3225+ IDbOperation)
3226+
3227+ def check_use_relational_db():
3228+ use_rdb = False
3229+ try:
3230+ arg = sys.argv[1]
3231+ if arg == '-r':
3232+ return True
3233+ except IndexError:
3234+ pass
3235+ return use_rdb
3236+
3237+ def initialize():
3238+ use_rdb = check_use_relational_db()
3239+ if use_rdb:
3240+ initialize_rdb()
3241+ else:
3242+ initialize_odb()
3243+
3244+Observez la fonction `initialize` que nous appelons depuis le module principal
3245+`zcalib.py`. Cette fonction commence par vérifier quelle base de données
3246+utiliser : une base relationnelle (RDB) ou une base objet (ODB). Cette
3247+vérification est effectuée dans la fonction `check_use_relational_db`. Si
3248+l'option `-r` est passé dans la ligne de commandes, elle appelera la fonction
3249+`initialize_rdb`, sinon `initialize_odb`. Si la fonction RDB est appelée, elle
3250+configure tous les composants liés à la base relationnelle. Si la fonction ODB est appelée,
3251+elle configure tous les composants liés à la base objet.
3252+
3253+Voici `mainwindow.py` ::
3254+
3255+ import os
3256+ import gtk
3257+ import gtk.glade
3258+
3259+ from circulationwindow import circulationwindow
3260+ from catalogwindow import catalogwindow
3261+ from memberwindow import memberwindow
3262+
3263+ class MainWindow(object):
3264+
3265+ def __init__(self):
3266+ curdir = os.path.abspath(os.path.dirname(__file__))
3267+ xml = os.path.join(curdir, 'glade', 'mainwindow.glade')
3268+ xmlobj = gtk.glade.XML(xml)
3269+
3270+ self.mainwindow = xmlobj.get_widget('mainwindow')
3271+ circulation = xmlobj.get_widget('circulation')
3272+ member = xmlobj.get_widget('member')
3273+ quit = xmlobj.get_widget('quit')
3274+ catalog = xmlobj.get_widget('catalog')
3275+ about = xmlobj.get_widget('about')
3276+
3277+ self.mainwindow.connect('delete_event', self.delete_event)
3278+ quit.connect('activate', self.delete_event)
3279+
3280+ circulation.connect('activate', self.on_circulation_activate)
3281+ member.connect('activate', self.on_member_activate)
3282+ catalog.connect('activate', self.on_catalog_activate)
3283+ about.connect('activate', self.on_about_activate)
3284+
3285+ def delete_event(self, *args):
3286+ gtk.main_quit()
3287+
3288+ def on_circulation_activate(self, *args):
3289+ circulationwindow.show_all()
3290+
3291+ def on_member_activate(self, *args):
3292+ memberwindow.show_all()
3293+
3294+ def on_catalog_activate(self, *args):
3295+ catalogwindow.show_all()
3296+
3297+ def on_about_activate(self, *args):
3298+ pass
3299+
3300+ def run(self):
3301+ self.mainwindow.show_all()
3302+
3303+ def main():
3304+ mainwindow = MainWindow()
3305+ mainwindow.run()
3306+ gtk.main()
3307+
3308+
3309+La fonction `main` crée une instance de la classe `MainWindow` qui initialise
3310+tous les widgets.
3311+
3312+Voici `memberwindow.py` ::
3313+
3314+ import os
3315+ import gtk
3316+ import gtk.glade
3317+
3318+ from zope.component import getAdapter
3319+
3320+ from components import Member
3321+ from interfaces import IDbOperation
3322+
3323+
3324+ class MemberWindow(object):
3325+
3326+ def __init__(self):
3327+ curdir = os.path.abspath(os.path.dirname(__file__))
3328+ xml = os.path.join(curdir, 'glade', 'memberwindow.glade')
3329+ xmlobj = gtk.glade.XML(xml)
3330+
3331+ self.memberwindow = xmlobj.get_widget('memberwindow')
3332+ self.number = xmlobj.get_widget('number')
3333+ self.name = xmlobj.get_widget('name')
3334+ add = xmlobj.get_widget('add')
3335+ update = xmlobj.get_widget('update')
3336+ delete = xmlobj.get_widget('delete')
3337+ close = xmlobj.get_widget('close')
3338+ self.treeview = xmlobj.get_widget('treeview')
3339+
3340+ self.memberwindow.connect('delete_event', self.on_delete_event)
3341+ add.connect('clicked', self.on_add_clicked)
3342+ update.connect('clicked', self.on_update_clicked)
3343+ delete.connect('clicked', self.on_delete_clicked)
3344+ close.connect('clicked', self.on_delete_event)
3345+
3346+ self.initialize_list()
3347+
3348+ def show_all(self):
3349+ self.populate_list_store()
3350+ self.memberwindow.show_all()
3351+
3352+ def populate_list_store(self):
3353+ self.list_store.clear()
3354+ member = Member()
3355+ memberdboperation = getAdapter(member, IDbOperation)
3356+ members = memberdboperation.get()
3357+ for member in members:
3358+ number = member.number
3359+ name = member.name
3360+ self.list_store.append((member, number, name,))
3361+
3362+ def on_delete_event(self, *args):
3363+ self.memberwindow.hide()
3364+ return True
3365+
3366+ def initialize_list(self):
3367+ self.list_store = gtk.ListStore(object, str, str)
3368+ self.treeview.set_model(self.list_store)
3369+ tvcolumn = gtk.TreeViewColumn('Member Number')
3370+ self.treeview.append_column(tvcolumn)
3371+
3372+ cell = gtk.CellRendererText()
3373+ tvcolumn.pack_start(cell, True)
3374+ tvcolumn.add_attribute(cell, 'text', 1)
3375+
3376+ tvcolumn = gtk.TreeViewColumn('Member Name')
3377+ self.treeview.append_column(tvcolumn)
3378+
3379+ cell = gtk.CellRendererText()
3380+ tvcolumn.pack_start(cell, True)
3381+ tvcolumn.add_attribute(cell, 'text', 2)
3382+
3383+ def on_add_clicked(self, *args):
3384+ number = self.number.get_text()
3385+ name = self.name.get_text()
3386+ member = Member()
3387+ member.number = number
3388+ member.name = name
3389+ self.add(member)
3390+ self.list_store.append((member, number, name,))
3391+
3392+ def add(self, member):
3393+ memberdboperation = getAdapter(member, IDbOperation)
3394+ memberdboperation.add()
3395+
3396+ def on_update_clicked(self, *args):
3397+ number = self.number.get_text()
3398+ name = self.name.get_text()
3399+ treeselection = self.treeview.get_selection()
3400+ model, iter = treeselection.get_selected()
3401+ if not iter:
3402+ return
3403+ member = self.list_store.get_value(iter, 0)
3404+ member.number = number
3405+ member.name = name
3406+ self.update(member)
3407+ self.list_store.set(iter, 1, number, 2, name)
3408+
3409+ def update(self, member):
3410+ memberdboperation = getAdapter(member, IDbOperation)
3411+ memberdboperation.update()
3412+
3413+ def on_delete_clicked(self, *args):
3414+ treeselection = self.treeview.get_selection()
3415+ model, iter = treeselection.get_selected()
3416+ if not iter:
3417+ return
3418+ member = self.list_store.get_value(iter, 0)
3419+ self.delete(member)
3420+ self.list_store.remove(iter)
3421+
3422+ def delete(self, member):
3423+ memberdboperation = getAdapter(member, IDbOperation)
3424+ memberdboperation.delete()
3425+
3426+ memberwindow = MemberWindow()
3427+
3428+Voici `components.py` ::
3429+
3430+ from zope.interface import implements
3431+
3432+ from interfaces import IBook
3433+ from interfaces import IMember
3434+ from interfaces import ICirculation
3435+
3436+ class Book(object):
3437+
3438+ implements(IBook)
3439+
3440+ barcode = ""
3441+ title = ""
3442+ author = ""
3443+
3444+ class Member(object):
3445+
3446+ implements(IMember)
3447+
3448+ number = ""
3449+ name = ""
3450+
3451+ class Circulation(object):
3452+
3453+ implements(ICirculation)
3454+
3455+ book = Book()
3456+ member = Member()
3457+
3458+Voici `interfaces.py` ::
3459+
3460+ from zope.interface import Interface
3461+ from zope.interface import Attribute
3462+
3463+
3464+ class IBook(Interface):
3465+
3466+ barcode = Attribute("Barcode")
3467+ author = Attribute("Author of book")
3468+ title = Attribute("Title of book")
3469+
3470+
3471+ class IMember(Interface):
3472+
3473+ number = Attribute("ID number")
3474+ name = Attribute("Name of member")
3475+
3476+
3477+ class ICirculation(Interface):
3478+
3479+ book = Attribute("A book")
3480+ member = Attribute("A member")
3481+
3482+
3483+ class IRelationalDatabase(Interface):
3484+
3485+ def commit():
3486+ pass
3487+
3488+ def rollback():
3489+ pass
3490+
3491+ def cursor():
3492+ pass
3493+
3494+ def get_next_id():
3495+ pass
3496+
3497+
3498+ class IObjectDatabase(Interface):
3499+
3500+ def commit():
3501+ pass
3502+
3503+ def rollback():
3504+ pass
3505+
3506+ def container():
3507+ pass
3508+
3509+ def get_next_id():
3510+ pass
3511+
3512+
3513+ class IDbOperation(Interface):
3514+
3515+ def get():
3516+ pass
3517+
3518+ def add():
3519+ pass
3520+
3521+ def update():
3522+ pass
3523+
3524+ def delete():
3525+ pass
3526+
3527+Here is the `member.py` ::
3528+
3529+ from zope.interface import implements
3530+ from zope.component import getUtility
3531+ from zope.component import adapts
3532+
3533+ from components import Member
3534+
3535+ from interfaces import IRelationalDatabase
3536+ from interfaces import IObjectDatabase
3537+ from interfaces import IMember
3538+ from interfaces import IDbOperation
3539+
3540+
3541+ class MemberRDbOperation(object):
3542+
3543+ implements(IDbOperation)
3544+ adapts(IMember)
3545+
3546+ def __init__(self, member):
3547+ self.member = member
3548+
3549+ def get(self):
3550+ db = getUtility(IRelationalDatabase)
3551+ cr = db.cursor()
3552+ number = self.member.number
3553+ if number:
3554+ cr.execute("""SELECT
3555+ id,
3556+ number,
3557+ name
3558+ FROM members
3559+ WHERE number = ?""",
3560+ (number,))
3561+ else:
3562+ cr.execute("""SELECT
3563+ id,
3564+ number,
3565+ name
3566+ FROM members""")
3567+ rst = cr.fetchall()
3568+ cr.close()
3569+ members = []
3570+ for record in rst:
3571+ id = record['id']
3572+ number = record['number']
3573+ name = record['name']
3574+ member = Member()
3575+ member.id = id
3576+ member.number = number
3577+ member.name = name
3578+ members.append(member)
3579+ return members
3580+
3581+ def add(self):
3582+ db = getUtility(IRelationalDatabase)
3583+ cr = db.cursor()
3584+ next_id = db.get_next_id("members")
3585+ number = self.member.number
3586+ name = self.member.name
3587+ cr.execute("""INSERT INTO members
3588+ (id, number, name)
3589+ VALUES (?, ?, ?)""",
3590+ (next_id, number, name))
3591+ cr.close()
3592+ db.commit()
3593+ self.member.id = next_id
3594+
3595+ def update(self):
3596+ db = getUtility(IRelationalDatabase)
3597+ cr = db.cursor()
3598+ number = self.member.number
3599+ name = self.member.name
3600+ id = self.member.id
3601+ cr.execute("""UPDATE members
3602+ SET
3603+ number = ?,
3604+ name = ?
3605+ WHERE id = ?""",
3606+ (number, name, id))
3607+ cr.close()
3608+ db.commit()
3609+
3610+ def delete(self):
3611+ db = getUtility(IRelationalDatabase)
3612+ cr = db.cursor()
3613+ id = self.member.id
3614+ cr.execute("""DELETE FROM members
3615+ WHERE id = ?""",
3616+ (id,))
3617+ cr.close()
3618+ db.commit()
3619+
3620+
3621+ class MemberODbOperation(object):
3622+
3623+ implements(IDbOperation)
3624+ adapts(IMember)
3625+
3626+ def __init__(self, member):
3627+ self.member = member
3628+
3629+ def get(self):
3630+ db = getUtility(IObjectDatabase)
3631+ zcalibdb = db.container()
3632+ members = zcalibdb['members']
3633+ return members.values()
3634+
3635+ def add(self):
3636+ db = getUtility(IObjectDatabase)
3637+ zcalibdb = db.container()
3638+ members = zcalibdb['members']
3639+ number = self.member.number
3640+ if number in [x.number for x in members.values()]:
3641+ db.rollback()
3642+ raise Exception("Duplicate key")
3643+ next_id = db.get_next_id('members')
3644+ self.member.id = next_id
3645+ members[next_id] = self.member
3646+ db.commit()
3647+
3648+ def update(self):
3649+ db = getUtility(IObjectDatabase)
3650+ zcalibdb = db.container()
3651+ members = zcalibdb['members']
3652+ id = self.member.id
3653+ members[id] = self.member
3654+ db.commit()
3655+
3656+ def delete(self):
3657+ db = getUtility(IObjectDatabase)
3658+ zcalibdb = db.container()
3659+ members = zcalibdb['members']
3660+ id = self.member.id
3661+ del members[id]
3662+ db.commit()
3663+
3664+
3665+PySQLite
3666+~~~~~~~~
3667+
3668+ZODB
3669+~~~~
3670+
3671+Conclusions
3672+~~~~~~~~~~~
3673
3674 Reference
3675 ---------
3676
3677
3678-Attribute
3679-~~~~~~~~~
3680-
3681-Using this class, you can define normal attribute in an interface.
3682-
3683- - Location: ``zope.interface``
3684-
3685- - Signature: `Attribute(name, doc='')`
3686-
3687-Example::
3688-
3689- >>> from zope.interface import Attribute
3690- >>> from zope.interface import Interface
3691-
3692- >>> class IPerson(Interface):
3693- ...
3694- ... name = Attribute("Name of person")
3695- ... email = Attribute("Email Address")
3696-
3697-
3698-Declaration
3699-~~~~~~~~~~~
3700-
3701-Need not to use directly.
3702-
3703-
3704-Interface
3705-~~~~~~~~~
3706-
3707-Using this class, you can define an interface. To define an
3708-interface, just inherit from ``Interface`` class.
3709-
3710- - Location: ``zope.interface``
3711-
3712- - Signature: `Interface(name, doc='')`
3713-
3714-Example 1::
3715-
3716- >>> from zope.interface import Attribute
3717- >>> from zope.interface import Interface
3718-
3719- >>> class IPerson(Interface):
3720- ...
3721- ... name = Attribute("Name of person")
3722- ... email = Attribute("Email Address")
3723-
3724-
3725-Example 2::
3726-
3727- >>> from zope.interface import Interface
3728-
3729- >>> class IHost(Interface):
3730- ...
3731- ... def goodmorning(guest):
3732- ... """Say good morning to guest"""
3733+adaptedBy
3734+~~~~~~~~~
3735+
3736+Cette fonction permet de trouver les interfaces adaptées.
3737+
3738+ - Emplacement : ``zope.component``
3739+
3740+ - Signature : `adaptedBy(object)`
3741+
3742+Exemple ::
3743+
3744+ >>> from zope.interface import implements
3745+ >>> from zope.component import adapts
3746+ >>> from zope.component import adaptedBy
3747+
3748+ >>> class FrontDeskNG(object):
3749+ ...
3750+ ... implements(IDesk)
3751+ ... adapts(IGuest)
3752+ ...
3753+ ... def __init__(self, guest):
3754+ ... self.guest = guest
3755+
3756+ >>> adaptedBy(FrontDeskNG)
3757+ (<InterfaceClass __builtin__.IGuest>,)
3758+
3759+
3760+adapter
3761+~~~~~~~
3762+
3763+Un adaptateur peut être n'importe quel objet appelable. Vous pouvez
3764+utiliser le décorateur `adapter` pour déclarer qu'un objet appelable s'adapte à
3765+des interfaces (ou des classes).
3766+
3767+ - Emplacement : ``zope.component``
3768+
3769+ - Signature : `adapter(*interfaces)`
3770+
3771+Exemple ::
3772+
3773+ >>> from zope.interface import Attribute
3774+ >>> from zope.interface import Interface
3775+ >>> from zope.interface import implementer
3776+ >>> from zope.component import adapter
3777+ >>> from zope.interface import implements
3778+
3779+ >>> class IJob(Interface):
3780+ ... """A job"""
3781+
3782+ >>> class Job(object):
3783+ ... implements(IJob)
3784+
3785+ >>> class IPerson(Interface):
3786+ ...
3787+ ... name = Attribute("Name")
3788+ ... job = Attribute("Job")
3789+
3790+ >>> class Person(object):
3791+ ... implements(IPerson)
3792+ ...
3793+ ... name = None
3794+ ... job = None
3795+
3796+ >>> @implementer(IJob)
3797+ ... @adapter(IPerson)
3798+ ... def personJob(person):
3799+ ... return person.job
3800+
3801+ >>> jack = Person()
3802+ >>> jack.name = "Jack"
3803+ >>> jack.job = Job()
3804+ >>> personJob(jack) #doctest: +ELLIPSIS
3805+ <Job object at ...>
3806
3807
3808 adapts
3809 ~~~~~~
3810
3811-This function helps to declare adapter classes.
3812-
3813- - Location: ``zope.component``
3814-
3815- - Signature: `adapts(*interfaces)`
3816-
3817-Example::
3818+Cette fonction permet de déclarer les classes adaptateurs.
3819+
3820+ - Emplacement : ``zope.component``
3821+
3822+ - Signature : `adapts(*interfaces)`
3823+
3824+Exemple ::
3825
3826 >>> from zope.interface import implements
3827 >>> from zope.component import adapts
3828
3829- >>> class GuestRegistrarNG(object):
3830+ >>> class FrontDeskNG(object):
3831 ...
3832- ... implements(IRegistrar)
3833+ ... implements(IDesk)
3834 ... adapts(IGuest)
3835 ...
3836 ... def __init__(self, guest):
3837@@ -1919,7 +2604,7 @@
3838 ...
3839 ... def register(self):
3840 ... next_id = get_next_id()
3841- ... guests_db[next_id] = {
3842+ ... bookings_db[next_id] = {
3843 ... 'name': guest.name,
3844 ... 'place': guest.place,
3845 ... 'phone': guest.phone
3846@@ -1929,15 +2614,15 @@
3847 alsoProvides
3848 ~~~~~~~~~~~~
3849
3850-Declare interfaces declared directly for an object. The arguments
3851-after the object are one or more interfaces. The interfaces given are
3852-added to the interfaces previously declared for the object.
3853-
3854- - Location: ``zope.interface``
3855-
3856- - Signature: `alsoProvides(object, *interfaces)`
3857-
3858-Example::
3859+Déclare des interfaces additionnelles fournies par un objet. Les arguments après
3860+l'objet sont une ou plusieurs interfaces. Les interfaces données sont ajoutées
3861+aux interfaces précédemment déclarées pour l'objet.
3862+
3863+ - Emplacement : ``zope.interface``
3864+
3865+ - Signature : `alsoProvides(object, *interfaces)`
3866+
3867+Exemple ::
3868
3869 >>> from zope.interface import Attribute
3870 >>> from zope.interface import Interface
3871@@ -1954,7 +2639,7 @@
3872
3873 >>> class Person(object):
3874 ...
3875- ... implements(IRegistrar)
3876+ ... implements(IDesk)
3877 ... name = u""
3878
3879 >>> jack = Person()
3880@@ -1962,25 +2647,48 @@
3881 >>> jack.college = "New College"
3882 >>> alsoProvides(jack, IStudent)
3883
3884- You can test it like this:
3885+ Vous pouvez tester de cette façon:
3886
3887 >>> from zope.interface import providedBy
3888 >>> IStudent in providedBy(jack)
3889 True
3890
3891
3892+Attribute
3893+~~~~~~~~~
3894+
3895+En utilisant cette classe, vous pouvez définir des attributs dans une interface.
3896+
3897+ - Emplacement : ``zope.interface``
3898+
3899+ - Signature : `Attribute(name, doc='')`
3900+
3901+ - Voir aussi : `Interface`_
3902+
3903+Exemple ::
3904+
3905+ >>> from zope.interface import Attribute
3906+ >>> from zope.interface import Interface
3907+
3908+ >>> class IPerson(Interface):
3909+ ...
3910+ ... name = Attribute("Name of person")
3911+ ... email = Attribute("Email Address")
3912+
3913+
3914 classImplements
3915 ~~~~~~~~~~~~~~~
3916
3917-Declare additional interfaces implemented for instances of a class.
3918-The arguments after the class are one or more interfaces. The
3919-interfaces given are added to any interfaces previously declared.
3920-
3921- - Location: ``zope.interface``
3922-
3923- - Signature: `classImplements(cls, *interfaces)`
3924-
3925-Example::
3926+Déclare des interfaces additionnelles qui doivent être fournies par les
3927+instances d'une classe. Les arguments après la classe sont une ou plusieurs
3928+interfaces. Les interfaces données sont ajoutées aux interfaces précédemment
3929+déclarées.
3930+
3931+ - Emplacement : ``zope.interface``
3932+
3933+ - Signature : `classImplements(cls, *interfaces)`
3934+
3935+Exemple ::
3936
3937 >>> from zope.interface import Attribute
3938 >>> from zope.interface import Interface
3939@@ -1997,7 +2705,7 @@
3940
3941 >>> class Person(object):
3942 ...
3943- ... implements(IRegistrar)
3944+ ... implements(IDesk)
3945 ... name = u""
3946 ... college = u""
3947
3948@@ -2006,7 +2714,7 @@
3949 >>> jack.name = "Jack"
3950 >>> jack.college = "New College"
3951
3952- You can test it like this:
3953+ Vous pouvez tester de cette façon :
3954
3955 >>> from zope.interface import providedBy
3956 >>> IStudent in providedBy(jack)
3957@@ -2016,15 +2724,16 @@
3958 classImplementsOnly
3959 ~~~~~~~~~~~~~~~~~~~
3960
3961-Declare the only interfaces implemented by instances of a class. The
3962-arguments after the class are one or more interfaces. The interfaces
3963-given replace any previous declarations.
3964-
3965- - Location: ``zope.interface``
3966-
3967- - Signature: `classImplementsOnly(cls, *interfaces)`
3968-
3969-Example::
3970+Déclare les seules interfaces qui devront être fournies par les instances d'une
3971+classe. Les arguments après la classe sont une ou plusieurs interfaces. Les
3972+interfaces fournies vont remplacer toutes les interfaces des déclarations
3973+précédentes.
3974+
3975+ - Emplacement : ``zope.interface``
3976+
3977+ - Signature : `classImplementsOnly(cls, *interfaces)`
3978+
3979+Exemple ::
3980
3981 >>> from zope.interface import Attribute
3982 >>> from zope.interface import Interface
3983@@ -2048,7 +2757,7 @@
3984 >>> jack = Person()
3985 >>> jack.college = "New College"
3986
3987- You can test it like this:
3988+ Vous pouvez tester de cette façon :
3989
3990 >>> from zope.interface import providedBy
3991 >>> IPerson in providedBy(jack)
3992@@ -2060,16 +2769,16 @@
3993 classProvides
3994 ~~~~~~~~~~~~~
3995
3996-Normally if a class implements a particular interface, the instance of
3997-that class will provide the interface implemented by that class. But
3998-if you want a class to be provided by an interface, you can declare it
3999-using ``classProvides`` function.
4000-
4001- - Location: ``zope.interface``
4002-
4003- - Signature: `classProvides(*interfaces)`
4004-
4005-Example::
4006+Normalement si une classe implémente une interface particulière, les instances
4007+de cette classe fourniront l'interface implémentée par la classe. Mais si vous
4008+voulez qu'une classe fournisse une interface, vous pouvez le déclarer grâce à la
4009+fonction ``classProvides``.
4010+
4011+ - Emplacement : ``zope.interface``
4012+
4013+ - Signature : `classProvides(*interfaces)`
4014+
4015+Exemple ::
4016
4017 >>> from zope.interface import Attribute
4018 >>> from zope.interface import Interface
4019@@ -2084,7 +2793,7 @@
4020 ... classProvides(IPerson)
4021 ... name = u"Jack"
4022
4023- You can test it like this:
4024+ Vous pouvez tester de cette façon :
4025
4026 >>> from zope.interface import providedBy
4027 >>> IPerson in providedBy(Person)
4028@@ -2094,26 +2803,39 @@
4029 ComponentLookupError
4030 ~~~~~~~~~~~~~~~~~~~~
4031
4032+C'est l'exception levée quand une recherche de composant échoue.
4033+
4034+Exemple ::
4035+
4036+ >>> class IPerson(Interface):
4037+ ...
4038+ ... name = Attribute("Name of person")
4039+
4040+ >>> person = object()
4041+ >>> getAdapter(person, IPerson, 'not-exists') #doctest: +ELLIPSIS
4042+ Traceback (most recent call last):
4043+ ...
4044+ ComponentLookupError: ...
4045+
4046
4047 createObject
4048 ~~~~~~~~~~~~
4049
4050-Create an object using a factory.
4051-
4052-Finds the named factory in the current site and calls it with the
4053-given arguments. If a matching factory cannot be found raises
4054-ComponentLookupError. Returns the created object.
4055-
4056-A context keyword argument can be provided to cause the factory to be
4057-looked up in a location other than the current site. (Of course, this
4058-means that it is impossible to pass a keyword argument named "context"
4059-to the factory.
4060-
4061- - Location: ``zope.component``
4062-
4063- - Signature: `createObject(factory_name, *args, **kwargs)`
4064-
4065-Example::
4066+Crée un objet en utilisant une fabrique.
4067+
4068+Cette fonction trouve une fabrique nommée dans le site courant et l'appelle avec
4069+les arguments donnés. Si la bonne fabrique ne peut pas être trouvée, une erreur
4070+``ComponentLookupError`` est déclenchée. Sinon l'objet créé est renvoyé.
4071+
4072+Un argument mot-clé contextuel peut être fourni pour rechercher une fabrique
4073+dans un emplacement différent du site courant. (Bien sûr, cela signifie qu'il
4074+est impossible de transmettre à la fabrique un argument mot-clé nommé « context ».
4075+
4076+ - Emplacement : ``zope.component``
4077+
4078+ - Signature : `createObject(factory_name, *args, **kwargs)`
4079+
4080+Exemple ::
4081
4082 >>> from zope.interface import Attribute
4083 >>> from zope.interface import Interface
4084@@ -2146,17 +2868,22 @@
4085 <FakeDb object at ...>
4086
4087
4088+Declaration
4089+~~~~~~~~~~~
4090+
4091+N'a pas besoin d'être utilisé directement.
4092+
4093+
4094 directlyProvidedBy
4095 ~~~~~~~~~~~~~~~~~~
4096
4097-This function will return the interfaces directly provided by the
4098-given object.
4099-
4100- - Location: ``zope.interface``
4101-
4102- - Signature: `directlyProvidedBy(object)`
4103-
4104-Example::
4105+Cette fonction renvoie les interfaces fournies directement par un objet donné.
4106+
4107+ - Emplacement : ``zope.interface``
4108+
4109+ - Signature : `directlyProvidedBy(object)`
4110+
4111+Exemple ::
4112
4113 >>> from zope.interface import Attribute
4114 >>> from zope.interface import Interface
4115@@ -2196,15 +2923,15 @@
4116 directlyProvides
4117 ~~~~~~~~~~~~~~~~
4118
4119-Declare interfaces declared directly for an object. The arguments
4120-after the object are one or more interfaces. The interfaces given
4121-replace interfaces previously declared for the object.
4122-
4123- - Location: ``zope.interface``
4124-
4125- - Signature: `directlyProvides(object, *interfaces)`
4126-
4127-Example::
4128+Déclare que des interfaces sont fournies directement par un objet. Les arguments
4129+après l'objet sont une ou plusieurs interfaces. Les interfaces données
4130+remplacent celles précédemment déclarées pour l'objet.
4131+
4132+ - Emplacement : ``zope.interface``
4133+
4134+ - Signature : `directlyProvides(object, *interfaces)`
4135+
4136+Exemple ::
4137
4138 >>> from zope.interface import Attribute
4139 >>> from zope.interface import Interface
4140@@ -2262,21 +2989,22 @@
4141 getAdapter
4142 ~~~~~~~~~~
4143
4144-Get a named adapter to an interface for an object. Returns an adapter
4145-that can adapt object to interface. If a matching adapter cannot be
4146-found, raises ``ComponentLookupError`` .
4147-
4148- - Location: ``zope.interface``
4149-
4150- - Signature: `getAdapter(object, interface=Interface, name=u'', context=None)`
4151-
4152-Example::
4153+Cette fonction récupère un adaptateur (nommé) vers une interface, pour un objet
4154+donné. Elle renvoie un adaptateur qui peut adapter les objets à l'interface
4155+voulue. Si aucun adaptateur ne peut être trouvé, une erreur
4156+``ComponentLookupError`` est émise.
4157+
4158+ - Emplacement : ``zope.interface``
4159+
4160+ - Signature : `getAdapter(object, interface=Interface, name=u'', context=None)`
4161+
4162+Exemple ::
4163
4164 >>> from zope.interface import Attribute
4165 >>> from zope.interface import Interface
4166
4167- >>> class IRegistrar(Interface):
4168- ... """A registrar will register object's details"""
4169+ >>> class IDesk(Interface):
4170+ ... """A frontdesk will register object's details"""
4171 ...
4172 ... def register():
4173 ... """Register object's details"""
4174@@ -2285,9 +3013,9 @@
4175 >>> from zope.interface import implements
4176 >>> from zope.component import adapts
4177
4178- >>> class GuestRegistrarNG(object):
4179+ >>> class FrontDeskNG(object):
4180 ...
4181- ... implements(IRegistrar)
4182+ ... implements(IDesk)
4183 ... adapts(IGuest)
4184 ...
4185 ... def __init__(self, guest):
4186@@ -2295,7 +3023,7 @@
4187 ...
4188 ... def register(self):
4189 ... next_id = get_next_id()
4190- ... guests_db[next_id] = {
4191+ ... bookings_db[next_id] = {
4192 ... 'name': guest.name,
4193 ... 'place': guest.place,
4194 ... 'phone': guest.phone
4195@@ -2310,31 +3038,33 @@
4196 ... self.place = place
4197
4198 >>> jack = Guest("Jack", "Bangalore")
4199- >>> jack_registrar = GuestRegistrarNG(jack)
4200+ >>> jack_frontdesk = FrontDeskNG(jack)
4201
4202- >>> IRegistrar.providedBy(jack_registrar)
4203+ >>> IDesk.providedBy(jack_frontdesk)
4204 True
4205
4206 >>> from zope.component import getGlobalSiteManager
4207 >>> gsm = getGlobalSiteManager()
4208- >>> gsm.registerAdapter(GuestRegistrarNG,
4209- ... (IGuest,), IRegistrar, 'ng')
4210+ >>> gsm.registerAdapter(FrontDeskNG,
4211+ ... (IGuest,), IDesk, 'ng')
4212
4213- >>> getAdapter(jack, IRegistrar, 'ng') #doctest: +ELLIPSIS
4214- <GuestRegistrarNG object at ...>
4215+ >>> getAdapter(jack, IDesk, 'ng') #doctest: +ELLIPSIS
4216+ <FrontDeskNG object at ...>
4217
4218
4219 getAdapterInContext
4220 ~~~~~~~~~~~~~~~~~~~
4221
4222-Instead of this function, use `context` argument of `getAdapter`_
4223-function.
4224-
4225- - Location: ``zope.component``
4226-
4227- - Signature: `getAdapterInContext(object, interface, context)`
4228-
4229-Example::
4230+Au lieu d'utiliser cette fonction, utilisez `getAdapter`_ avec un argument
4231+`context`.
4232+
4233+ - Emplacement : ``zope.component``
4234+
4235+ - Signature : `getAdapterInContext(object, interface, context)`
4236+
4237+ - Voir aussi : `queryAdapterInContext`_
4238+
4239+Exemple ::
4240
4241 >>> from zope.component.globalregistry import BaseGlobalComponents
4242 >>> from zope.component import IComponentLookup
4243@@ -2352,8 +3082,8 @@
4244 >>> from zope.interface import Attribute
4245 >>> from zope.interface import Interface
4246
4247- >>> class IRegistrar(Interface):
4248- ... """A registrar will register object's details"""
4249+ >>> class IDesk(Interface):
4250+ ... """A frontdesk will register object's details"""
4251 ...
4252 ... def register():
4253 ... """Register object's details"""
4254@@ -2362,9 +3092,9 @@
4255 >>> from zope.interface import implements
4256 >>> from zope.component import adapts
4257
4258- >>> class GuestRegistrarNG(object):
4259+ >>> class FrontDeskNG(object):
4260 ...
4261- ... implements(IRegistrar)
4262+ ... implements(IDesk)
4263 ... adapts(IGuest)
4264 ...
4265 ... def __init__(self, guest):
4266@@ -2372,7 +3102,7 @@
4267 ...
4268 ... def register(self):
4269 ... next_id = get_next_id()
4270- ... guests_db[next_id] = {
4271+ ... bookings_db[next_id] = {
4272 ... 'name': guest.name,
4273 ... 'place': guest.place,
4274 ... 'phone': guest.phone
4275@@ -2387,42 +3117,41 @@
4276 ... self.place = place
4277
4278 >>> jack = Guest("Jack", "Bangalore")
4279- >>> jack_registrar = GuestRegistrarNG(jack)
4280+ >>> jack_frontdesk = FrontDeskNG(jack)
4281
4282- >>> IRegistrar.providedBy(jack_registrar)
4283+ >>> IDesk.providedBy(jack_frontdesk)
4284 True
4285
4286 >>> from zope.component import getGlobalSiteManager
4287 >>> gsm = getGlobalSiteManager()
4288- >>> sm.registerAdapter(GuestRegistrarNG,
4289- ... (IGuest,), IRegistrar)
4290+ >>> sm.registerAdapter(FrontDeskNG,
4291+ ... (IGuest,), IDesk)
4292
4293 >>> from zope.component import getAdapterInContext
4294- >>> from zope.component import queryAdapterInContext
4295
4296- >>> getAdapterInContext(jack, IRegistrar, sm) #doctest: +ELLIPSIS
4297- <GuestRegistrarNG object at ...>
4298+ >>> getAdapterInContext(jack, IDesk, sm) #doctest: +ELLIPSIS
4299+ <FrontDeskNG object at ...>
4300
4301
4302 getAdapters
4303 ~~~~~~~~~~~
4304
4305-Look for all matching adapters to a provided interface for objects.
4306-Return a list of adapters that match. If an adapter is named, only the
4307-most specific adapter of a given name is returned.
4308-
4309- - Location: ``zope.component``
4310-
4311- - Signature: `getAdapters(objects, provided, context=None)`
4312-
4313-Example::
4314+Recherche pour des objets tous les adaptateurs fournissant une interface donnée.
4315+Une liste d'adaptateurs est renvoyée. Si un adaptateur est nommé, seul
4316+l'adaptateur le plus spécifique pour un nom donné est renvoyé.
4317+
4318+ - Emplacement : ``zope.component``
4319+
4320+ - Signature : `getAdapters(objects, provided, context=None)`
4321+
4322+Exemple ::
4323
4324 >>> from zope.interface import implements
4325 >>> from zope.component import adapts
4326
4327- >>> class GuestRegistrarNG(object):
4328+ >>> class FrontDeskNG(object):
4329 ...
4330- ... implements(IRegistrar)
4331+ ... implements(IDesk)
4332 ... adapts(IGuest)
4333 ...
4334 ... def __init__(self, guest):
4335@@ -2430,37 +3159,37 @@
4336 ...
4337 ... def register(self):
4338 ... next_id = get_next_id()
4339- ... guests_db[next_id] = {
4340+ ... bookings_db[next_id] = {
4341 ... 'name': guest.name,
4342 ... 'place': guest.place,
4343 ... 'phone': guest.phone
4344 ... }
4345
4346 >>> jack = Guest("Jack", "Bangalore")
4347- >>> jack_registrar = GuestRegistrarNG(jack)
4348+ >>> jack_frontdesk = FrontDeskNG(jack)
4349
4350 >>> from zope.component import getGlobalSiteManager
4351 >>> gsm = getGlobalSiteManager()
4352
4353- >>> gsm.registerAdapter(GuestRegistrarNG, name='ng')
4354+ >>> gsm.registerAdapter(FrontDeskNG, name='ng')
4355
4356 >>> from zope.component import getAdapters
4357- >>> list(getAdapters((jack,), IRegistrar)) #doctest: +ELLIPSIS
4358- [(u'ng', <GuestRegistrarNG object at ...>)]
4359+ >>> list(getAdapters((jack,), IDesk)) #doctest: +ELLIPSIS
4360+ [(u'ng', <FrontDeskNG object at ...>)]
4361
4362
4363 getAllUtilitiesRegisteredFor
4364 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4365
4366-Return all registered utilities for an interface. This includes
4367-overridden utilities. The returned value is an iterable of utility
4368-instances.
4369-
4370- - Location: ``zope.component``
4371-
4372- - Signature: `getAllUtilitiesRegisteredFor(interface)`
4373-
4374-Example::
4375+Renvoie tous les utilitaires inscrits pour une interface. Ceci inclut les
4376+utilitaires surchargés. La valeur renvoyée est un objet iterable listant les
4377+instances d'utilitaires correspondants.
4378+
4379+ - Emplacement : ``zope.component``
4380+
4381+ - Signature : `getAllUtilitiesRegisteredFor(interface)`
4382+
4383+Exemple ::
4384
4385 >>> from zope.interface import Interface
4386 >>> from zope.interface import implements
4387@@ -2491,14 +3220,14 @@
4388 getFactoriesFor
4389 ~~~~~~~~~~~~~~~
4390
4391-Return a tuple (name, factory) of registered factories that create
4392-objects which implement the given interface.
4393-
4394- - Location: ``zope.component``
4395-
4396- - Signature: `getFactoriesFor(interface, context=None)`
4397-
4398-Example::
4399+Renvoie un tuple (nom, fabrique) de fabriques inscrites capables de créer des
4400+objets qui fournissent une interface donnée.
4401+
4402+ - Emplacement : ``zope.component``
4403+
4404+ - Signature : `getFactoriesFor(interface, context=None)`
4405+
4406+Exemple ::
4407
4408 >>> from zope.interface import Attribute
4409 >>> from zope.interface import Interface
4410@@ -2535,16 +3264,16 @@
4411 getFactoryInterfaces
4412 ~~~~~~~~~~~~~~~~~~~~
4413
4414-Get interfaces implemented by a factory. Finds the factory of the
4415-given name that is nearest to the context, and returns the interface
4416-or interface tuple that object instances created by the named factory
4417-will implement.
4418-
4419- - Location: ``zope.component``
4420-
4421- - Signature: `getFactoryInterfaces(name, context=None)`
4422-
4423-Example::
4424+Récupère les interfaces implémentées par une fabrique. Cette fonction trouve la
4425+fabrique possédant le nom donné la plus proche du contexte, puis renvoie
4426+l'interface ou le tuple d'interfaces que les instances créées par la fabrique
4427+vont fournir.
4428+
4429+ - Emplacement : ``zope.component``
4430+
4431+ - Signature : `getFactoryInterfaces(name, context=None)`
4432+
4433+Exemple ::
4434
4435 >>> from zope.interface import Attribute
4436 >>> from zope.interface import Interface
4437@@ -2581,14 +3310,14 @@
4438 getGlobalSiteManager
4439 ~~~~~~~~~~~~~~~~~~~~
4440
4441-Return the global site manager. This function should never fail and
4442-always return an object that provides `IGlobalSiteManager`
4443-
4444- - Location: ``zope.component``
4445-
4446- - Signature: `getGlobalSiteManager()`
4447-
4448-Example::
4449+Renvoie le gestionnaire global de site. Cette fonction ne doit jamais échouer
4450+et doit toujours renvoyer un objet qui fournit `IGlobalSiteManager`.
4451+
4452+ - Emplacement : ``zope.component``
4453+
4454+ - Signature : `getGlobalSiteManager()`
4455+
4456+Exemple ::
4457
4458 >>> from zope.component import getGlobalSiteManager
4459 >>> from zope.component import globalSiteManager
4460@@ -2600,19 +3329,21 @@
4461 getMultiAdapter
4462 ~~~~~~~~~~~~~~~
4463
4464-Look for a multi-adapter to an interface for an objects. Returns a
4465-multi-adapter that can adapt objects to interface. If a matching
4466-adapter cannot be found, raises ComponentLookupError. The name
4467-consisting of an empty string is reserved for unnamed adapters. The
4468-unnamed adapter methods will often call the named adapter methods with
4469-an empty string for a name.
4470-
4471- - Location: ``zope.component``
4472-
4473- - Signature: `getMultiAdapter(objects, interface=Interface, name='',
4474+Cette fonction recherche pour des objets un multi-adaptateur vers une interface
4475+donnée. Elle renvoie un multi-adaptateur qui peut s'adapter aux objets donnés et
4476+fournir l'interface voulue. Si aucun adaptateur ne peut être trouvé, une erreur
4477+`ComponentLookupError` est émise. Le nom constitué de la chaîne vide est réservé
4478+aux adaptateur sans nom. Les méthodes des adaptateurs sans nom appellent souvent
4479+les méthodes des adaptateurs nommés en fournissant un nom vide ('').
4480+
4481+ - Emplacement : ``zope.component``
4482+
4483+ - Signature : `getMultiAdapter(objects, interface=Interface, name='',
4484 context=None)`
4485
4486-Example::
4487+ - Voir aussi : `queryMultiAdapter`_
4488+
4489+Exemple ::
4490
4491 >>> from zope.interface import Interface
4492 >>> from zope.interface import implements
4493@@ -2664,17 +3395,17 @@
4494 getSiteManager
4495 ~~~~~~~~~~~~~~
4496
4497-Get the nearest site manager in the given context. If `context` is
4498-`None`, return the global site manager. If the `context` is not
4499-`None`, it is expected that an adapter from the `context` to
4500-`IComponentLookup` can be found. If no adapter is found, a
4501-`ComponentLookupError` is raised.
4502-
4503- - Location: ``zope.component``
4504-
4505- - Signature: `getSiteManager(context=None)`
4506-
4507-Example 1::
4508+Récupère le gestionnaire de site le plus proche du contexte donné. Si `context`
4509+est `None`, cette fonction renvoie le gestionnaire global de site. Si le
4510+`context` n'est pas `None`, on s'attend à ce qu'un adaptateur sur le contexte
4511+vers `IComponentLookup` soit trouvé. Si aucun adaptateur n'est trouvé, une
4512+erreur `ComponentLookupError` est émise.
4513+
4514+ - Emplacement : ``zope.component``
4515+
4516+ - Signature : `getSiteManager(context=None)`
4517+
4518+Exemple 1 ::
4519
4520 >>> from zope.component.globalregistry import BaseGlobalComponents
4521 >>> from zope.component import IComponentLookup
4522@@ -2695,7 +3426,7 @@
4523 >>> lsm is sm
4524 True
4525
4526-Example 2::
4527+Exemple 2 ::
4528
4529 >>> from zope.component import getGlobalSiteManager
4530 >>> gsm = getGlobalSiteManager()
4531@@ -2708,14 +3439,14 @@
4532 getUtilitiesFor
4533 ~~~~~~~~~~~~~~~
4534
4535-Look up the registered utilities that provide an interface. Returns
4536-an iterable of name-utility pairs.
4537-
4538- - Location: ``zope.component``
4539-
4540- - Signature: `getUtilitiesFor(interface)`
4541-
4542-Example::
4543+Récupère les utilitaires inscrits pour une interface particulière. Renvoie un
4544+objet iterable listant les paires nom/utilitaire.
4545+
4546+ - Emplacement : ``zope.component``
4547+
4548+ - Signature : `getUtilitiesFor(interface)`
4549+
4550+Exemple ::
4551
4552 >>> from zope.interface import Interface
4553 >>> from zope.interface import implements
4554@@ -2746,15 +3477,15 @@
4555 getUtility
4556 ~~~~~~~~~~
4557
4558-Get the utility that provides interface. Returns the nearest utility
4559-to the context that implements the specified interface. If one is not
4560-found, raises ComponentLookupError.
4561-
4562- - Location: ``zope.component``
4563-
4564- - Signature: `getUtility(interface, name='', context=None)`
4565-
4566-Example::
4567+Récupère l'utilitaire qui fournit une interface donnée. Cette fonction renvoie
4568+l'utilitaire le plus proche du contexte et qui fournit l'interface donnée. Si
4569+aucun n'est trouvé, une erreur ``ComponentLookupError`` est levée.
4570+
4571+ - Emplacement : ``zope.component``
4572+
4573+ - Signature : `getUtility(interface, name='', context=None)`
4574+
4575+Exemple ::
4576
4577 >>> from zope.interface import Interface
4578 >>> from zope.interface import implements
4579@@ -2785,16 +3516,15 @@
4580 handle
4581 ~~~~~~
4582
4583-Call all of the handlers for the given objects. Handlers are
4584-subscription adapter factories that don't produce anything. They do
4585-all of their work when called. Handlers are typically used to handle
4586-events.
4587-
4588- - Location: ``zope.component``
4589-
4590- - Signature: `handle(*objects)`
4591-
4592-Example::
4593+Appelle tous les gestionnaires pour un objet donné. Les gestionnaires sont des
4594+fabriques d'abonnés qui ne produisent rien. Ils font tout leur travail lors de
4595+l'appel. Ils sont typiquement utilisés pour gérer des événements.
4596+
4597+ - Emplacement : ``zope.component``
4598+
4599+ - Signature : `handle(*objects)`
4600+
4601+Exemple ::
4602
4603 >>> import datetime
4604
4605@@ -2840,13 +3570,13 @@
4606 implementedBy
4607 ~~~~~~~~~~~~~
4608
4609-Return the interfaces implemented for a class' instances.
4610-
4611- - Location: ``zope.interface``
4612-
4613- - Signature: `implementedBy(class_)`
4614-
4615-Example 1::
4616+Renvoie les interfaces implémentées par une classe.
4617+
4618+ - Emplacement : ``zope.interface``
4619+
4620+ - Signature : `implementedBy(class_)`
4621+
4622+Exemple 1 ::
4623
4624 >>> from zope.interface import Interface
4625 >>> from zope.interface import implements
4626@@ -2866,7 +3596,7 @@
4627 >>> implementedBy(Greeter)
4628 <implementedBy __builtin__.Greeter>
4629
4630-Example 2::
4631+Exemple 2 ::
4632
4633 >>> from zope.interface import Attribute
4634 >>> from zope.interface import Interface
4635@@ -2887,7 +3617,8 @@
4636
4637 >>> from zope.interface import implementedBy
4638
4639- To get a list of all interfaces implemented by that class::
4640+ Pour récupérer une liste de toutes les interfaces implémentées par cette
4641+ classe ::
4642
4643 >>> [x.__name__ for x in implementedBy(Person)]
4644 ['IPerson', 'ISpecial']
4645@@ -2896,15 +3627,15 @@
4646 implementer
4647 ~~~~~~~~~~~
4648
4649-Create a decorator for declaring interfaces implemented by a factory.
4650-A callable is returned that makes an implements declaration on objects
4651-passed to it.
4652-
4653- - Location: ``zope.interface``
4654-
4655- - Signature: `implementer(*interfaces)`
4656-
4657-Example::
4658+Créer un décorateur permettant de déclarer des interfaces implémentées par une
4659+fabrique. Un objet appelable est renvoyé, qui fait une déclaration
4660+d'implémentation sur les objets qui lui sont transmis.
4661+
4662+ - Emplacement : ``zope.interface``
4663+
4664+ - Signature : `implementer(*interfaces)`
4665+
4666+Exemple ::
4667
4668 >>> from zope.interface import implementer
4669 >>> class IFoo(Interface):
4670@@ -2923,17 +3654,17 @@
4671 implements
4672 ~~~~~~~~~~
4673
4674-Declare interfaces implemented by instances of a class This function
4675-is called in a class definition. The arguments are one or more
4676-interfaces. The interfaces given are added to any interfaces
4677-previously declared. Previous declarations include declarations for
4678-base classes unless implementsOnly was used.
4679-
4680- - Location: ``zope.interface``
4681-
4682- - Signature: `implements(*interfaces)`
4683-
4684-Example::
4685+Déclare que des interfaces seront fournies par une classe. Cette fonction est
4686+appelée dans une définition de classe. Les arguments sont une ou plusieurs
4687+interfaces. Les interfaces données sont ajoutées aux interfaces précédemment
4688+déclarées. Les déclarations précédentes incluent les déclarations des classes
4689+debase, à moins que `implementsOnly` ne soit utilisé.
4690+
4691+ - Emplacement : ``zope.interface``
4692+
4693+ - Signature : `implements(*interfaces)`
4694+
4695+Exemple ::
4696
4697 >>> from zope.interface import Attribute
4698 >>> from zope.interface import Interface
4699@@ -2957,19 +3688,20 @@
4700 >>> IPerson in providedBy(jack)
4701 True
4702
4703+
4704 implementsOnly
4705 ~~~~~~~~~~~~~~
4706
4707-Declare the only interfaces implemented by instances of a class. This
4708-function is called in a class definition. The arguments are one or
4709-more interfaces. Previous declarations including declarations for
4710-base classes are overridden.
4711-
4712- - Location: ``zope.interface``
4713-
4714- - Signature: `implementsOnly(*interfaces)`
4715-
4716-Example::
4717+Déclare les seules interfaces qui doivent être implémentées par une classe.
4718+Cette fonction est appelée dans la définition de classe. Les arguments sont une
4719+ou plusieurs interfaces. Les déclarations précédentes, y compris celles des
4720+classes de base, sont remplacées.
4721+
4722+ - Emplacement : ``zope.interface``
4723+
4724+ - Signature : `implementsOnly(*interfaces)`
4725+
4726+Exemple ::
4727
4728 >>> from zope.interface import Attribute
4729 >>> from zope.interface import Interface
4730@@ -3005,35 +3737,78 @@
4731 True
4732
4733
4734+Interface
4735+~~~~~~~~~
4736+
4737+Grâce à cette classe, vous pouvez définir une interface. Pour définir une
4738+interface, contentez-vous d'hériter de cette classe.
4739+
4740+ - Emplacement : ``zope.interface``
4741+
4742+ - Signature : `Interface(name, doc='')`
4743+
4744+Exemple 1 ::
4745+
4746+ >>> from zope.interface import Attribute
4747+ >>> from zope.interface import Interface
4748+
4749+ >>> class IPerson(Interface):
4750+ ...
4751+ ... name = Attribute("Name of person")
4752+ ... email = Attribute("Email Address")
4753+
4754+
4755+Exemple 2 ::
4756+
4757+ >>> from zope.interface import Interface
4758+
4759+ >>> class IHost(Interface):
4760+ ...
4761+ ... def goodmorning(guest):
4762+ ... """Say good morning to guest"""
4763+
4764+
4765 moduleProvides
4766 ~~~~~~~~~~~~~~
4767
4768-Declare interfaces provided by a module. This function is used in a
4769-module definition. The arguments are one or more interfaces. The
4770-given interfaces are used to create the module's direct-object
4771-interface specification. An error will be raised if the module
4772-already has an interface specification. In other words, it is an
4773-error to call this function more than once in a module definition.
4774-
4775-This function is provided for convenience. It provides a more
4776-convenient way to call directlyProvides for a module.
4777-
4778- - Location: ``zope.interface``
4779-
4780- - Signature: `moduleProvides(*interfaces)`
4781+Déclare les interfaces fournies par un module. Cette fonction est utilisée dans
4782+une définition de module. Les arguments sont une ou plusieurs interfaces. Les
4783+interfaces fournies sont utilisées pour créer la spécification d'interface objet
4784+du module. Une erreur est levée si le module a déjà une spécification
4785+d'interface. Autrement dit, c'est une erreur d'appeler cette fonction plus d'une
4786+fois dans une définition de module.
4787+
4788+Cette fonction est fournie pour des raisons pratiques. Elle fournit une manière
4789+plus pratique d'appeler ``directlyProvides`` pour un module.
4790+
4791+ - Emplacement : ``zope.interface``
4792+
4793+ - Signature : `moduleProvides(*interfaces)`
4794+
4795+ - Voir aussi : `directlyProvides`_
4796+
4797+Vous pouvez consulter un exemple d'utilisation dans le code source de
4798+`zope.component` lui-même. Le fichier `__init__.py` possède celle
4799+instruction ::
4800+
4801+ moduleProvides(IComponentArchitecture,
4802+ IComponentRegistrationConvenience)
4803+
4804+Ainsi, le paquet `zope.component` fournit deux interfaces :
4805+`IComponentArchitecture` et `IComponentRegistrationConvenience`.
4806
4807
4808 noLongerProvides
4809 ~~~~~~~~~~~~~~~~
4810
4811-Remove an interface from the list of an object's directly provided
4812-interfaces.
4813-
4814- - Location: ``zope.interface``
4815-
4816- - Signature: `noLongerProvides(object, interface)`
4817-
4818-Example::
4819+Retire une interface de la liste des interfaces directements fournies par un
4820+objet.
4821+
4822+ - Emplacement : ``zope.interface``
4823+
4824+ - Signature : `noLongerProvides(object, interface)`
4825+
4826+Exemple ::
4827
4828 >>> from zope.interface import Attribute
4829 >>> from zope.interface import Interface
4830@@ -3076,39 +3851,38 @@
4831 provideAdapter
4832 ~~~~~~~~~~~~~~
4833
4834-It is recommend to use `registerAdapter`_ .
4835+Il est recommandé d'utilier `registerAdapter`_ .
4836
4837
4838 provideHandler
4839 ~~~~~~~~~~~~~~
4840
4841-It is recommend to use `registerHandler`_ .
4842+Il est recommandé d'utiliser `registerHandler`_ .
4843
4844
4845 provideSubscriptionAdapter
4846 ~~~~~~~~~~~~~~~~~~~~~~~~~~
4847
4848-It is recommend to use `registerSubscriptionAdapter`_ .
4849+Il est recommandé d'utiliser `registerSubscriptionAdapter`_ .
4850
4851
4852 provideUtility
4853 ~~~~~~~~~~~~~~
4854
4855-It is recommend to use `registerUtility`_ .
4856+Il est recommandé d'utiliser `registerUtility`_ .
4857
4858
4859 providedBy
4860 ~~~~~~~~~~
4861
4862-Test whether the interface is implemented by the object. Return true
4863-if the object asserts that it implements the interface, including
4864-asserting that it implements an extended interface.
4865-
4866- - Location: ``zope.interface``
4867-
4868- - Signature: `providedBy(object)`
4869-
4870-Example 1::
4871+Teste si l'interface est implémentée par l'objet. Renvoie True si l'objet
4872+affirme qu'il implémente l'interface, y compris les interfaces étendues.
4873+
4874+ - Emplacement : ``zope.interface``
4875+
4876+ - Signature : `providedBy(object)`
4877+
4878+Exemple 1 ::
4879
4880 >>> from zope.interface import Attribute
4881 >>> from zope.interface import Interface
4882@@ -3132,7 +3906,7 @@
4883 >>> IPerson in providedBy(jack)
4884 True
4885
4886-Example 2::
4887+Exemple 2 ::
4888
4889 >>> from zope.interface import Attribute
4890 >>> from zope.interface import Interface
4891@@ -3154,7 +3928,7 @@
4892 >>> jack = Person()
4893 >>> jack.name = "Jack"
4894
4895- To get a list of all interfaces provided by that object::
4896+ Pour obtenir une liste de toutes les interfaces fournies par cet objet ::
4897
4898 >>> [x.__name__ for x in providedBy(jack)]
4899 ['IPerson', 'ISpecial']
4900@@ -3163,22 +3937,22 @@
4901 queryAdapter
4902 ~~~~~~~~~~~~
4903
4904-Look for a named adapter to an interface for an object. Returns an
4905-adapter that can adapt object to interface. If a matching adapter
4906-cannot be found, returns the default.
4907-
4908- - Location: ``zope.component``
4909-
4910- - Signature: `queryAdapter(object, interface=Interface, name=u'',
4911+Recherche pour un objet un adaptateur nommé vers une interface. Renvoie un
4912+adaptateur qui peut s'adapter à un objet et fournir une interface. Si aucun
4913+adaptateur ne peut être trouvé, la valeur par défaut est renvoyée.
4914+
4915+ - Emplacement : ``zope.component``
4916+
4917+ - Signature : `queryAdapter(object, interface=Interface, name=u'',
4918 default=None, context=None)`
4919
4920-Example::
4921+Exemple ::
4922
4923 >>> from zope.interface import Attribute
4924 >>> from zope.interface import Interface
4925
4926- >>> class IRegistrar(Interface):
4927- ... """A registrar will register object's details"""
4928+ >>> class IDesk(Interface):
4929+ ... """A frontdesk will register object's details"""
4930 ...
4931 ... def register():
4932 ... """Register object's details"""
4933@@ -3187,9 +3961,9 @@
4934 >>> from zope.interface import implements
4935 >>> from zope.component import adapts
4936
4937- >>> class GuestRegistrarNG(object):
4938+ >>> class FrontDeskNG(object):
4939 ...
4940- ... implements(IRegistrar)
4941+ ... implements(IDesk)
4942 ... adapts(IGuest)
4943 ...
4944 ... def __init__(self, guest):
4945@@ -3197,7 +3971,7 @@
4946 ...
4947 ... def register(self):
4948 ... next_id = get_next_id()
4949- ... guests_db[next_id] = {
4950+ ... bookings_db[next_id] = {
4951 ... 'name': guest.name,
4952 ... 'place': guest.place,
4953 ... 'phone': guest.phone
4954@@ -3212,32 +3986,50 @@
4955 ... self.place = place
4956
4957 >>> jack = Guest("Jack", "Bangalore")
4958- >>> jack_registrar = GuestRegistrarNG(jack)
4959+ >>> jack_frontdesk = FrontDeskNG(jack)
4960
4961- >>> IRegistrar.providedBy(jack_registrar)
4962+ >>> IDesk.providedBy(jack_frontdesk)
4963 True
4964
4965 >>> from zope.component import getGlobalSiteManager
4966 >>> gsm = getGlobalSiteManager()
4967- >>> gsm.registerAdapter(GuestRegistrarNG,
4968- ... (IGuest,), IRegistrar, 'ng')
4969+ >>> gsm.registerAdapter(FrontDeskNG,
4970+ ... (IGuest,), IDesk, 'ng')
4971
4972- >>> queryAdapter(jack, IRegistrar, 'ng') #doctest: +ELLIPSIS
4973- <GuestRegistrarNG object at ...>
4974+ >>> queryAdapter(jack, IDesk, 'ng') #doctest: +ELLIPSIS
4975+ <FrontDeskNG object at ...>
4976
4977
4978 queryAdapterInContext
4979 ~~~~~~~~~~~~~~~~~~~~~
4980
4981-Instead of this function, use `context` argument of `queryAdapter`_
4982-function.
4983-
4984- - Location: ``zope.component``
4985-
4986- - Signature: `queryAdapterInContext(object, interface, context,
4987+Recherche pour un objet un adaptateur spécial vers une interface.
4988+
4989+NOTE : cette méthode ne doit être utilisée que si un contexte personnalisé doit
4990+être fourni lors d'une recherche de composant personnalisée. Sinon, appelez
4991+l'interface comme ci-dessous ::
4992+
4993+ interface(object, default)
4994+
4995+Renvoie un adaptateur qui peut s'adapter à l'objet et fournir l'interface. Si
4996+aucun adaptateur n'est fourni, la valeur par défaut est renvoyée.
4997+
4998+Le contexte est adapté à IServiceService, et ce service d'adaptateurs, fourni par
4999+l'adaptateur, est utilisé.
5000+
The diff has been truncated for viewing.

Subscribers

People subscribed via source and target branches

to status/vote changes: