« back to all changes in this revision
Viewing changes to dogtail/predicate.py
- browse files at revision 1.1.2
- compare with another revision
- download diff
- download tarball
- view history from revision 1.1.2
- Committer: Bazaar Package Importer
- Author(s): Daniel Holbach
- Date: 2006-12-21 13:33:47 UTC
- mfrom: (1.2.1 upstream)
- mto: This revision was merged to the branch mainline in revision 5.
- Revision ID: james.westby@ubuntu.com-20061221133347-xo9jg11afp5plcka
Tags: upstream-0.6.1
Import upstream version 0.6.1
- files added:
- examples/data/10b.png
- recorder
- files removed:
- debian
- dogtail/apps
- dogtail/apps/wrappers
- files modified:
- HACKING
added
removed
dogtail/predicate.py
8
8
from i18n import TranslatableString
9
9
10
10
def stringMatches(scriptName, reportedName):
11
assert isinstance(scriptName, TranslatableString)
12
13
return scriptName.matchedBy(reportedName)
14
11
assert isinstance(scriptName, TranslatableString)
12
13
return scriptName.matchedBy(reportedName)
14
15
15
def makeScriptRecursiveArgument(isRecursive, defaultValue):
16
if isRecursive==defaultValue:
17
return ""
18
else:
19
return ", recursive=%s"%isRecursive
16
if isRecursive==defaultValue:
17
return ""
18
else:
19
return ", recursive=%s"%isRecursive
20
20
21
21
def makeCamel(string):
22
"""
23
Convert string to camelCaps
24
"""
25
string = str(string)
26
# FIXME: this function is probably really fragile, lots of difficult cases here
22
"""
23
Convert string to camelCaps
24
"""
25
string = str(string)
26
# FIXME: this function is probably really fragile, lots of difficult cases here
27
27
28
# Sanitize string, replacing bad characters with spaces:
29
for char in ":;!@#$%^&*()-+=_~`\\/?|[]{}<>,.\t\n\r\"'":
30
string = string.replace(char, " ")
31
words = string.strip().split(" ")
32
for word in words:
33
word.strip
34
result = ""
35
firstWord=True
36
for word in words:
37
lowercaseWord = word.lower()
38
if firstWord:
39
result += lowercaseWord
40
firstWord=False
41
else:
42
result += lowercaseWord.capitalize()
43
return result
28
# Sanitize string, replacing bad characters with spaces:
29
for char in ":;!@#$%^&*()-+=_~`\\/?|[]{}<>,.\t\n\r\"'":
30
string = string.replace(char, " ")
31
words = string.strip().split(" ")
32
for word in words:
33
word.strip
34
result = ""
35
firstWord=True
36
for word in words:
37
lowercaseWord = word.lower()
38
if firstWord:
39
result += lowercaseWord
40
firstWord=False
41
else:
42
result += lowercaseWord.capitalize()
43
return result
44
44
45
45
class Predicate:
46
"""Abstract base class representing a predicate function on nodes.
47
48
It's more than just a function in that it has data and can describe itself"""
49
def satisfiedByNode(self, node):
50
"""Pure virtual method returning a boolean if the predicate is satisfied by the node"""
51
raise NotImplementedError
52
53
def describeSearchResult(self, node):
54
raise NotImplementedError
55
56
def makeScriptMethodCall(self, isRecursive):
57
"""
58
Method to generate a string containing a (hopefully) readable search
59
method call on a node (to be used when generating Python source code in
60
the event recorder)
61
"""
62
raise NotImplementedError
63
64
def makeScriptVariableName(self):
65
"""
66
Method to generate a string containing a (hopefully) readable name
67
for a Node instance variable that would be the result of a search on
68
this predicate (to be used when generating Python source code in the
69
event recorder).
70
"""
71
raise NotImplementedError
72
73
def __eq__(self, other):
74
"""
75
Predicates are considered equal if they are of the same subclass and
76
have the same data
77
"""
78
# print "predeq: self:%s"%self
79
# print " other:%s"%other
80
# print "predeq: selfdict:%s"%self.__dict__
81
# print " otherdict:%s"%other.__dict__
82
83
if type(self)!=type(other):
84
return False
85
else:
86
return self.__dict__ == other.__dict__
46
"""Abstract base class representing a predicate function on nodes.
47
48
It's more than just a function in that it has data and can describe itself"""
49
def satisfiedByNode(self, node):
50
"""Pure virtual method returning a boolean if the predicate is satisfied by the node"""
51
raise NotImplementedError
52
53
def describeSearchResult(self, node):
54
raise NotImplementedError
55
56
def makeScriptMethodCall(self, isRecursive):
57
"""
58
Method to generate a string containing a (hopefully) readable search
59
method call on a node (to be used when generating Python source code in
60
the event recorder)
61
"""
62
raise NotImplementedError
63
64
def makeScriptVariableName(self):
65
"""
66
Method to generate a string containing a (hopefully) readable name
67
for a Node instance variable that would be the result of a search on
68
this predicate (to be used when generating Python source code in the
69
event recorder).
70
"""
71
raise NotImplementedError
72
73
def __eq__(self, other):
74
"""
75
Predicates are considered equal if they are of the same subclass and
76
have the same data
77
"""
78
# print "predeq: self:%s"%self
79
# print " other:%s"%other
80
# print "predeq: selfdict:%s"%self.__dict__
81
# print " otherdict:%s"%other.__dict__
82
83
if type(self)!=type(other):
84
return False
85
else:
86
return self.__dict__ == other.__dict__
87
87
88
88
89
89
class IsAnApplicationNamed(Predicate):
90
"""Search subclass that looks for an application by name"""
91
def __init__(self, appName):
92
self.appName = TranslatableString(appName)
93
94
def satisfiedByNode(self, node):
95
return node.roleName=='application' and stringMatches(self.appName, node.name)
96
97
def describeSearchResult(self):
98
return '%s application'%self.appName
99
100
def makeScriptMethodCall(self, isRecursive):
101
# ignores the isRecursive parameter
102
return "application('%s')"%self.appName
103
104
def makeScriptVariableName(self):
105
return makeCamel(self.appName)+"App"
90
"""Search subclass that looks for an application by name"""
91
def __init__(self, appName):
92
self.appName = TranslatableString(appName)
93
self.debugName = self.describeSearchResult()
94
95
def satisfiedByNode(self, node):
96
return node.roleName=='application' and stringMatches(self.appName, node.name)
97
98
def describeSearchResult(self):
99
return '%s application'%self.appName
100
101
def makeScriptMethodCall(self, isRecursive):
102
# ignores the isRecursive parameter
103
return "application(%s)"%self.appName
104
105
def makeScriptVariableName(self):
106
return makeCamel(self.appName)+"App"
106
107
107
108
class GenericPredicate(Predicate):
108
"""SubtreePredicate subclass that takes various optional search fields"""
109
110
def __init__(self, name = None, roleName = None, description= None, label = None, debugName=None):
111
if name:
112
self.name = TranslatableString(name)
113
else:
114
self.name = None
115
self.roleName = roleName
116
self.description = description
117
if label:
118
self.label = TranslatableString(label)
119
else:
120
self.label = None
121
122
if debugName:
123
self.debugName = debugName
124
else:
125
if label:
126
self.debugName = "labelled '%s'"%self.label
127
else:
128
self.debugName = "child with"
129
if name:
130
self.debugName += " name=%s" % self.name
131
if roleName:
132
self.debugName += " roleName='%s'"%roleName
133
if description:
134
self.debugName += " description='%s'"%description
135
assert self.debugName
136
137
138
def satisfiedByNode(self, node):
139
# labelled nodes are handled specially:
140
if self.label:
141
# this reverses the search; we're looking for a node with LABELLED_BY
142
# and then checking the label, rather than looking for a label and
143
# then returning whatever LABEL_FOR targets
144
if node.labeller:
145
return stringMatches(self.label, node.labeller.name)
146
else: return False
147
else:
148
# Ensure the node matches any criteria that were set:
149
if self.name:
150
if not stringMatches(self.name,node.name): return False
151
if self.roleName:
152
if self.roleName!=node.roleName: return False
153
if self.description:
154
if self.description!=node.description: return False
155
return True
156
157
def describeSearchResult(self):
158
return self.debugName
159
160
def makeScriptMethodCall(self, isRecursive):
161
if self.label:
162
args = "label='%s'"%label
163
else:
164
args = ""
165
if self.name:
166
args += " name='%s'"%self.name
167
if self.roleName:
168
args += " roleName='%s'"%self.roleName
169
if self.description:
170
args += " description='%s'"%self.description
171
return "child(%s%s)"%(args, makeScriptRecursiveArgument(isRecursive, True))
172
173
def makeScriptVariableName(self):
174
if self.label:
175
return makeCamel(self.label)+"Node"
176
else:
177
if self.name:
178
return makeCamel(self.name)+"Node"
179
if self.roleName:
180
return makeCamel(self.roleName)+"Node"
181
if self.description:
182
return makeCamel(self.description)+"Node"
109
"""SubtreePredicate subclass that takes various optional search fields"""
110
111
def __init__(self, name = None, roleName = None, description= None, label = None, debugName=None):
112
if name:
113
self.name = TranslatableString(name)
114
else:
115
self.name = None
116
self.roleName = roleName
117
self.description = description
118
if label:
119
self.label = TranslatableString(label)
120
else:
121
self.label = None
122
123
if debugName:
124
self.debugName = debugName
125
else:
126
if label:
127
self.debugName = "labelled '%s'"%self.label
128
else:
129
self.debugName = "child with"
130
if name:
131
self.debugName += " name=%s" % self.name
132
if roleName:
133
self.debugName += " roleName='%s'"%roleName
134
if description:
135
self.debugName += " description='%s'"%description
136
assert self.debugName
137
138
139
def satisfiedByNode(self, node):
140
# labelled nodes are handled specially:
141
if self.label:
142
# this reverses the search; we're looking for a node with LABELLED_BY
143
# and then checking the label, rather than looking for a label and
144
# then returning whatever LABEL_FOR targets
145
if node.labeller:
146
return stringMatches(self.label, node.labeller.name)
147
else: return False
148
else:
149
# Ensure the node matches any criteria that were set:
150
if self.name:
151
if not stringMatches(self.name,node.name): return False
152
if self.roleName:
153
if self.roleName!=node.roleName: return False
154
if self.description:
155
if self.description!=node.description: return False
156
return True
157
158
def describeSearchResult(self):
159
return self.debugName
160
161
def makeScriptMethodCall(self, isRecursive):
162
if self.label:
163
args = "label=%s"%label
164
else:
165
args = ""
166
if self.name:
167
args += " name=%s"%self.name
168
if self.roleName:
169
args += " roleName=%s"%self.roleName
170
if self.description:
171
args += " description=%s"%self.description
172
return "child(%s%s)"%(args, makeScriptRecursiveArgument(isRecursive, True))
173
174
def makeScriptVariableName(self):
175
if self.label:
176
return makeCamel(self.label)+"Node"
177
else:
178
if self.name:
179
return makeCamel(self.name)+"Node"
180
if self.roleName:
181
return makeCamel(self.roleName)+"Node"
182
if self.description:
183
return makeCamel(self.description)+"Node"
183
184
184
185
class IsNamed(Predicate):
185
"""Predicate subclass that looks simply by name"""
186
187
def __init__(self, name):
188
self.name = TranslatableString(name)
189
190
def satisfiedByNode(self, node):
191
return stringMatches(self.name, node.name)
192
193
def describeSearchResult(self):
194
return "named %s"%self.name
195
196
def makeScriptMethodCall(self, isRecursive):
197
return "child(name='%s'%s)"%(self.name, makeScriptRecursiveArgument(isRecursive, True))
198
def makeScriptVariableName(self):
199
return makeCamel(self.name)+"Node"
186
"""Predicate subclass that looks simply by name"""
187
188
def __init__(self, name):
189
self.name = TranslatableString(name)
190
self.debugName = self.describeSearchResult()
191
192
def satisfiedByNode(self, node):
193
return stringMatches(self.name, node.name)
194
195
def describeSearchResult(self):
196
return "named %s"%self.name
197
198
def makeScriptMethodCall(self, isRecursive):
199
return "child(name=%s%s)"%(self.name, makeScriptRecursiveArgument(isRecursive, True))
200
def makeScriptVariableName(self):
201
return makeCamel(self.name)+"Node"
200
202
201
203
class IsAWindowNamed(Predicate):
202
"""Predicate subclass that looks for a top-level window by name"""
203
def __init__(self, windowName):
204
self.windowName = TranslatableString(windowName)
205
206
def satisfiedByNode(self, node):
207
return node.roleName=='frame' and stringMatches(self.windowName, node.name)
208
209
def describeSearchResult(self):
210
return "%s window"%self.windowName
211
212
def makeScriptMethodCall(self, isRecursive):
213
return "window('%s'%s)"%(self.windowName, makeScriptRecursiveArgument(isRecursive, False))
214
215
def makeScriptVariableName(self):
216
return makeCamel(self.windowName)+"Win"
204
"""Predicate subclass that looks for a top-level window by name"""
205
def __init__(self, windowName):
206
self.windowName = TranslatableString(windowName)
207
self.debugName = self.describeSearchResult()
208
209
def satisfiedByNode(self, node):
210
return node.roleName=='frame' and stringMatches(self.windowName, node.name)
211
212
def describeSearchResult(self):
213
return "%s window"%self.windowName
214
215
def makeScriptMethodCall(self, isRecursive):
216
return "window(%s%s)"%(self.windowName, makeScriptRecursiveArgument(isRecursive, False))
217
218
def makeScriptVariableName(self):
219
return makeCamel(self.windowName)+"Win"
217
220
218
221
class IsAWindow(Predicate):
219
"""Predicate subclass that looks for top-level windows"""
220
def satisfiedByNode(self, node):
221
return node.roleName=='frame'
222
"""Predicate subclass that looks for top-level windows"""
223
def satisfiedByNode(self, node):
224
return node.roleName=='frame'
222
225
223
def describeSearchResult(self):
224
return "window"
226
def describeSearchResult(self):
227
return "window"
225
228
226
229
class IsADialogNamed(Predicate):
227
"""Predicate subclass that looks for a top-level dialog by name"""
228
def __init__(self, dialogName):
229
self.dialogName = TranslatableString(dialogName)
230
231
def satisfiedByNode(self, node):
232
return node.roleName=='dialog' and stringMatches(self.dialogName, node.name)
233
234
def describeSearchResult(self):
235
return '%s dialog'%self.dialogName
236
237
def makeScriptMethodCall(self, isRecursive):
238
return "dialog('%s'%s)"%(self.dialogName, makeScriptRecursiveArgument(isRecursive, False))
239
240
def makeScriptVariableName(self):
241
return makeCamel(self.dialogName)+"Dlg"
230
"""Predicate subclass that looks for a top-level dialog by name"""
231
def __init__(self, dialogName):
232
self.dialogName = TranslatableString(dialogName)
233
self.debugName = self.describeSearchResult()
234
235
def satisfiedByNode(self, node):
236
return node.roleName=='dialog' and stringMatches(self.dialogName, node.name)
237
238
def describeSearchResult(self):
239
return '%s dialog'%self.dialogName
240
241
def makeScriptMethodCall(self, isRecursive):
242
return "dialog(%s%s)"%(self.dialogName, makeScriptRecursiveArgument(isRecursive, False))
243
244
def makeScriptVariableName(self):
245
return makeCamel(self.dialogName)+"Dlg"
242
246
243
247
class IsLabelledBy(Predicate):
244
"""Predicate: is this node labelled by another node"""
245
pass
248
"""Predicate: is this node labelled by another node"""
249
pass
246
250
247
251
class IsLabelledAs(Predicate):
248
"""Predicate: is this node labelled with the text string (i.e. by another node with that as a name)"""
249
def __init__(self, labelText):
250
self.labelText = TranslatableString(labelText)
251
252
def satisfiedByNode(self, node):
253
# FIXME
254
if node.labeller:
255
return stringMatches(self.labelText, node.labeller.name)
256
else: return False
257
258
def describeSearchResult(self):
259
return 'labelled %s'%self.labelText
260
261
def makeScriptMethodCall(self, isRecursive):
262
return "child(label='%s'%s)"%(self.labelText, makeScriptRecursiveArgument(isRecursive, True))
263
264
def makeScriptVariableName(self):
265
return makeCamel(self.labelText)+"Node"
252
"""Predicate: is this node labelled with the text string (i.e. by another node with that as a name)"""
253
def __init__(self, labelText):
254
self.labelText = TranslatableString(labelText)
255
self.debugName = self.describeSearchResult()
256
257
def satisfiedByNode(self, node):
258
# FIXME
259
if node.labeller:
260
return stringMatches(self.labelText, node.labeller.name)
261
else: return False
262
263
def describeSearchResult(self):
264
return 'labelled %s'%self.labelText
265
266
def makeScriptMethodCall(self, isRecursive):
267
return "child(label=%s%s)"%(self.labelText, makeScriptRecursiveArgument(isRecursive, True))
268
269
def makeScriptVariableName(self):
270
return makeCamel(self.labelText)+"Node"
266
271
267
272
class IsAMenuNamed(Predicate):
268
"""Predicate subclass that looks for a menu by name"""
269
def __init__(self, menuName):
270
self.menuName = TranslatableString(menuName)
271
272
def satisfiedByNode(self, node):
273
return node.roleName=='menu' and stringMatches(self.menuName, node.name)
274
275
def describeSearchResult(self):
276
return '%s menu'%(self.menuName)
277
278
def makeScriptMethodCall(self, isRecursive):
279
return "menu('%s'%s)"%(self.menuName, makeScriptRecursiveArgument(isRecursive, True))
280
281
def makeScriptVariableName(self):
282
return makeCamel(self.menuName)+"Menu"
273
"""Predicate subclass that looks for a menu by name"""
274
def __init__(self, menuName):
275
self.menuName = TranslatableString(menuName)
276
self.debugName = self.describeSearchResult()
277
278
def satisfiedByNode(self, node):
279
return node.roleName=='menu' and stringMatches(self.menuName, node.name)
280
281
def describeSearchResult(self):
282
return '%s menu'%(self.menuName)
283
284
def makeScriptMethodCall(self, isRecursive):
285
return "menu(%s%s)"%(self.menuName, makeScriptRecursiveArgument(isRecursive, True))
286
287
def makeScriptVariableName(self):
288
return makeCamel(self.menuName)+"Menu"
283
289
284
290
class IsAMenuItemNamed(Predicate):
285
"""Predicate subclass that looks for a menu item by name"""
286
def __init__(self, menuItemName):
287
self.menuItemName = TranslatableString(menuItemName)
288
289
def satisfiedByNode(self, node):
290
roleName = node.roleName
291
return (roleName=='menu item' or roleName=='check menu item' or roleName=='radio menu item') and stringMatches(self.menuItemName, node.name)
292
293
def describeSearchResult(self):
294
return '%s menuitem'%(self.menuItemName)
295
296
def makeScriptMethodCall(self, isRecursive):
297
return "menuItem('%s'%s)"%(self.menuItemName, makeScriptRecursiveArgument(isRecursive, True))
298
299
def makeScriptVariableName(self):
300
return makeCamel(self.menuItemName)+"MenuItem"
291
"""Predicate subclass that looks for a menu item by name"""
292
def __init__(self, menuItemName):
293
self.menuItemName = TranslatableString(menuItemName)
294
self.debugName = self.describeSearchResult()
295
296
def satisfiedByNode(self, node):
297
roleName = node.roleName
298
return (roleName=='menu item' or roleName=='check menu item' or roleName=='radio menu item') and stringMatches(self.menuItemName, node.name)
299
300
def describeSearchResult(self):
301
return '%s menuitem'%(self.menuItemName)
302
303
def makeScriptMethodCall(self, isRecursive):
304
return "menuItem(%s%s)"%(self.menuItemName, makeScriptRecursiveArgument(isRecursive, True))
305
306
def makeScriptVariableName(self):
307
return makeCamel(self.menuItemName)+"MenuItem"
301
308
302
309
class IsATextEntryNamed(Predicate):
303
"""Predicate subclass that looks for a text entry by name"""
304
def __init__(self, textEntryName):
305
self.textEntryName = TranslatableString(textEntryName)
306
307
def satisfiedByNode(self, node):
308
return node.roleName=='text' and stringMatches(self.textEntryName, node.name)
309
310
def describeSearchResult(self):
311
return '%s textentry'%(self.textEntryName)
312
313
def makeScriptMethodCall(self, isRecursive):
314
return "textentry('%s'%s)"%(self.textEntryName, makeScriptRecursiveArgument(isRecursive, True))
315
316
def makeScriptVariableName(self):
317
return makeCamel(self.textEntryName)+"Entry"
310
"""Predicate subclass that looks for a text entry by name"""
311
def __init__(self, textEntryName):
312
self.textEntryName = TranslatableString(textEntryName)
313
self.debugName = self.describeSearchResult()
314
315
def satisfiedByNode(self, node):
316
return node.roleName=='text' and stringMatches(self.textEntryName, node.name)
317
318
def describeSearchResult(self):
319
return '%s textentry'%(self.textEntryName)
320
321
def makeScriptMethodCall(self, isRecursive):
322
return "textentry(%s%s)"%(self.textEntryName, makeScriptRecursiveArgument(isRecursive, True))
323
324
def makeScriptVariableName(self):
325
return makeCamel(self.textEntryName)+"Entry"
318
326
319
327
class IsAButtonNamed(Predicate):
320
"""Predicate subclass that looks for a button by name"""
321
def __init__(self, buttonName):
322
self.buttonName = TranslatableString(buttonName)
323
324
def satisfiedByNode(self, node):
325
return node.roleName=='push button' and stringMatches(self.buttonName, node.name)
326
327
def describeSearchResult(self):
328
return '%s button'%(self.buttonName)
329
330
def makeScriptMethodCall(self, isRecursive):
331
return "button('%s'%s)"%(self.buttonName, makeScriptRecursiveArgument(isRecursive, True))
332
333
def makeScriptVariableName(self):
334
return makeCamel(self.buttonName)+"Button"
328
"""Predicate subclass that looks for a button by name"""
329
def __init__(self, buttonName):
330
self.buttonName = TranslatableString(buttonName)
331
self.debugName = self.describeSearchResult()
332
333
def satisfiedByNode(self, node):
334
return node.roleName=='push button' and stringMatches(self.buttonName, node.name)
335
336
def describeSearchResult(self):
337
return '%s button'%(self.buttonName)
338
339
def makeScriptMethodCall(self, isRecursive):
340
return "button(%s%s)"%(self.buttonName, makeScriptRecursiveArgument(isRecursive, True))
341
342
def makeScriptVariableName(self):
343
return makeCamel(self.buttonName)+"Button"
335
344
336
345
class IsATabNamed(Predicate):
337
"""Predicate subclass that looks for a tab by name"""
338
def __init__(self, tabName):
339
self.tabName = TranslatableString(tabName)
340
341
def satisfiedByNode(self, node):
342
return node.roleName=='page tab' and stringMatches(self.tabName, node.name)
343
344
def describeSearchResult(self):
345
return '%s tab'%(self.tabName)
346
347
def makeScriptMethodCall(self, isRecursive):
348
return "tab('%s'%s)"%(self.tabName, makeScriptRecursiveArgument(isRecursive, True))
349
350
def makeScriptVariableName(self):
351
return makeCamel(self.tabName)+"Tab"
346
"""Predicate subclass that looks for a tab by name"""
347
def __init__(self, tabName):
348
self.tabName = TranslatableString(tabName)
349
self.debugName = self.describeSearchResult()
350
351
def satisfiedByNode(self, node):
352
return node.roleName=='page tab' and stringMatches(self.tabName, node.name)
353
354
def describeSearchResult(self):
355
return '%s tab'%(self.tabName)
356
357
def makeScriptMethodCall(self, isRecursive):
358
return "tab(%s%s)"%(self.tabName, makeScriptRecursiveArgument(isRecursive, True))
359
360
def makeScriptVariableName(self):
361
return makeCamel(self.tabName)+"Tab"
352
362
353
363
class PredicateTests(unittest.TestCase):
354
def testCapitalization(self):
355
self.assertEquals(makeCamel("gnome-terminal"),"gnomeTerminal")
356
self.assertEquals(makeCamel("Evolution - Mail"), "evolutionMail")
357
self.assertEquals(makeCamel('self.assertEquals(makeCamel("Evolution - Mail"), "evolutionMail")'), "selfAssertequalsMakecamelEvolutionMailEvolutionmail")
364
def testCapitalization(self):
365
self.assertEquals(makeCamel("gnome-terminal"),"gnomeTerminal")
366
self.assertEquals(makeCamel("Evolution - Mail"), "evolutionMail")
367
self.assertEquals(makeCamel('self.assertEquals(makeCamel("Evolution - Mail"), "evolutionMail")'), "selfAssertequalsMakecamelEvolutionMailEvolutionmail")
358
368
359
369
if __name__ == "__main__":
360
unittest.main()
370
unittest.main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.1