##// END OF EJS Templates
Merge pull request #8253 from SylvainCorlay/context_manager...
Min RK -
r21160:de3a01a4 merge
parent child Browse files
Show More
@@ -1,1634 +1,1634
1 # encoding: utf-8
1 # encoding: utf-8
2 """Tests for IPython.utils.traitlets."""
2 """Tests for IPython.utils.traitlets."""
3
3
4 # Copyright (c) IPython Development Team.
4 # Copyright (c) IPython Development Team.
5 # Distributed under the terms of the Modified BSD License.
5 # Distributed under the terms of the Modified BSD License.
6 #
6 #
7 # Adapted from enthought.traits, Copyright (c) Enthought, Inc.,
7 # Adapted from enthought.traits, Copyright (c) Enthought, Inc.,
8 # also under the terms of the Modified BSD License.
8 # also under the terms of the Modified BSD License.
9
9
10 import pickle
10 import pickle
11 import re
11 import re
12 import sys
12 import sys
13 from unittest import TestCase
13 from unittest import TestCase
14
14
15 import nose.tools as nt
15 import nose.tools as nt
16 from nose import SkipTest
16 from nose import SkipTest
17
17
18 from IPython.utils.traitlets import (
18 from IPython.utils.traitlets import (
19 HasTraits, MetaHasTraits, TraitType, Any, Bool, CBytes, Dict, Enum,
19 HasTraits, MetaHasTraits, TraitType, Any, Bool, CBytes, Dict, Enum,
20 Int, Long, Integer, Float, Complex, Bytes, Unicode, TraitError,
20 Int, Long, Integer, Float, Complex, Bytes, Unicode, TraitError,
21 Union, Undefined, Type, This, Instance, TCPAddress, List, Tuple,
21 Union, Undefined, Type, This, Instance, TCPAddress, List, Tuple,
22 ObjectName, DottedObjectName, CRegExp, link, directional_link,
22 ObjectName, DottedObjectName, CRegExp, link, directional_link,
23 EventfulList, EventfulDict, ForwardDeclaredType, ForwardDeclaredInstance,
23 EventfulList, EventfulDict, ForwardDeclaredType, ForwardDeclaredInstance,
24 )
24 )
25 from IPython.utils import py3compat
25 from IPython.utils import py3compat
26 from IPython.testing.decorators import skipif
26 from IPython.testing.decorators import skipif
27
27
28 #-----------------------------------------------------------------------------
28 #-----------------------------------------------------------------------------
29 # Helper classes for testing
29 # Helper classes for testing
30 #-----------------------------------------------------------------------------
30 #-----------------------------------------------------------------------------
31
31
32
32
33 class HasTraitsStub(HasTraits):
33 class HasTraitsStub(HasTraits):
34
34
35 def _notify_trait(self, name, old, new):
35 def _notify_trait(self, name, old, new):
36 self._notify_name = name
36 self._notify_name = name
37 self._notify_old = old
37 self._notify_old = old
38 self._notify_new = new
38 self._notify_new = new
39
39
40
40
41 #-----------------------------------------------------------------------------
41 #-----------------------------------------------------------------------------
42 # Test classes
42 # Test classes
43 #-----------------------------------------------------------------------------
43 #-----------------------------------------------------------------------------
44
44
45
45
46 class TestTraitType(TestCase):
46 class TestTraitType(TestCase):
47
47
48 def test_get_undefined(self):
48 def test_get_undefined(self):
49 class A(HasTraits):
49 class A(HasTraits):
50 a = TraitType
50 a = TraitType
51 a = A()
51 a = A()
52 self.assertEqual(a.a, Undefined)
52 self.assertEqual(a.a, Undefined)
53
53
54 def test_set(self):
54 def test_set(self):
55 class A(HasTraitsStub):
55 class A(HasTraitsStub):
56 a = TraitType
56 a = TraitType
57
57
58 a = A()
58 a = A()
59 a.a = 10
59 a.a = 10
60 self.assertEqual(a.a, 10)
60 self.assertEqual(a.a, 10)
61 self.assertEqual(a._notify_name, 'a')
61 self.assertEqual(a._notify_name, 'a')
62 self.assertEqual(a._notify_old, Undefined)
62 self.assertEqual(a._notify_old, Undefined)
63 self.assertEqual(a._notify_new, 10)
63 self.assertEqual(a._notify_new, 10)
64
64
65 def test_validate(self):
65 def test_validate(self):
66 class MyTT(TraitType):
66 class MyTT(TraitType):
67 def validate(self, inst, value):
67 def validate(self, inst, value):
68 return -1
68 return -1
69 class A(HasTraitsStub):
69 class A(HasTraitsStub):
70 tt = MyTT
70 tt = MyTT
71
71
72 a = A()
72 a = A()
73 a.tt = 10
73 a.tt = 10
74 self.assertEqual(a.tt, -1)
74 self.assertEqual(a.tt, -1)
75
75
76 def test_default_validate(self):
76 def test_default_validate(self):
77 class MyIntTT(TraitType):
77 class MyIntTT(TraitType):
78 def validate(self, obj, value):
78 def validate(self, obj, value):
79 if isinstance(value, int):
79 if isinstance(value, int):
80 return value
80 return value
81 self.error(obj, value)
81 self.error(obj, value)
82 class A(HasTraits):
82 class A(HasTraits):
83 tt = MyIntTT(10)
83 tt = MyIntTT(10)
84 a = A()
84 a = A()
85 self.assertEqual(a.tt, 10)
85 self.assertEqual(a.tt, 10)
86
86
87 # Defaults are validated when the HasTraits is instantiated
87 # Defaults are validated when the HasTraits is instantiated
88 class B(HasTraits):
88 class B(HasTraits):
89 tt = MyIntTT('bad default')
89 tt = MyIntTT('bad default')
90 self.assertRaises(TraitError, B)
90 self.assertRaises(TraitError, B)
91
91
92 def test_info(self):
92 def test_info(self):
93 class A(HasTraits):
93 class A(HasTraits):
94 tt = TraitType
94 tt = TraitType
95 a = A()
95 a = A()
96 self.assertEqual(A.tt.info(), 'any value')
96 self.assertEqual(A.tt.info(), 'any value')
97
97
98 def test_error(self):
98 def test_error(self):
99 class A(HasTraits):
99 class A(HasTraits):
100 tt = TraitType
100 tt = TraitType
101 a = A()
101 a = A()
102 self.assertRaises(TraitError, A.tt.error, a, 10)
102 self.assertRaises(TraitError, A.tt.error, a, 10)
103
103
104 def test_dynamic_initializer(self):
104 def test_dynamic_initializer(self):
105 class A(HasTraits):
105 class A(HasTraits):
106 x = Int(10)
106 x = Int(10)
107 def _x_default(self):
107 def _x_default(self):
108 return 11
108 return 11
109 class B(A):
109 class B(A):
110 x = Int(20)
110 x = Int(20)
111 class C(A):
111 class C(A):
112 def _x_default(self):
112 def _x_default(self):
113 return 21
113 return 21
114
114
115 a = A()
115 a = A()
116 self.assertEqual(a._trait_values, {})
116 self.assertEqual(a._trait_values, {})
117 self.assertEqual(list(a._trait_dyn_inits.keys()), ['x'])
117 self.assertEqual(list(a._trait_dyn_inits.keys()), ['x'])
118 self.assertEqual(a.x, 11)
118 self.assertEqual(a.x, 11)
119 self.assertEqual(a._trait_values, {'x': 11})
119 self.assertEqual(a._trait_values, {'x': 11})
120 b = B()
120 b = B()
121 self.assertEqual(b._trait_values, {'x': 20})
121 self.assertEqual(b._trait_values, {'x': 20})
122 self.assertEqual(list(a._trait_dyn_inits.keys()), ['x'])
122 self.assertEqual(list(a._trait_dyn_inits.keys()), ['x'])
123 self.assertEqual(b.x, 20)
123 self.assertEqual(b.x, 20)
124 c = C()
124 c = C()
125 self.assertEqual(c._trait_values, {})
125 self.assertEqual(c._trait_values, {})
126 self.assertEqual(list(a._trait_dyn_inits.keys()), ['x'])
126 self.assertEqual(list(a._trait_dyn_inits.keys()), ['x'])
127 self.assertEqual(c.x, 21)
127 self.assertEqual(c.x, 21)
128 self.assertEqual(c._trait_values, {'x': 21})
128 self.assertEqual(c._trait_values, {'x': 21})
129 # Ensure that the base class remains unmolested when the _default
129 # Ensure that the base class remains unmolested when the _default
130 # initializer gets overridden in a subclass.
130 # initializer gets overridden in a subclass.
131 a = A()
131 a = A()
132 c = C()
132 c = C()
133 self.assertEqual(a._trait_values, {})
133 self.assertEqual(a._trait_values, {})
134 self.assertEqual(list(a._trait_dyn_inits.keys()), ['x'])
134 self.assertEqual(list(a._trait_dyn_inits.keys()), ['x'])
135 self.assertEqual(a.x, 11)
135 self.assertEqual(a.x, 11)
136 self.assertEqual(a._trait_values, {'x': 11})
136 self.assertEqual(a._trait_values, {'x': 11})
137
137
138
138
139
139
140 class TestHasTraitsMeta(TestCase):
140 class TestHasTraitsMeta(TestCase):
141
141
142 def test_metaclass(self):
142 def test_metaclass(self):
143 self.assertEqual(type(HasTraits), MetaHasTraits)
143 self.assertEqual(type(HasTraits), MetaHasTraits)
144
144
145 class A(HasTraits):
145 class A(HasTraits):
146 a = Int
146 a = Int
147
147
148 a = A()
148 a = A()
149 self.assertEqual(type(a.__class__), MetaHasTraits)
149 self.assertEqual(type(a.__class__), MetaHasTraits)
150 self.assertEqual(a.a,0)
150 self.assertEqual(a.a,0)
151 a.a = 10
151 a.a = 10
152 self.assertEqual(a.a,10)
152 self.assertEqual(a.a,10)
153
153
154 class B(HasTraits):
154 class B(HasTraits):
155 b = Int()
155 b = Int()
156
156
157 b = B()
157 b = B()
158 self.assertEqual(b.b,0)
158 self.assertEqual(b.b,0)
159 b.b = 10
159 b.b = 10
160 self.assertEqual(b.b,10)
160 self.assertEqual(b.b,10)
161
161
162 class C(HasTraits):
162 class C(HasTraits):
163 c = Int(30)
163 c = Int(30)
164
164
165 c = C()
165 c = C()
166 self.assertEqual(c.c,30)
166 self.assertEqual(c.c,30)
167 c.c = 10
167 c.c = 10
168 self.assertEqual(c.c,10)
168 self.assertEqual(c.c,10)
169
169
170 def test_this_class(self):
170 def test_this_class(self):
171 class A(HasTraits):
171 class A(HasTraits):
172 t = This()
172 t = This()
173 tt = This()
173 tt = This()
174 class B(A):
174 class B(A):
175 tt = This()
175 tt = This()
176 ttt = This()
176 ttt = This()
177 self.assertEqual(A.t.this_class, A)
177 self.assertEqual(A.t.this_class, A)
178 self.assertEqual(B.t.this_class, A)
178 self.assertEqual(B.t.this_class, A)
179 self.assertEqual(B.tt.this_class, B)
179 self.assertEqual(B.tt.this_class, B)
180 self.assertEqual(B.ttt.this_class, B)
180 self.assertEqual(B.ttt.this_class, B)
181
181
182 class TestHasTraitsNotify(TestCase):
182 class TestHasTraitsNotify(TestCase):
183
183
184 def setUp(self):
184 def setUp(self):
185 self._notify1 = []
185 self._notify1 = []
186 self._notify2 = []
186 self._notify2 = []
187
187
188 def notify1(self, name, old, new):
188 def notify1(self, name, old, new):
189 self._notify1.append((name, old, new))
189 self._notify1.append((name, old, new))
190
190
191 def notify2(self, name, old, new):
191 def notify2(self, name, old, new):
192 self._notify2.append((name, old, new))
192 self._notify2.append((name, old, new))
193
193
194 def test_notify_all(self):
194 def test_notify_all(self):
195
195
196 class A(HasTraits):
196 class A(HasTraits):
197 a = Int
197 a = Int
198 b = Float
198 b = Float
199
199
200 a = A()
200 a = A()
201 a.on_trait_change(self.notify1)
201 a.on_trait_change(self.notify1)
202 a.a = 0
202 a.a = 0
203 self.assertEqual(len(self._notify1),0)
203 self.assertEqual(len(self._notify1),0)
204 a.b = 0.0
204 a.b = 0.0
205 self.assertEqual(len(self._notify1),0)
205 self.assertEqual(len(self._notify1),0)
206 a.a = 10
206 a.a = 10
207 self.assertTrue(('a',0,10) in self._notify1)
207 self.assertTrue(('a',0,10) in self._notify1)
208 a.b = 10.0
208 a.b = 10.0
209 self.assertTrue(('b',0.0,10.0) in self._notify1)
209 self.assertTrue(('b',0.0,10.0) in self._notify1)
210 self.assertRaises(TraitError,setattr,a,'a','bad string')
210 self.assertRaises(TraitError,setattr,a,'a','bad string')
211 self.assertRaises(TraitError,setattr,a,'b','bad string')
211 self.assertRaises(TraitError,setattr,a,'b','bad string')
212 self._notify1 = []
212 self._notify1 = []
213 a.on_trait_change(self.notify1,remove=True)
213 a.on_trait_change(self.notify1,remove=True)
214 a.a = 20
214 a.a = 20
215 a.b = 20.0
215 a.b = 20.0
216 self.assertEqual(len(self._notify1),0)
216 self.assertEqual(len(self._notify1),0)
217
217
218 def test_notify_one(self):
218 def test_notify_one(self):
219
219
220 class A(HasTraits):
220 class A(HasTraits):
221 a = Int
221 a = Int
222 b = Float
222 b = Float
223
223
224 a = A()
224 a = A()
225 a.on_trait_change(self.notify1, 'a')
225 a.on_trait_change(self.notify1, 'a')
226 a.a = 0
226 a.a = 0
227 self.assertEqual(len(self._notify1),0)
227 self.assertEqual(len(self._notify1),0)
228 a.a = 10
228 a.a = 10
229 self.assertTrue(('a',0,10) in self._notify1)
229 self.assertTrue(('a',0,10) in self._notify1)
230 self.assertRaises(TraitError,setattr,a,'a','bad string')
230 self.assertRaises(TraitError,setattr,a,'a','bad string')
231
231
232 def test_subclass(self):
232 def test_subclass(self):
233
233
234 class A(HasTraits):
234 class A(HasTraits):
235 a = Int
235 a = Int
236
236
237 class B(A):
237 class B(A):
238 b = Float
238 b = Float
239
239
240 b = B()
240 b = B()
241 self.assertEqual(b.a,0)
241 self.assertEqual(b.a,0)
242 self.assertEqual(b.b,0.0)
242 self.assertEqual(b.b,0.0)
243 b.a = 100
243 b.a = 100
244 b.b = 100.0
244 b.b = 100.0
245 self.assertEqual(b.a,100)
245 self.assertEqual(b.a,100)
246 self.assertEqual(b.b,100.0)
246 self.assertEqual(b.b,100.0)
247
247
248 def test_notify_subclass(self):
248 def test_notify_subclass(self):
249
249
250 class A(HasTraits):
250 class A(HasTraits):
251 a = Int
251 a = Int
252
252
253 class B(A):
253 class B(A):
254 b = Float
254 b = Float
255
255
256 b = B()
256 b = B()
257 b.on_trait_change(self.notify1, 'a')
257 b.on_trait_change(self.notify1, 'a')
258 b.on_trait_change(self.notify2, 'b')
258 b.on_trait_change(self.notify2, 'b')
259 b.a = 0
259 b.a = 0
260 b.b = 0.0
260 b.b = 0.0
261 self.assertEqual(len(self._notify1),0)
261 self.assertEqual(len(self._notify1),0)
262 self.assertEqual(len(self._notify2),0)
262 self.assertEqual(len(self._notify2),0)
263 b.a = 10
263 b.a = 10
264 b.b = 10.0
264 b.b = 10.0
265 self.assertTrue(('a',0,10) in self._notify1)
265 self.assertTrue(('a',0,10) in self._notify1)
266 self.assertTrue(('b',0.0,10.0) in self._notify2)
266 self.assertTrue(('b',0.0,10.0) in self._notify2)
267
267
268 def test_static_notify(self):
268 def test_static_notify(self):
269
269
270 class A(HasTraits):
270 class A(HasTraits):
271 a = Int
271 a = Int
272 _notify1 = []
272 _notify1 = []
273 def _a_changed(self, name, old, new):
273 def _a_changed(self, name, old, new):
274 self._notify1.append((name, old, new))
274 self._notify1.append((name, old, new))
275
275
276 a = A()
276 a = A()
277 a.a = 0
277 a.a = 0
278 # This is broken!!!
278 # This is broken!!!
279 self.assertEqual(len(a._notify1),0)
279 self.assertEqual(len(a._notify1),0)
280 a.a = 10
280 a.a = 10
281 self.assertTrue(('a',0,10) in a._notify1)
281 self.assertTrue(('a',0,10) in a._notify1)
282
282
283 class B(A):
283 class B(A):
284 b = Float
284 b = Float
285 _notify2 = []
285 _notify2 = []
286 def _b_changed(self, name, old, new):
286 def _b_changed(self, name, old, new):
287 self._notify2.append((name, old, new))
287 self._notify2.append((name, old, new))
288
288
289 b = B()
289 b = B()
290 b.a = 10
290 b.a = 10
291 b.b = 10.0
291 b.b = 10.0
292 self.assertTrue(('a',0,10) in b._notify1)
292 self.assertTrue(('a',0,10) in b._notify1)
293 self.assertTrue(('b',0.0,10.0) in b._notify2)
293 self.assertTrue(('b',0.0,10.0) in b._notify2)
294
294
295 def test_notify_args(self):
295 def test_notify_args(self):
296
296
297 def callback0():
297 def callback0():
298 self.cb = ()
298 self.cb = ()
299 def callback1(name):
299 def callback1(name):
300 self.cb = (name,)
300 self.cb = (name,)
301 def callback2(name, new):
301 def callback2(name, new):
302 self.cb = (name, new)
302 self.cb = (name, new)
303 def callback3(name, old, new):
303 def callback3(name, old, new):
304 self.cb = (name, old, new)
304 self.cb = (name, old, new)
305
305
306 class A(HasTraits):
306 class A(HasTraits):
307 a = Int
307 a = Int
308
308
309 a = A()
309 a = A()
310 a.on_trait_change(callback0, 'a')
310 a.on_trait_change(callback0, 'a')
311 a.a = 10
311 a.a = 10
312 self.assertEqual(self.cb,())
312 self.assertEqual(self.cb,())
313 a.on_trait_change(callback0, 'a', remove=True)
313 a.on_trait_change(callback0, 'a', remove=True)
314
314
315 a.on_trait_change(callback1, 'a')
315 a.on_trait_change(callback1, 'a')
316 a.a = 100
316 a.a = 100
317 self.assertEqual(self.cb,('a',))
317 self.assertEqual(self.cb,('a',))
318 a.on_trait_change(callback1, 'a', remove=True)
318 a.on_trait_change(callback1, 'a', remove=True)
319
319
320 a.on_trait_change(callback2, 'a')
320 a.on_trait_change(callback2, 'a')
321 a.a = 1000
321 a.a = 1000
322 self.assertEqual(self.cb,('a',1000))
322 self.assertEqual(self.cb,('a',1000))
323 a.on_trait_change(callback2, 'a', remove=True)
323 a.on_trait_change(callback2, 'a', remove=True)
324
324
325 a.on_trait_change(callback3, 'a')
325 a.on_trait_change(callback3, 'a')
326 a.a = 10000
326 a.a = 10000
327 self.assertEqual(self.cb,('a',1000,10000))
327 self.assertEqual(self.cb,('a',1000,10000))
328 a.on_trait_change(callback3, 'a', remove=True)
328 a.on_trait_change(callback3, 'a', remove=True)
329
329
330 self.assertEqual(len(a._trait_notifiers['a']),0)
330 self.assertEqual(len(a._trait_notifiers['a']),0)
331
331
332 def test_notify_only_once(self):
332 def test_notify_only_once(self):
333
333
334 class A(HasTraits):
334 class A(HasTraits):
335 listen_to = ['a']
335 listen_to = ['a']
336
336
337 a = Int(0)
337 a = Int(0)
338 b = 0
338 b = 0
339
339
340 def __init__(self, **kwargs):
340 def __init__(self, **kwargs):
341 super(A, self).__init__(**kwargs)
341 super(A, self).__init__(**kwargs)
342 self.on_trait_change(self.listener1, ['a'])
342 self.on_trait_change(self.listener1, ['a'])
343
343
344 def listener1(self, name, old, new):
344 def listener1(self, name, old, new):
345 self.b += 1
345 self.b += 1
346
346
347 class B(A):
347 class B(A):
348
348
349 c = 0
349 c = 0
350 d = 0
350 d = 0
351
351
352 def __init__(self, **kwargs):
352 def __init__(self, **kwargs):
353 super(B, self).__init__(**kwargs)
353 super(B, self).__init__(**kwargs)
354 self.on_trait_change(self.listener2)
354 self.on_trait_change(self.listener2)
355
355
356 def listener2(self, name, old, new):
356 def listener2(self, name, old, new):
357 self.c += 1
357 self.c += 1
358
358
359 def _a_changed(self, name, old, new):
359 def _a_changed(self, name, old, new):
360 self.d += 1
360 self.d += 1
361
361
362 b = B()
362 b = B()
363 b.a += 1
363 b.a += 1
364 self.assertEqual(b.b, b.c)
364 self.assertEqual(b.b, b.c)
365 self.assertEqual(b.b, b.d)
365 self.assertEqual(b.b, b.d)
366 b.a += 1
366 b.a += 1
367 self.assertEqual(b.b, b.c)
367 self.assertEqual(b.b, b.c)
368 self.assertEqual(b.b, b.d)
368 self.assertEqual(b.b, b.d)
369
369
370
370
371 class TestHasTraits(TestCase):
371 class TestHasTraits(TestCase):
372
372
373 def test_trait_names(self):
373 def test_trait_names(self):
374 class A(HasTraits):
374 class A(HasTraits):
375 i = Int
375 i = Int
376 f = Float
376 f = Float
377 a = A()
377 a = A()
378 self.assertEqual(sorted(a.trait_names()),['f','i'])
378 self.assertEqual(sorted(a.trait_names()),['f','i'])
379 self.assertEqual(sorted(A.class_trait_names()),['f','i'])
379 self.assertEqual(sorted(A.class_trait_names()),['f','i'])
380
380
381 def test_trait_metadata(self):
381 def test_trait_metadata(self):
382 class A(HasTraits):
382 class A(HasTraits):
383 i = Int(config_key='MY_VALUE')
383 i = Int(config_key='MY_VALUE')
384 a = A()
384 a = A()
385 self.assertEqual(a.trait_metadata('i','config_key'), 'MY_VALUE')
385 self.assertEqual(a.trait_metadata('i','config_key'), 'MY_VALUE')
386
386
387 def test_trait_metadata_default(self):
387 def test_trait_metadata_default(self):
388 class A(HasTraits):
388 class A(HasTraits):
389 i = Int()
389 i = Int()
390 a = A()
390 a = A()
391 self.assertEqual(a.trait_metadata('i', 'config_key'), None)
391 self.assertEqual(a.trait_metadata('i', 'config_key'), None)
392 self.assertEqual(a.trait_metadata('i', 'config_key', 'default'), 'default')
392 self.assertEqual(a.trait_metadata('i', 'config_key', 'default'), 'default')
393
393
394 def test_traits(self):
394 def test_traits(self):
395 class A(HasTraits):
395 class A(HasTraits):
396 i = Int
396 i = Int
397 f = Float
397 f = Float
398 a = A()
398 a = A()
399 self.assertEqual(a.traits(), dict(i=A.i, f=A.f))
399 self.assertEqual(a.traits(), dict(i=A.i, f=A.f))
400 self.assertEqual(A.class_traits(), dict(i=A.i, f=A.f))
400 self.assertEqual(A.class_traits(), dict(i=A.i, f=A.f))
401
401
402 def test_traits_metadata(self):
402 def test_traits_metadata(self):
403 class A(HasTraits):
403 class A(HasTraits):
404 i = Int(config_key='VALUE1', other_thing='VALUE2')
404 i = Int(config_key='VALUE1', other_thing='VALUE2')
405 f = Float(config_key='VALUE3', other_thing='VALUE2')
405 f = Float(config_key='VALUE3', other_thing='VALUE2')
406 j = Int(0)
406 j = Int(0)
407 a = A()
407 a = A()
408 self.assertEqual(a.traits(), dict(i=A.i, f=A.f, j=A.j))
408 self.assertEqual(a.traits(), dict(i=A.i, f=A.f, j=A.j))
409 traits = a.traits(config_key='VALUE1', other_thing='VALUE2')
409 traits = a.traits(config_key='VALUE1', other_thing='VALUE2')
410 self.assertEqual(traits, dict(i=A.i))
410 self.assertEqual(traits, dict(i=A.i))
411
411
412 # This passes, but it shouldn't because I am replicating a bug in
412 # This passes, but it shouldn't because I am replicating a bug in
413 # traits.
413 # traits.
414 traits = a.traits(config_key=lambda v: True)
414 traits = a.traits(config_key=lambda v: True)
415 self.assertEqual(traits, dict(i=A.i, f=A.f, j=A.j))
415 self.assertEqual(traits, dict(i=A.i, f=A.f, j=A.j))
416
416
417 def test_init(self):
417 def test_init(self):
418 class A(HasTraits):
418 class A(HasTraits):
419 i = Int()
419 i = Int()
420 x = Float()
420 x = Float()
421 a = A(i=1, x=10.0)
421 a = A(i=1, x=10.0)
422 self.assertEqual(a.i, 1)
422 self.assertEqual(a.i, 1)
423 self.assertEqual(a.x, 10.0)
423 self.assertEqual(a.x, 10.0)
424
424
425 def test_positional_args(self):
425 def test_positional_args(self):
426 class A(HasTraits):
426 class A(HasTraits):
427 i = Int(0)
427 i = Int(0)
428 def __init__(self, i):
428 def __init__(self, i):
429 super(A, self).__init__()
429 super(A, self).__init__()
430 self.i = i
430 self.i = i
431
431
432 a = A(5)
432 a = A(5)
433 self.assertEqual(a.i, 5)
433 self.assertEqual(a.i, 5)
434 # should raise TypeError if no positional arg given
434 # should raise TypeError if no positional arg given
435 self.assertRaises(TypeError, A)
435 self.assertRaises(TypeError, A)
436
436
437 #-----------------------------------------------------------------------------
437 #-----------------------------------------------------------------------------
438 # Tests for specific trait types
438 # Tests for specific trait types
439 #-----------------------------------------------------------------------------
439 #-----------------------------------------------------------------------------
440
440
441
441
442 class TestType(TestCase):
442 class TestType(TestCase):
443
443
444 def test_default(self):
444 def test_default(self):
445
445
446 class B(object): pass
446 class B(object): pass
447 class A(HasTraits):
447 class A(HasTraits):
448 klass = Type(allow_none=True)
448 klass = Type(allow_none=True)
449
449
450 a = A()
450 a = A()
451 self.assertEqual(a.klass, None)
451 self.assertEqual(a.klass, None)
452
452
453 a.klass = B
453 a.klass = B
454 self.assertEqual(a.klass, B)
454 self.assertEqual(a.klass, B)
455 self.assertRaises(TraitError, setattr, a, 'klass', 10)
455 self.assertRaises(TraitError, setattr, a, 'klass', 10)
456
456
457 def test_value(self):
457 def test_value(self):
458
458
459 class B(object): pass
459 class B(object): pass
460 class C(object): pass
460 class C(object): pass
461 class A(HasTraits):
461 class A(HasTraits):
462 klass = Type(B)
462 klass = Type(B)
463
463
464 a = A()
464 a = A()
465 self.assertEqual(a.klass, B)
465 self.assertEqual(a.klass, B)
466 self.assertRaises(TraitError, setattr, a, 'klass', C)
466 self.assertRaises(TraitError, setattr, a, 'klass', C)
467 self.assertRaises(TraitError, setattr, a, 'klass', object)
467 self.assertRaises(TraitError, setattr, a, 'klass', object)
468 a.klass = B
468 a.klass = B
469
469
470 def test_allow_none(self):
470 def test_allow_none(self):
471
471
472 class B(object): pass
472 class B(object): pass
473 class C(B): pass
473 class C(B): pass
474 class A(HasTraits):
474 class A(HasTraits):
475 klass = Type(B)
475 klass = Type(B)
476
476
477 a = A()
477 a = A()
478 self.assertEqual(a.klass, B)
478 self.assertEqual(a.klass, B)
479 self.assertRaises(TraitError, setattr, a, 'klass', None)
479 self.assertRaises(TraitError, setattr, a, 'klass', None)
480 a.klass = C
480 a.klass = C
481 self.assertEqual(a.klass, C)
481 self.assertEqual(a.klass, C)
482
482
483 def test_validate_klass(self):
483 def test_validate_klass(self):
484
484
485 class A(HasTraits):
485 class A(HasTraits):
486 klass = Type('no strings allowed')
486 klass = Type('no strings allowed')
487
487
488 self.assertRaises(ImportError, A)
488 self.assertRaises(ImportError, A)
489
489
490 class A(HasTraits):
490 class A(HasTraits):
491 klass = Type('rub.adub.Duck')
491 klass = Type('rub.adub.Duck')
492
492
493 self.assertRaises(ImportError, A)
493 self.assertRaises(ImportError, A)
494
494
495 def test_validate_default(self):
495 def test_validate_default(self):
496
496
497 class B(object): pass
497 class B(object): pass
498 class A(HasTraits):
498 class A(HasTraits):
499 klass = Type('bad default', B)
499 klass = Type('bad default', B)
500
500
501 self.assertRaises(ImportError, A)
501 self.assertRaises(ImportError, A)
502
502
503 class C(HasTraits):
503 class C(HasTraits):
504 klass = Type(None, B)
504 klass = Type(None, B)
505
505
506 self.assertRaises(TraitError, C)
506 self.assertRaises(TraitError, C)
507
507
508 def test_str_klass(self):
508 def test_str_klass(self):
509
509
510 class A(HasTraits):
510 class A(HasTraits):
511 klass = Type('IPython.utils.ipstruct.Struct')
511 klass = Type('IPython.utils.ipstruct.Struct')
512
512
513 from IPython.utils.ipstruct import Struct
513 from IPython.utils.ipstruct import Struct
514 a = A()
514 a = A()
515 a.klass = Struct
515 a.klass = Struct
516 self.assertEqual(a.klass, Struct)
516 self.assertEqual(a.klass, Struct)
517
517
518 self.assertRaises(TraitError, setattr, a, 'klass', 10)
518 self.assertRaises(TraitError, setattr, a, 'klass', 10)
519
519
520 def test_set_str_klass(self):
520 def test_set_str_klass(self):
521
521
522 class A(HasTraits):
522 class A(HasTraits):
523 klass = Type()
523 klass = Type()
524
524
525 a = A(klass='IPython.utils.ipstruct.Struct')
525 a = A(klass='IPython.utils.ipstruct.Struct')
526 from IPython.utils.ipstruct import Struct
526 from IPython.utils.ipstruct import Struct
527 self.assertEqual(a.klass, Struct)
527 self.assertEqual(a.klass, Struct)
528
528
529 class TestInstance(TestCase):
529 class TestInstance(TestCase):
530
530
531 def test_basic(self):
531 def test_basic(self):
532 class Foo(object): pass
532 class Foo(object): pass
533 class Bar(Foo): pass
533 class Bar(Foo): pass
534 class Bah(object): pass
534 class Bah(object): pass
535
535
536 class A(HasTraits):
536 class A(HasTraits):
537 inst = Instance(Foo, allow_none=True)
537 inst = Instance(Foo, allow_none=True)
538
538
539 a = A()
539 a = A()
540 self.assertTrue(a.inst is None)
540 self.assertTrue(a.inst is None)
541 a.inst = Foo()
541 a.inst = Foo()
542 self.assertTrue(isinstance(a.inst, Foo))
542 self.assertTrue(isinstance(a.inst, Foo))
543 a.inst = Bar()
543 a.inst = Bar()
544 self.assertTrue(isinstance(a.inst, Foo))
544 self.assertTrue(isinstance(a.inst, Foo))
545 self.assertRaises(TraitError, setattr, a, 'inst', Foo)
545 self.assertRaises(TraitError, setattr, a, 'inst', Foo)
546 self.assertRaises(TraitError, setattr, a, 'inst', Bar)
546 self.assertRaises(TraitError, setattr, a, 'inst', Bar)
547 self.assertRaises(TraitError, setattr, a, 'inst', Bah())
547 self.assertRaises(TraitError, setattr, a, 'inst', Bah())
548
548
549 def test_default_klass(self):
549 def test_default_klass(self):
550 class Foo(object): pass
550 class Foo(object): pass
551 class Bar(Foo): pass
551 class Bar(Foo): pass
552 class Bah(object): pass
552 class Bah(object): pass
553
553
554 class FooInstance(Instance):
554 class FooInstance(Instance):
555 klass = Foo
555 klass = Foo
556
556
557 class A(HasTraits):
557 class A(HasTraits):
558 inst = FooInstance(allow_none=True)
558 inst = FooInstance(allow_none=True)
559
559
560 a = A()
560 a = A()
561 self.assertTrue(a.inst is None)
561 self.assertTrue(a.inst is None)
562 a.inst = Foo()
562 a.inst = Foo()
563 self.assertTrue(isinstance(a.inst, Foo))
563 self.assertTrue(isinstance(a.inst, Foo))
564 a.inst = Bar()
564 a.inst = Bar()
565 self.assertTrue(isinstance(a.inst, Foo))
565 self.assertTrue(isinstance(a.inst, Foo))
566 self.assertRaises(TraitError, setattr, a, 'inst', Foo)
566 self.assertRaises(TraitError, setattr, a, 'inst', Foo)
567 self.assertRaises(TraitError, setattr, a, 'inst', Bar)
567 self.assertRaises(TraitError, setattr, a, 'inst', Bar)
568 self.assertRaises(TraitError, setattr, a, 'inst', Bah())
568 self.assertRaises(TraitError, setattr, a, 'inst', Bah())
569
569
570 def test_unique_default_value(self):
570 def test_unique_default_value(self):
571 class Foo(object): pass
571 class Foo(object): pass
572 class A(HasTraits):
572 class A(HasTraits):
573 inst = Instance(Foo,(),{})
573 inst = Instance(Foo,(),{})
574
574
575 a = A()
575 a = A()
576 b = A()
576 b = A()
577 self.assertTrue(a.inst is not b.inst)
577 self.assertTrue(a.inst is not b.inst)
578
578
579 def test_args_kw(self):
579 def test_args_kw(self):
580 class Foo(object):
580 class Foo(object):
581 def __init__(self, c): self.c = c
581 def __init__(self, c): self.c = c
582 class Bar(object): pass
582 class Bar(object): pass
583 class Bah(object):
583 class Bah(object):
584 def __init__(self, c, d):
584 def __init__(self, c, d):
585 self.c = c; self.d = d
585 self.c = c; self.d = d
586
586
587 class A(HasTraits):
587 class A(HasTraits):
588 inst = Instance(Foo, (10,))
588 inst = Instance(Foo, (10,))
589 a = A()
589 a = A()
590 self.assertEqual(a.inst.c, 10)
590 self.assertEqual(a.inst.c, 10)
591
591
592 class B(HasTraits):
592 class B(HasTraits):
593 inst = Instance(Bah, args=(10,), kw=dict(d=20))
593 inst = Instance(Bah, args=(10,), kw=dict(d=20))
594 b = B()
594 b = B()
595 self.assertEqual(b.inst.c, 10)
595 self.assertEqual(b.inst.c, 10)
596 self.assertEqual(b.inst.d, 20)
596 self.assertEqual(b.inst.d, 20)
597
597
598 class C(HasTraits):
598 class C(HasTraits):
599 inst = Instance(Foo, allow_none=True)
599 inst = Instance(Foo, allow_none=True)
600 c = C()
600 c = C()
601 self.assertTrue(c.inst is None)
601 self.assertTrue(c.inst is None)
602
602
603 def test_bad_default(self):
603 def test_bad_default(self):
604 class Foo(object): pass
604 class Foo(object): pass
605
605
606 class A(HasTraits):
606 class A(HasTraits):
607 inst = Instance(Foo)
607 inst = Instance(Foo)
608
608
609 self.assertRaises(TraitError, A)
609 self.assertRaises(TraitError, A)
610
610
611 def test_instance(self):
611 def test_instance(self):
612 class Foo(object): pass
612 class Foo(object): pass
613
613
614 def inner():
614 def inner():
615 class A(HasTraits):
615 class A(HasTraits):
616 inst = Instance(Foo())
616 inst = Instance(Foo())
617
617
618 self.assertRaises(TraitError, inner)
618 self.assertRaises(TraitError, inner)
619
619
620
620
621 class TestThis(TestCase):
621 class TestThis(TestCase):
622
622
623 def test_this_class(self):
623 def test_this_class(self):
624 class Foo(HasTraits):
624 class Foo(HasTraits):
625 this = This
625 this = This
626
626
627 f = Foo()
627 f = Foo()
628 self.assertEqual(f.this, None)
628 self.assertEqual(f.this, None)
629 g = Foo()
629 g = Foo()
630 f.this = g
630 f.this = g
631 self.assertEqual(f.this, g)
631 self.assertEqual(f.this, g)
632 self.assertRaises(TraitError, setattr, f, 'this', 10)
632 self.assertRaises(TraitError, setattr, f, 'this', 10)
633
633
634 def test_this_inst(self):
634 def test_this_inst(self):
635 class Foo(HasTraits):
635 class Foo(HasTraits):
636 this = This()
636 this = This()
637
637
638 f = Foo()
638 f = Foo()
639 f.this = Foo()
639 f.this = Foo()
640 self.assertTrue(isinstance(f.this, Foo))
640 self.assertTrue(isinstance(f.this, Foo))
641
641
642 def test_subclass(self):
642 def test_subclass(self):
643 class Foo(HasTraits):
643 class Foo(HasTraits):
644 t = This()
644 t = This()
645 class Bar(Foo):
645 class Bar(Foo):
646 pass
646 pass
647 f = Foo()
647 f = Foo()
648 b = Bar()
648 b = Bar()
649 f.t = b
649 f.t = b
650 b.t = f
650 b.t = f
651 self.assertEqual(f.t, b)
651 self.assertEqual(f.t, b)
652 self.assertEqual(b.t, f)
652 self.assertEqual(b.t, f)
653
653
654 def test_subclass_override(self):
654 def test_subclass_override(self):
655 class Foo(HasTraits):
655 class Foo(HasTraits):
656 t = This()
656 t = This()
657 class Bar(Foo):
657 class Bar(Foo):
658 t = This()
658 t = This()
659 f = Foo()
659 f = Foo()
660 b = Bar()
660 b = Bar()
661 f.t = b
661 f.t = b
662 self.assertEqual(f.t, b)
662 self.assertEqual(f.t, b)
663 self.assertRaises(TraitError, setattr, b, 't', f)
663 self.assertRaises(TraitError, setattr, b, 't', f)
664
664
665 def test_this_in_container(self):
665 def test_this_in_container(self):
666
666
667 class Tree(HasTraits):
667 class Tree(HasTraits):
668 value = Unicode()
668 value = Unicode()
669 leaves = List(This())
669 leaves = List(This())
670
670
671 tree = Tree(
671 tree = Tree(
672 value='foo',
672 value='foo',
673 leaves=[Tree('bar'), Tree('buzz')]
673 leaves=[Tree('bar'), Tree('buzz')]
674 )
674 )
675
675
676 with self.assertRaises(TraitError):
676 with self.assertRaises(TraitError):
677 tree.leaves = [1, 2]
677 tree.leaves = [1, 2]
678
678
679 class TraitTestBase(TestCase):
679 class TraitTestBase(TestCase):
680 """A best testing class for basic trait types."""
680 """A best testing class for basic trait types."""
681
681
682 def assign(self, value):
682 def assign(self, value):
683 self.obj.value = value
683 self.obj.value = value
684
684
685 def coerce(self, value):
685 def coerce(self, value):
686 return value
686 return value
687
687
688 def test_good_values(self):
688 def test_good_values(self):
689 if hasattr(self, '_good_values'):
689 if hasattr(self, '_good_values'):
690 for value in self._good_values:
690 for value in self._good_values:
691 self.assign(value)
691 self.assign(value)
692 self.assertEqual(self.obj.value, self.coerce(value))
692 self.assertEqual(self.obj.value, self.coerce(value))
693
693
694 def test_bad_values(self):
694 def test_bad_values(self):
695 if hasattr(self, '_bad_values'):
695 if hasattr(self, '_bad_values'):
696 for value in self._bad_values:
696 for value in self._bad_values:
697 try:
697 try:
698 self.assertRaises(TraitError, self.assign, value)
698 self.assertRaises(TraitError, self.assign, value)
699 except AssertionError:
699 except AssertionError:
700 assert False, value
700 assert False, value
701
701
702 def test_default_value(self):
702 def test_default_value(self):
703 if hasattr(self, '_default_value'):
703 if hasattr(self, '_default_value'):
704 self.assertEqual(self._default_value, self.obj.value)
704 self.assertEqual(self._default_value, self.obj.value)
705
705
706 def test_allow_none(self):
706 def test_allow_none(self):
707 if (hasattr(self, '_bad_values') and hasattr(self, '_good_values') and
707 if (hasattr(self, '_bad_values') and hasattr(self, '_good_values') and
708 None in self._bad_values):
708 None in self._bad_values):
709 trait=self.obj.traits()['value']
709 trait=self.obj.traits()['value']
710 try:
710 try:
711 trait.allow_none = True
711 trait.allow_none = True
712 self._bad_values.remove(None)
712 self._bad_values.remove(None)
713 #skip coerce. Allow None casts None to None.
713 #skip coerce. Allow None casts None to None.
714 self.assign(None)
714 self.assign(None)
715 self.assertEqual(self.obj.value,None)
715 self.assertEqual(self.obj.value,None)
716 self.test_good_values()
716 self.test_good_values()
717 self.test_bad_values()
717 self.test_bad_values()
718 finally:
718 finally:
719 #tear down
719 #tear down
720 trait.allow_none = False
720 trait.allow_none = False
721 self._bad_values.append(None)
721 self._bad_values.append(None)
722
722
723 def tearDown(self):
723 def tearDown(self):
724 # restore default value after tests, if set
724 # restore default value after tests, if set
725 if hasattr(self, '_default_value'):
725 if hasattr(self, '_default_value'):
726 self.obj.value = self._default_value
726 self.obj.value = self._default_value
727
727
728
728
729 class AnyTrait(HasTraits):
729 class AnyTrait(HasTraits):
730
730
731 value = Any
731 value = Any
732
732
733 class AnyTraitTest(TraitTestBase):
733 class AnyTraitTest(TraitTestBase):
734
734
735 obj = AnyTrait()
735 obj = AnyTrait()
736
736
737 _default_value = None
737 _default_value = None
738 _good_values = [10.0, 'ten', u'ten', [10], {'ten': 10},(10,), None, 1j]
738 _good_values = [10.0, 'ten', u'ten', [10], {'ten': 10},(10,), None, 1j]
739 _bad_values = []
739 _bad_values = []
740
740
741 class UnionTrait(HasTraits):
741 class UnionTrait(HasTraits):
742
742
743 value = Union([Type(), Bool()])
743 value = Union([Type(), Bool()])
744
744
745 class UnionTraitTest(TraitTestBase):
745 class UnionTraitTest(TraitTestBase):
746
746
747 obj = UnionTrait(value='IPython.utils.ipstruct.Struct')
747 obj = UnionTrait(value='IPython.utils.ipstruct.Struct')
748 _good_values = [int, float, True]
748 _good_values = [int, float, True]
749 _bad_values = [[], (0,), 1j]
749 _bad_values = [[], (0,), 1j]
750
750
751 class OrTrait(HasTraits):
751 class OrTrait(HasTraits):
752
752
753 value = Bool() | Unicode()
753 value = Bool() | Unicode()
754
754
755 class OrTraitTest(TraitTestBase):
755 class OrTraitTest(TraitTestBase):
756
756
757 obj = OrTrait()
757 obj = OrTrait()
758 _good_values = [True, False, 'ten']
758 _good_values = [True, False, 'ten']
759 _bad_values = [[], (0,), 1j]
759 _bad_values = [[], (0,), 1j]
760
760
761 class IntTrait(HasTraits):
761 class IntTrait(HasTraits):
762
762
763 value = Int(99)
763 value = Int(99)
764
764
765 class TestInt(TraitTestBase):
765 class TestInt(TraitTestBase):
766
766
767 obj = IntTrait()
767 obj = IntTrait()
768 _default_value = 99
768 _default_value = 99
769 _good_values = [10, -10]
769 _good_values = [10, -10]
770 _bad_values = ['ten', u'ten', [10], {'ten': 10},(10,), None, 1j,
770 _bad_values = ['ten', u'ten', [10], {'ten': 10},(10,), None, 1j,
771 10.1, -10.1, '10L', '-10L', '10.1', '-10.1', u'10L',
771 10.1, -10.1, '10L', '-10L', '10.1', '-10.1', u'10L',
772 u'-10L', u'10.1', u'-10.1', '10', '-10', u'10', u'-10']
772 u'-10L', u'10.1', u'-10.1', '10', '-10', u'10', u'-10']
773 if not py3compat.PY3:
773 if not py3compat.PY3:
774 _bad_values.extend([long(10), long(-10), 10*sys.maxint, -10*sys.maxint])
774 _bad_values.extend([long(10), long(-10), 10*sys.maxint, -10*sys.maxint])
775
775
776
776
777 class LongTrait(HasTraits):
777 class LongTrait(HasTraits):
778
778
779 value = Long(99 if py3compat.PY3 else long(99))
779 value = Long(99 if py3compat.PY3 else long(99))
780
780
781 class TestLong(TraitTestBase):
781 class TestLong(TraitTestBase):
782
782
783 obj = LongTrait()
783 obj = LongTrait()
784
784
785 _default_value = 99 if py3compat.PY3 else long(99)
785 _default_value = 99 if py3compat.PY3 else long(99)
786 _good_values = [10, -10]
786 _good_values = [10, -10]
787 _bad_values = ['ten', u'ten', [10], {'ten': 10},(10,),
787 _bad_values = ['ten', u'ten', [10], {'ten': 10},(10,),
788 None, 1j, 10.1, -10.1, '10', '-10', '10L', '-10L', '10.1',
788 None, 1j, 10.1, -10.1, '10', '-10', '10L', '-10L', '10.1',
789 '-10.1', u'10', u'-10', u'10L', u'-10L', u'10.1',
789 '-10.1', u'10', u'-10', u'10L', u'-10L', u'10.1',
790 u'-10.1']
790 u'-10.1']
791 if not py3compat.PY3:
791 if not py3compat.PY3:
792 # maxint undefined on py3, because int == long
792 # maxint undefined on py3, because int == long
793 _good_values.extend([long(10), long(-10), 10*sys.maxint, -10*sys.maxint])
793 _good_values.extend([long(10), long(-10), 10*sys.maxint, -10*sys.maxint])
794 _bad_values.extend([[long(10)], (long(10),)])
794 _bad_values.extend([[long(10)], (long(10),)])
795
795
796 @skipif(py3compat.PY3, "not relevant on py3")
796 @skipif(py3compat.PY3, "not relevant on py3")
797 def test_cast_small(self):
797 def test_cast_small(self):
798 """Long casts ints to long"""
798 """Long casts ints to long"""
799 self.obj.value = 10
799 self.obj.value = 10
800 self.assertEqual(type(self.obj.value), long)
800 self.assertEqual(type(self.obj.value), long)
801
801
802
802
803 class IntegerTrait(HasTraits):
803 class IntegerTrait(HasTraits):
804 value = Integer(1)
804 value = Integer(1)
805
805
806 class TestInteger(TestLong):
806 class TestInteger(TestLong):
807 obj = IntegerTrait()
807 obj = IntegerTrait()
808 _default_value = 1
808 _default_value = 1
809
809
810 def coerce(self, n):
810 def coerce(self, n):
811 return int(n)
811 return int(n)
812
812
813 @skipif(py3compat.PY3, "not relevant on py3")
813 @skipif(py3compat.PY3, "not relevant on py3")
814 def test_cast_small(self):
814 def test_cast_small(self):
815 """Integer casts small longs to int"""
815 """Integer casts small longs to int"""
816 if py3compat.PY3:
816 if py3compat.PY3:
817 raise SkipTest("not relevant on py3")
817 raise SkipTest("not relevant on py3")
818
818
819 self.obj.value = long(100)
819 self.obj.value = long(100)
820 self.assertEqual(type(self.obj.value), int)
820 self.assertEqual(type(self.obj.value), int)
821
821
822
822
823 class FloatTrait(HasTraits):
823 class FloatTrait(HasTraits):
824
824
825 value = Float(99.0)
825 value = Float(99.0)
826
826
827 class TestFloat(TraitTestBase):
827 class TestFloat(TraitTestBase):
828
828
829 obj = FloatTrait()
829 obj = FloatTrait()
830
830
831 _default_value = 99.0
831 _default_value = 99.0
832 _good_values = [10, -10, 10.1, -10.1]
832 _good_values = [10, -10, 10.1, -10.1]
833 _bad_values = ['ten', u'ten', [10], {'ten': 10},(10,), None,
833 _bad_values = ['ten', u'ten', [10], {'ten': 10},(10,), None,
834 1j, '10', '-10', '10L', '-10L', '10.1', '-10.1', u'10',
834 1j, '10', '-10', '10L', '-10L', '10.1', '-10.1', u'10',
835 u'-10', u'10L', u'-10L', u'10.1', u'-10.1']
835 u'-10', u'10L', u'-10L', u'10.1', u'-10.1']
836 if not py3compat.PY3:
836 if not py3compat.PY3:
837 _bad_values.extend([long(10), long(-10)])
837 _bad_values.extend([long(10), long(-10)])
838
838
839
839
840 class ComplexTrait(HasTraits):
840 class ComplexTrait(HasTraits):
841
841
842 value = Complex(99.0-99.0j)
842 value = Complex(99.0-99.0j)
843
843
844 class TestComplex(TraitTestBase):
844 class TestComplex(TraitTestBase):
845
845
846 obj = ComplexTrait()
846 obj = ComplexTrait()
847
847
848 _default_value = 99.0-99.0j
848 _default_value = 99.0-99.0j
849 _good_values = [10, -10, 10.1, -10.1, 10j, 10+10j, 10-10j,
849 _good_values = [10, -10, 10.1, -10.1, 10j, 10+10j, 10-10j,
850 10.1j, 10.1+10.1j, 10.1-10.1j]
850 10.1j, 10.1+10.1j, 10.1-10.1j]
851 _bad_values = [u'10L', u'-10L', 'ten', [10], {'ten': 10},(10,), None]
851 _bad_values = [u'10L', u'-10L', 'ten', [10], {'ten': 10},(10,), None]
852 if not py3compat.PY3:
852 if not py3compat.PY3:
853 _bad_values.extend([long(10), long(-10)])
853 _bad_values.extend([long(10), long(-10)])
854
854
855
855
856 class BytesTrait(HasTraits):
856 class BytesTrait(HasTraits):
857
857
858 value = Bytes(b'string')
858 value = Bytes(b'string')
859
859
860 class TestBytes(TraitTestBase):
860 class TestBytes(TraitTestBase):
861
861
862 obj = BytesTrait()
862 obj = BytesTrait()
863
863
864 _default_value = b'string'
864 _default_value = b'string'
865 _good_values = [b'10', b'-10', b'10L',
865 _good_values = [b'10', b'-10', b'10L',
866 b'-10L', b'10.1', b'-10.1', b'string']
866 b'-10L', b'10.1', b'-10.1', b'string']
867 _bad_values = [10, -10, 10.1, -10.1, 1j, [10],
867 _bad_values = [10, -10, 10.1, -10.1, 1j, [10],
868 ['ten'],{'ten': 10},(10,), None, u'string']
868 ['ten'],{'ten': 10},(10,), None, u'string']
869 if not py3compat.PY3:
869 if not py3compat.PY3:
870 _bad_values.extend([long(10), long(-10)])
870 _bad_values.extend([long(10), long(-10)])
871
871
872
872
873 class UnicodeTrait(HasTraits):
873 class UnicodeTrait(HasTraits):
874
874
875 value = Unicode(u'unicode')
875 value = Unicode(u'unicode')
876
876
877 class TestUnicode(TraitTestBase):
877 class TestUnicode(TraitTestBase):
878
878
879 obj = UnicodeTrait()
879 obj = UnicodeTrait()
880
880
881 _default_value = u'unicode'
881 _default_value = u'unicode'
882 _good_values = ['10', '-10', '10L', '-10L', '10.1',
882 _good_values = ['10', '-10', '10L', '-10L', '10.1',
883 '-10.1', '', u'', 'string', u'string', u"€"]
883 '-10.1', '', u'', 'string', u'string', u"€"]
884 _bad_values = [10, -10, 10.1, -10.1, 1j,
884 _bad_values = [10, -10, 10.1, -10.1, 1j,
885 [10], ['ten'], [u'ten'], {'ten': 10},(10,), None]
885 [10], ['ten'], [u'ten'], {'ten': 10},(10,), None]
886 if not py3compat.PY3:
886 if not py3compat.PY3:
887 _bad_values.extend([long(10), long(-10)])
887 _bad_values.extend([long(10), long(-10)])
888
888
889
889
890 class ObjectNameTrait(HasTraits):
890 class ObjectNameTrait(HasTraits):
891 value = ObjectName("abc")
891 value = ObjectName("abc")
892
892
893 class TestObjectName(TraitTestBase):
893 class TestObjectName(TraitTestBase):
894 obj = ObjectNameTrait()
894 obj = ObjectNameTrait()
895
895
896 _default_value = "abc"
896 _default_value = "abc"
897 _good_values = ["a", "gh", "g9", "g_", "_G", u"a345_"]
897 _good_values = ["a", "gh", "g9", "g_", "_G", u"a345_"]
898 _bad_values = [1, "", u"€", "9g", "!", "#abc", "aj@", "a.b", "a()", "a[0]",
898 _bad_values = [1, "", u"€", "9g", "!", "#abc", "aj@", "a.b", "a()", "a[0]",
899 None, object(), object]
899 None, object(), object]
900 if sys.version_info[0] < 3:
900 if sys.version_info[0] < 3:
901 _bad_values.append(u"ΓΎ")
901 _bad_values.append(u"ΓΎ")
902 else:
902 else:
903 _good_values.append(u"ΓΎ") # ΓΎ=1 is valid in Python 3 (PEP 3131).
903 _good_values.append(u"ΓΎ") # ΓΎ=1 is valid in Python 3 (PEP 3131).
904
904
905
905
906 class DottedObjectNameTrait(HasTraits):
906 class DottedObjectNameTrait(HasTraits):
907 value = DottedObjectName("a.b")
907 value = DottedObjectName("a.b")
908
908
909 class TestDottedObjectName(TraitTestBase):
909 class TestDottedObjectName(TraitTestBase):
910 obj = DottedObjectNameTrait()
910 obj = DottedObjectNameTrait()
911
911
912 _default_value = "a.b"
912 _default_value = "a.b"
913 _good_values = ["A", "y.t", "y765.__repr__", "os.path.join", u"os.path.join"]
913 _good_values = ["A", "y.t", "y765.__repr__", "os.path.join", u"os.path.join"]
914 _bad_values = [1, u"abc.€", "_.@", ".", ".abc", "abc.", ".abc.", None]
914 _bad_values = [1, u"abc.€", "_.@", ".", ".abc", "abc.", ".abc.", None]
915 if sys.version_info[0] < 3:
915 if sys.version_info[0] < 3:
916 _bad_values.append(u"t.ΓΎ")
916 _bad_values.append(u"t.ΓΎ")
917 else:
917 else:
918 _good_values.append(u"t.ΓΎ")
918 _good_values.append(u"t.ΓΎ")
919
919
920
920
921 class TCPAddressTrait(HasTraits):
921 class TCPAddressTrait(HasTraits):
922 value = TCPAddress()
922 value = TCPAddress()
923
923
924 class TestTCPAddress(TraitTestBase):
924 class TestTCPAddress(TraitTestBase):
925
925
926 obj = TCPAddressTrait()
926 obj = TCPAddressTrait()
927
927
928 _default_value = ('127.0.0.1',0)
928 _default_value = ('127.0.0.1',0)
929 _good_values = [('localhost',0),('192.168.0.1',1000),('www.google.com',80)]
929 _good_values = [('localhost',0),('192.168.0.1',1000),('www.google.com',80)]
930 _bad_values = [(0,0),('localhost',10.0),('localhost',-1), None]
930 _bad_values = [(0,0),('localhost',10.0),('localhost',-1), None]
931
931
932 class ListTrait(HasTraits):
932 class ListTrait(HasTraits):
933
933
934 value = List(Int)
934 value = List(Int)
935
935
936 class TestList(TraitTestBase):
936 class TestList(TraitTestBase):
937
937
938 obj = ListTrait()
938 obj = ListTrait()
939
939
940 _default_value = []
940 _default_value = []
941 _good_values = [[], [1], list(range(10)), (1,2)]
941 _good_values = [[], [1], list(range(10)), (1,2)]
942 _bad_values = [10, [1,'a'], 'a']
942 _bad_values = [10, [1,'a'], 'a']
943
943
944 def coerce(self, value):
944 def coerce(self, value):
945 if value is not None:
945 if value is not None:
946 value = list(value)
946 value = list(value)
947 return value
947 return value
948
948
949 class Foo(object):
949 class Foo(object):
950 pass
950 pass
951
951
952 class NoneInstanceListTrait(HasTraits):
952 class NoneInstanceListTrait(HasTraits):
953
953
954 value = List(Instance(Foo))
954 value = List(Instance(Foo))
955
955
956 class TestNoneInstanceList(TraitTestBase):
956 class TestNoneInstanceList(TraitTestBase):
957
957
958 obj = NoneInstanceListTrait()
958 obj = NoneInstanceListTrait()
959
959
960 _default_value = []
960 _default_value = []
961 _good_values = [[Foo(), Foo()], []]
961 _good_values = [[Foo(), Foo()], []]
962 _bad_values = [[None], [Foo(), None]]
962 _bad_values = [[None], [Foo(), None]]
963
963
964
964
965 class InstanceListTrait(HasTraits):
965 class InstanceListTrait(HasTraits):
966
966
967 value = List(Instance(__name__+'.Foo'))
967 value = List(Instance(__name__+'.Foo'))
968
968
969 class TestInstanceList(TraitTestBase):
969 class TestInstanceList(TraitTestBase):
970
970
971 obj = InstanceListTrait()
971 obj = InstanceListTrait()
972
972
973 def test_klass(self):
973 def test_klass(self):
974 """Test that the instance klass is properly assigned."""
974 """Test that the instance klass is properly assigned."""
975 self.assertIs(self.obj.traits()['value']._trait.klass, Foo)
975 self.assertIs(self.obj.traits()['value']._trait.klass, Foo)
976
976
977 _default_value = []
977 _default_value = []
978 _good_values = [[Foo(), Foo()], []]
978 _good_values = [[Foo(), Foo()], []]
979 _bad_values = [['1', 2,], '1', [Foo], None]
979 _bad_values = [['1', 2,], '1', [Foo], None]
980
980
981 class UnionListTrait(HasTraits):
981 class UnionListTrait(HasTraits):
982
982
983 value = List(Int() | Bool())
983 value = List(Int() | Bool())
984
984
985 class TestUnionListTrait(HasTraits):
985 class TestUnionListTrait(HasTraits):
986
986
987 obj = UnionListTrait()
987 obj = UnionListTrait()
988
988
989 _default_value = []
989 _default_value = []
990 _good_values = [[True, 1], [False, True]]
990 _good_values = [[True, 1], [False, True]]
991 _bad_values = [[1, 'True'], False]
991 _bad_values = [[1, 'True'], False]
992
992
993
993
994 class LenListTrait(HasTraits):
994 class LenListTrait(HasTraits):
995
995
996 value = List(Int, [0], minlen=1, maxlen=2)
996 value = List(Int, [0], minlen=1, maxlen=2)
997
997
998 class TestLenList(TraitTestBase):
998 class TestLenList(TraitTestBase):
999
999
1000 obj = LenListTrait()
1000 obj = LenListTrait()
1001
1001
1002 _default_value = [0]
1002 _default_value = [0]
1003 _good_values = [[1], [1,2], (1,2)]
1003 _good_values = [[1], [1,2], (1,2)]
1004 _bad_values = [10, [1,'a'], 'a', [], list(range(3))]
1004 _bad_values = [10, [1,'a'], 'a', [], list(range(3))]
1005
1005
1006 def coerce(self, value):
1006 def coerce(self, value):
1007 if value is not None:
1007 if value is not None:
1008 value = list(value)
1008 value = list(value)
1009 return value
1009 return value
1010
1010
1011 class TupleTrait(HasTraits):
1011 class TupleTrait(HasTraits):
1012
1012
1013 value = Tuple(Int(allow_none=True))
1013 value = Tuple(Int(allow_none=True))
1014
1014
1015 class TestTupleTrait(TraitTestBase):
1015 class TestTupleTrait(TraitTestBase):
1016
1016
1017 obj = TupleTrait()
1017 obj = TupleTrait()
1018
1018
1019 _default_value = None
1019 _default_value = None
1020 _good_values = [(1,), None, (0,), [1], (None,)]
1020 _good_values = [(1,), None, (0,), [1], (None,)]
1021 _bad_values = [10, (1,2), ('a'), ()]
1021 _bad_values = [10, (1,2), ('a'), ()]
1022
1022
1023 def coerce(self, value):
1023 def coerce(self, value):
1024 if value is not None:
1024 if value is not None:
1025 value = tuple(value)
1025 value = tuple(value)
1026 return value
1026 return value
1027
1027
1028 def test_invalid_args(self):
1028 def test_invalid_args(self):
1029 self.assertRaises(TypeError, Tuple, 5)
1029 self.assertRaises(TypeError, Tuple, 5)
1030 self.assertRaises(TypeError, Tuple, default_value='hello')
1030 self.assertRaises(TypeError, Tuple, default_value='hello')
1031 t = Tuple(Int, CBytes, default_value=(1,5))
1031 t = Tuple(Int, CBytes, default_value=(1,5))
1032
1032
1033 class LooseTupleTrait(HasTraits):
1033 class LooseTupleTrait(HasTraits):
1034
1034
1035 value = Tuple((1,2,3))
1035 value = Tuple((1,2,3))
1036
1036
1037 class TestLooseTupleTrait(TraitTestBase):
1037 class TestLooseTupleTrait(TraitTestBase):
1038
1038
1039 obj = LooseTupleTrait()
1039 obj = LooseTupleTrait()
1040
1040
1041 _default_value = (1,2,3)
1041 _default_value = (1,2,3)
1042 _good_values = [(1,), None, [1], (0,), tuple(range(5)), tuple('hello'), ('a',5), ()]
1042 _good_values = [(1,), None, [1], (0,), tuple(range(5)), tuple('hello'), ('a',5), ()]
1043 _bad_values = [10, 'hello', {}]
1043 _bad_values = [10, 'hello', {}]
1044
1044
1045 def coerce(self, value):
1045 def coerce(self, value):
1046 if value is not None:
1046 if value is not None:
1047 value = tuple(value)
1047 value = tuple(value)
1048 return value
1048 return value
1049
1049
1050 def test_invalid_args(self):
1050 def test_invalid_args(self):
1051 self.assertRaises(TypeError, Tuple, 5)
1051 self.assertRaises(TypeError, Tuple, 5)
1052 self.assertRaises(TypeError, Tuple, default_value='hello')
1052 self.assertRaises(TypeError, Tuple, default_value='hello')
1053 t = Tuple(Int, CBytes, default_value=(1,5))
1053 t = Tuple(Int, CBytes, default_value=(1,5))
1054
1054
1055
1055
1056 class MultiTupleTrait(HasTraits):
1056 class MultiTupleTrait(HasTraits):
1057
1057
1058 value = Tuple(Int, Bytes, default_value=[99,b'bottles'])
1058 value = Tuple(Int, Bytes, default_value=[99,b'bottles'])
1059
1059
1060 class TestMultiTuple(TraitTestBase):
1060 class TestMultiTuple(TraitTestBase):
1061
1061
1062 obj = MultiTupleTrait()
1062 obj = MultiTupleTrait()
1063
1063
1064 _default_value = (99,b'bottles')
1064 _default_value = (99,b'bottles')
1065 _good_values = [(1,b'a'), (2,b'b')]
1065 _good_values = [(1,b'a'), (2,b'b')]
1066 _bad_values = ((),10, b'a', (1,b'a',3), (b'a',1), (1, u'a'))
1066 _bad_values = ((),10, b'a', (1,b'a',3), (b'a',1), (1, u'a'))
1067
1067
1068 class CRegExpTrait(HasTraits):
1068 class CRegExpTrait(HasTraits):
1069
1069
1070 value = CRegExp(r'')
1070 value = CRegExp(r'')
1071
1071
1072 class TestCRegExp(TraitTestBase):
1072 class TestCRegExp(TraitTestBase):
1073
1073
1074 def coerce(self, value):
1074 def coerce(self, value):
1075 return re.compile(value)
1075 return re.compile(value)
1076
1076
1077 obj = CRegExpTrait()
1077 obj = CRegExpTrait()
1078
1078
1079 _default_value = re.compile(r'')
1079 _default_value = re.compile(r'')
1080 _good_values = [r'\d+', re.compile(r'\d+')]
1080 _good_values = [r'\d+', re.compile(r'\d+')]
1081 _bad_values = ['(', None, ()]
1081 _bad_values = ['(', None, ()]
1082
1082
1083 class DictTrait(HasTraits):
1083 class DictTrait(HasTraits):
1084 value = Dict()
1084 value = Dict()
1085
1085
1086 def test_dict_assignment():
1086 def test_dict_assignment():
1087 d = dict()
1087 d = dict()
1088 c = DictTrait()
1088 c = DictTrait()
1089 c.value = d
1089 c.value = d
1090 d['a'] = 5
1090 d['a'] = 5
1091 nt.assert_equal(d, c.value)
1091 nt.assert_equal(d, c.value)
1092 nt.assert_true(c.value is d)
1092 nt.assert_true(c.value is d)
1093
1093
1094 class ValidatedDictTrait(HasTraits):
1094 class ValidatedDictTrait(HasTraits):
1095
1095
1096 value = Dict(Unicode())
1096 value = Dict(Unicode())
1097
1097
1098 class TestInstanceDict(TraitTestBase):
1098 class TestInstanceDict(TraitTestBase):
1099
1099
1100 obj = ValidatedDictTrait()
1100 obj = ValidatedDictTrait()
1101
1101
1102 _default_value = {}
1102 _default_value = {}
1103 _good_values = [{'0': 'foo'}, {'1': 'bar'}]
1103 _good_values = [{'0': 'foo'}, {'1': 'bar'}]
1104 _bad_values = [{'0': 0}, {'1': 1}]
1104 _bad_values = [{'0': 0}, {'1': 1}]
1105
1105
1106
1106
1107 def test_dict_default_value():
1107 def test_dict_default_value():
1108 """Check that the `{}` default value of the Dict traitlet constructor is
1108 """Check that the `{}` default value of the Dict traitlet constructor is
1109 actually copied."""
1109 actually copied."""
1110
1110
1111 d1, d2 = Dict(), Dict()
1111 d1, d2 = Dict(), Dict()
1112 nt.assert_false(d1.get_default_value() is d2.get_default_value())
1112 nt.assert_false(d1.get_default_value() is d2.get_default_value())
1113
1113
1114
1114
1115 class TestValidationHook(TestCase):
1115 class TestValidationHook(TestCase):
1116
1116
1117 def test_parity_trait(self):
1117 def test_parity_trait(self):
1118 """Verify that the early validation hook is effective"""
1118 """Verify that the early validation hook is effective"""
1119
1119
1120 class Parity(HasTraits):
1120 class Parity(HasTraits):
1121
1121
1122 value = Int(0)
1122 value = Int(0)
1123 parity = Enum(['odd', 'even'], default_value='even')
1123 parity = Enum(['odd', 'even'], default_value='even')
1124
1124
1125 def _value_validate(self, value, trait):
1125 def _value_validate(self, value, trait):
1126 if self.parity == 'even' and value % 2:
1126 if self.parity == 'even' and value % 2:
1127 raise TraitError('Expected an even number')
1127 raise TraitError('Expected an even number')
1128 if self.parity == 'odd' and (value % 2 == 0):
1128 if self.parity == 'odd' and (value % 2 == 0):
1129 raise TraitError('Expected an odd number')
1129 raise TraitError('Expected an odd number')
1130 return value
1130 return value
1131
1131
1132 u = Parity()
1132 u = Parity()
1133 u.parity = 'odd'
1133 u.parity = 'odd'
1134 u.value = 1 # OK
1134 u.value = 1 # OK
1135 with self.assertRaises(TraitError):
1135 with self.assertRaises(TraitError):
1136 u.value = 2 # Trait Error
1136 u.value = 2 # Trait Error
1137
1137
1138 u.parity = 'even'
1138 u.parity = 'even'
1139 u.value = 2 # OK
1139 u.value = 2 # OK
1140
1140
1141
1141
1142 class TestLink(TestCase):
1142 class TestLink(TestCase):
1143
1143
1144 def test_connect_same(self):
1144 def test_connect_same(self):
1145 """Verify two traitlets of the same type can be linked together using link."""
1145 """Verify two traitlets of the same type can be linked together using link."""
1146
1146
1147 # Create two simple classes with Int traitlets.
1147 # Create two simple classes with Int traitlets.
1148 class A(HasTraits):
1148 class A(HasTraits):
1149 value = Int()
1149 value = Int()
1150 a = A(value=9)
1150 a = A(value=9)
1151 b = A(value=8)
1151 b = A(value=8)
1152
1152
1153 # Conenct the two classes.
1153 # Conenct the two classes.
1154 c = link((a, 'value'), (b, 'value'))
1154 c = link((a, 'value'), (b, 'value'))
1155
1155
1156 # Make sure the values are the same at the point of linking.
1156 # Make sure the values are the same at the point of linking.
1157 self.assertEqual(a.value, b.value)
1157 self.assertEqual(a.value, b.value)
1158
1158
1159 # Change one of the values to make sure they stay in sync.
1159 # Change one of the values to make sure they stay in sync.
1160 a.value = 5
1160 a.value = 5
1161 self.assertEqual(a.value, b.value)
1161 self.assertEqual(a.value, b.value)
1162 b.value = 6
1162 b.value = 6
1163 self.assertEqual(a.value, b.value)
1163 self.assertEqual(a.value, b.value)
1164
1164
1165 def test_link_different(self):
1165 def test_link_different(self):
1166 """Verify two traitlets of different types can be linked together using link."""
1166 """Verify two traitlets of different types can be linked together using link."""
1167
1167
1168 # Create two simple classes with Int traitlets.
1168 # Create two simple classes with Int traitlets.
1169 class A(HasTraits):
1169 class A(HasTraits):
1170 value = Int()
1170 value = Int()
1171 class B(HasTraits):
1171 class B(HasTraits):
1172 count = Int()
1172 count = Int()
1173 a = A(value=9)
1173 a = A(value=9)
1174 b = B(count=8)
1174 b = B(count=8)
1175
1175
1176 # Conenct the two classes.
1176 # Conenct the two classes.
1177 c = link((a, 'value'), (b, 'count'))
1177 c = link((a, 'value'), (b, 'count'))
1178
1178
1179 # Make sure the values are the same at the point of linking.
1179 # Make sure the values are the same at the point of linking.
1180 self.assertEqual(a.value, b.count)
1180 self.assertEqual(a.value, b.count)
1181
1181
1182 # Change one of the values to make sure they stay in sync.
1182 # Change one of the values to make sure they stay in sync.
1183 a.value = 5
1183 a.value = 5
1184 self.assertEqual(a.value, b.count)
1184 self.assertEqual(a.value, b.count)
1185 b.count = 4
1185 b.count = 4
1186 self.assertEqual(a.value, b.count)
1186 self.assertEqual(a.value, b.count)
1187
1187
1188 def test_unlink(self):
1188 def test_unlink(self):
1189 """Verify two linked traitlets can be unlinked."""
1189 """Verify two linked traitlets can be unlinked."""
1190
1190
1191 # Create two simple classes with Int traitlets.
1191 # Create two simple classes with Int traitlets.
1192 class A(HasTraits):
1192 class A(HasTraits):
1193 value = Int()
1193 value = Int()
1194 a = A(value=9)
1194 a = A(value=9)
1195 b = A(value=8)
1195 b = A(value=8)
1196
1196
1197 # Connect the two classes.
1197 # Connect the two classes.
1198 c = link((a, 'value'), (b, 'value'))
1198 c = link((a, 'value'), (b, 'value'))
1199 a.value = 4
1199 a.value = 4
1200 c.unlink()
1200 c.unlink()
1201
1201
1202 # Change one of the values to make sure they don't stay in sync.
1202 # Change one of the values to make sure they don't stay in sync.
1203 a.value = 5
1203 a.value = 5
1204 self.assertNotEqual(a.value, b.value)
1204 self.assertNotEqual(a.value, b.value)
1205
1205
1206 def test_callbacks(self):
1206 def test_callbacks(self):
1207 """Verify two linked traitlets have their callbacks called once."""
1207 """Verify two linked traitlets have their callbacks called once."""
1208
1208
1209 # Create two simple classes with Int traitlets.
1209 # Create two simple classes with Int traitlets.
1210 class A(HasTraits):
1210 class A(HasTraits):
1211 value = Int()
1211 value = Int()
1212 class B(HasTraits):
1212 class B(HasTraits):
1213 count = Int()
1213 count = Int()
1214 a = A(value=9)
1214 a = A(value=9)
1215 b = B(count=8)
1215 b = B(count=8)
1216
1216
1217 # Register callbacks that count.
1217 # Register callbacks that count.
1218 callback_count = []
1218 callback_count = []
1219 def a_callback(name, old, new):
1219 def a_callback(name, old, new):
1220 callback_count.append('a')
1220 callback_count.append('a')
1221 a.on_trait_change(a_callback, 'value')
1221 a.on_trait_change(a_callback, 'value')
1222 def b_callback(name, old, new):
1222 def b_callback(name, old, new):
1223 callback_count.append('b')
1223 callback_count.append('b')
1224 b.on_trait_change(b_callback, 'count')
1224 b.on_trait_change(b_callback, 'count')
1225
1225
1226 # Connect the two classes.
1226 # Connect the two classes.
1227 c = link((a, 'value'), (b, 'count'))
1227 c = link((a, 'value'), (b, 'count'))
1228
1228
1229 # Make sure b's count was set to a's value once.
1229 # Make sure b's count was set to a's value once.
1230 self.assertEqual(''.join(callback_count), 'b')
1230 self.assertEqual(''.join(callback_count), 'b')
1231 del callback_count[:]
1231 del callback_count[:]
1232
1232
1233 # Make sure a's value was set to b's count once.
1233 # Make sure a's value was set to b's count once.
1234 b.count = 5
1234 b.count = 5
1235 self.assertEqual(''.join(callback_count), 'ba')
1235 self.assertEqual(''.join(callback_count), 'ba')
1236 del callback_count[:]
1236 del callback_count[:]
1237
1237
1238 # Make sure b's count was set to a's value once.
1238 # Make sure b's count was set to a's value once.
1239 a.value = 4
1239 a.value = 4
1240 self.assertEqual(''.join(callback_count), 'ab')
1240 self.assertEqual(''.join(callback_count), 'ab')
1241 del callback_count[:]
1241 del callback_count[:]
1242
1242
1243 class TestDirectionalLink(TestCase):
1243 class TestDirectionalLink(TestCase):
1244 def test_connect_same(self):
1244 def test_connect_same(self):
1245 """Verify two traitlets of the same type can be linked together using directional_link."""
1245 """Verify two traitlets of the same type can be linked together using directional_link."""
1246
1246
1247 # Create two simple classes with Int traitlets.
1247 # Create two simple classes with Int traitlets.
1248 class A(HasTraits):
1248 class A(HasTraits):
1249 value = Int()
1249 value = Int()
1250 a = A(value=9)
1250 a = A(value=9)
1251 b = A(value=8)
1251 b = A(value=8)
1252
1252
1253 # Conenct the two classes.
1253 # Conenct the two classes.
1254 c = directional_link((a, 'value'), (b, 'value'))
1254 c = directional_link((a, 'value'), (b, 'value'))
1255
1255
1256 # Make sure the values are the same at the point of linking.
1256 # Make sure the values are the same at the point of linking.
1257 self.assertEqual(a.value, b.value)
1257 self.assertEqual(a.value, b.value)
1258
1258
1259 # Change one the value of the source and check that it synchronizes the target.
1259 # Change one the value of the source and check that it synchronizes the target.
1260 a.value = 5
1260 a.value = 5
1261 self.assertEqual(b.value, 5)
1261 self.assertEqual(b.value, 5)
1262 # Change one the value of the target and check that it has no impact on the source
1262 # Change one the value of the target and check that it has no impact on the source
1263 b.value = 6
1263 b.value = 6
1264 self.assertEqual(a.value, 5)
1264 self.assertEqual(a.value, 5)
1265
1265
1266 def test_link_different(self):
1266 def test_link_different(self):
1267 """Verify two traitlets of different types can be linked together using link."""
1267 """Verify two traitlets of different types can be linked together using link."""
1268
1268
1269 # Create two simple classes with Int traitlets.
1269 # Create two simple classes with Int traitlets.
1270 class A(HasTraits):
1270 class A(HasTraits):
1271 value = Int()
1271 value = Int()
1272 class B(HasTraits):
1272 class B(HasTraits):
1273 count = Int()
1273 count = Int()
1274 a = A(value=9)
1274 a = A(value=9)
1275 b = B(count=8)
1275 b = B(count=8)
1276
1276
1277 # Conenct the two classes.
1277 # Conenct the two classes.
1278 c = directional_link((a, 'value'), (b, 'count'))
1278 c = directional_link((a, 'value'), (b, 'count'))
1279
1279
1280 # Make sure the values are the same at the point of linking.
1280 # Make sure the values are the same at the point of linking.
1281 self.assertEqual(a.value, b.count)
1281 self.assertEqual(a.value, b.count)
1282
1282
1283 # Change one the value of the source and check that it synchronizes the target.
1283 # Change one the value of the source and check that it synchronizes the target.
1284 a.value = 5
1284 a.value = 5
1285 self.assertEqual(b.count, 5)
1285 self.assertEqual(b.count, 5)
1286 # Change one the value of the target and check that it has no impact on the source
1286 # Change one the value of the target and check that it has no impact on the source
1287 b.value = 6
1287 b.value = 6
1288 self.assertEqual(a.value, 5)
1288 self.assertEqual(a.value, 5)
1289
1289
1290 def test_unlink(self):
1290 def test_unlink(self):
1291 """Verify two linked traitlets can be unlinked."""
1291 """Verify two linked traitlets can be unlinked."""
1292
1292
1293 # Create two simple classes with Int traitlets.
1293 # Create two simple classes with Int traitlets.
1294 class A(HasTraits):
1294 class A(HasTraits):
1295 value = Int()
1295 value = Int()
1296 a = A(value=9)
1296 a = A(value=9)
1297 b = A(value=8)
1297 b = A(value=8)
1298
1298
1299 # Connect the two classes.
1299 # Connect the two classes.
1300 c = directional_link((a, 'value'), (b, 'value'))
1300 c = directional_link((a, 'value'), (b, 'value'))
1301 a.value = 4
1301 a.value = 4
1302 c.unlink()
1302 c.unlink()
1303
1303
1304 # Change one of the values to make sure they don't stay in sync.
1304 # Change one of the values to make sure they don't stay in sync.
1305 a.value = 5
1305 a.value = 5
1306 self.assertNotEqual(a.value, b.value)
1306 self.assertNotEqual(a.value, b.value)
1307
1307
1308 class Pickleable(HasTraits):
1308 class Pickleable(HasTraits):
1309 i = Int()
1309 i = Int()
1310 j = Int()
1310 j = Int()
1311
1311
1312 def _i_default(self):
1312 def _i_default(self):
1313 return 1
1313 return 1
1314
1314
1315 def _i_changed(self, name, old, new):
1315 def _i_changed(self, name, old, new):
1316 self.j = new
1316 self.j = new
1317
1317
1318 def test_pickle_hastraits():
1318 def test_pickle_hastraits():
1319 c = Pickleable()
1319 c = Pickleable()
1320 for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
1320 for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
1321 p = pickle.dumps(c, protocol)
1321 p = pickle.dumps(c, protocol)
1322 c2 = pickle.loads(p)
1322 c2 = pickle.loads(p)
1323 nt.assert_equal(c2.i, c.i)
1323 nt.assert_equal(c2.i, c.i)
1324 nt.assert_equal(c2.j, c.j)
1324 nt.assert_equal(c2.j, c.j)
1325
1325
1326 c.i = 5
1326 c.i = 5
1327 for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
1327 for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
1328 p = pickle.dumps(c, protocol)
1328 p = pickle.dumps(c, protocol)
1329 c2 = pickle.loads(p)
1329 c2 = pickle.loads(p)
1330 nt.assert_equal(c2.i, c.i)
1330 nt.assert_equal(c2.i, c.i)
1331 nt.assert_equal(c2.j, c.j)
1331 nt.assert_equal(c2.j, c.j)
1332
1332
1333
1333
1334 def test_hold_trait_notifications():
1334 def test_hold_trait_notifications():
1335 changes = []
1335 changes = []
1336
1336
1337 class Test(HasTraits):
1337 class Test(HasTraits):
1338 a = Integer(0)
1338 a = Integer(0)
1339 b = Integer(0)
1339 b = Integer(0)
1340
1340
1341 def _a_changed(self, name, old, new):
1341 def _a_changed(self, name, old, new):
1342 changes.append((old, new))
1342 changes.append((old, new))
1343
1343
1344 def _b_validate(self, value, trait):
1344 def _b_validate(self, value, trait):
1345 if value != 0:
1345 if value != 0:
1346 raise TraitError('Only 0 is a valid value')
1346 raise TraitError('Only 0 is a valid value')
1347 return value
1347 return value
1348
1348
1349 # Test context manager and nesting
1349 # Test context manager and nesting
1350 t = Test()
1350 t = Test()
1351 with t.hold_trait_notifications():
1351 with t.hold_trait_notifications():
1352 with t.hold_trait_notifications():
1352 with t.hold_trait_notifications():
1353 t.a = 1
1353 t.a = 1
1354 nt.assert_equal(t.a, 1)
1354 nt.assert_equal(t.a, 1)
1355 nt.assert_equal(changes, [])
1355 nt.assert_equal(changes, [])
1356 t.a = 2
1356 t.a = 2
1357 nt.assert_equal(t.a, 2)
1357 nt.assert_equal(t.a, 2)
1358 with t.hold_trait_notifications():
1358 with t.hold_trait_notifications():
1359 t.a = 3
1359 t.a = 3
1360 nt.assert_equal(t.a, 3)
1360 nt.assert_equal(t.a, 3)
1361 nt.assert_equal(changes, [])
1361 nt.assert_equal(changes, [])
1362 t.a = 4
1362 t.a = 4
1363 nt.assert_equal(t.a, 4)
1363 nt.assert_equal(t.a, 4)
1364 nt.assert_equal(changes, [])
1364 nt.assert_equal(changes, [])
1365 t.a = 4
1365 t.a = 4
1366 nt.assert_equal(t.a, 4)
1366 nt.assert_equal(t.a, 4)
1367 nt.assert_equal(changes, [])
1367 nt.assert_equal(changes, [])
1368
1368
1369 nt.assert_equal(changes, [(3,4)])
1369 nt.assert_equal(changes, [(0, 4)])
1370 # Test roll-back
1370 # Test roll-back
1371 try:
1371 try:
1372 with t.hold_trait_notifications():
1372 with t.hold_trait_notifications():
1373 t.b = 1 # raises a Trait error
1373 t.b = 1 # raises a Trait error
1374 except:
1374 except:
1375 pass
1375 pass
1376 nt.assert_equal(t.b, 0)
1376 nt.assert_equal(t.b, 0)
1377
1377
1378
1378
1379 class OrderTraits(HasTraits):
1379 class OrderTraits(HasTraits):
1380 notified = Dict()
1380 notified = Dict()
1381
1381
1382 a = Unicode()
1382 a = Unicode()
1383 b = Unicode()
1383 b = Unicode()
1384 c = Unicode()
1384 c = Unicode()
1385 d = Unicode()
1385 d = Unicode()
1386 e = Unicode()
1386 e = Unicode()
1387 f = Unicode()
1387 f = Unicode()
1388 g = Unicode()
1388 g = Unicode()
1389 h = Unicode()
1389 h = Unicode()
1390 i = Unicode()
1390 i = Unicode()
1391 j = Unicode()
1391 j = Unicode()
1392 k = Unicode()
1392 k = Unicode()
1393 l = Unicode()
1393 l = Unicode()
1394
1394
1395 def _notify(self, name, old, new):
1395 def _notify(self, name, old, new):
1396 """check the value of all traits when each trait change is triggered
1396 """check the value of all traits when each trait change is triggered
1397
1397
1398 This verifies that the values are not sensitive
1398 This verifies that the values are not sensitive
1399 to dict ordering when loaded from kwargs
1399 to dict ordering when loaded from kwargs
1400 """
1400 """
1401 # check the value of the other traits
1401 # check the value of the other traits
1402 # when a given trait change notification fires
1402 # when a given trait change notification fires
1403 self.notified[name] = {
1403 self.notified[name] = {
1404 c: getattr(self, c) for c in 'abcdefghijkl'
1404 c: getattr(self, c) for c in 'abcdefghijkl'
1405 }
1405 }
1406
1406
1407 def __init__(self, **kwargs):
1407 def __init__(self, **kwargs):
1408 self.on_trait_change(self._notify)
1408 self.on_trait_change(self._notify)
1409 super(OrderTraits, self).__init__(**kwargs)
1409 super(OrderTraits, self).__init__(**kwargs)
1410
1410
1411 def test_notification_order():
1411 def test_notification_order():
1412 d = {c:c for c in 'abcdefghijkl'}
1412 d = {c:c for c in 'abcdefghijkl'}
1413 obj = OrderTraits()
1413 obj = OrderTraits()
1414 nt.assert_equal(obj.notified, {})
1414 nt.assert_equal(obj.notified, {})
1415 obj = OrderTraits(**d)
1415 obj = OrderTraits(**d)
1416 notifications = {
1416 notifications = {
1417 c: d for c in 'abcdefghijkl'
1417 c: d for c in 'abcdefghijkl'
1418 }
1418 }
1419 nt.assert_equal(obj.notified, notifications)
1419 nt.assert_equal(obj.notified, notifications)
1420
1420
1421
1421
1422 class TestEventful(TestCase):
1422 class TestEventful(TestCase):
1423
1423
1424 def test_list(self):
1424 def test_list(self):
1425 """Does the EventfulList work?"""
1425 """Does the EventfulList work?"""
1426 event_cache = []
1426 event_cache = []
1427
1427
1428 class A(HasTraits):
1428 class A(HasTraits):
1429 x = EventfulList([c for c in 'abc'])
1429 x = EventfulList([c for c in 'abc'])
1430 a = A()
1430 a = A()
1431 a.x.on_events(lambda i, x: event_cache.append('insert'), \
1431 a.x.on_events(lambda i, x: event_cache.append('insert'), \
1432 lambda i, x: event_cache.append('set'), \
1432 lambda i, x: event_cache.append('set'), \
1433 lambda i: event_cache.append('del'), \
1433 lambda i: event_cache.append('del'), \
1434 lambda: event_cache.append('reverse'), \
1434 lambda: event_cache.append('reverse'), \
1435 lambda *p, **k: event_cache.append('sort'))
1435 lambda *p, **k: event_cache.append('sort'))
1436
1436
1437 a.x.remove('c')
1437 a.x.remove('c')
1438 # ab
1438 # ab
1439 a.x.insert(0, 'z')
1439 a.x.insert(0, 'z')
1440 # zab
1440 # zab
1441 del a.x[1]
1441 del a.x[1]
1442 # zb
1442 # zb
1443 a.x.reverse()
1443 a.x.reverse()
1444 # bz
1444 # bz
1445 a.x[1] = 'o'
1445 a.x[1] = 'o'
1446 # bo
1446 # bo
1447 a.x.append('a')
1447 a.x.append('a')
1448 # boa
1448 # boa
1449 a.x.sort()
1449 a.x.sort()
1450 # abo
1450 # abo
1451
1451
1452 # Were the correct events captured?
1452 # Were the correct events captured?
1453 self.assertEqual(event_cache, ['del', 'insert', 'del', 'reverse', 'set', 'set', 'sort'])
1453 self.assertEqual(event_cache, ['del', 'insert', 'del', 'reverse', 'set', 'set', 'sort'])
1454
1454
1455 # Is the output correct?
1455 # Is the output correct?
1456 self.assertEqual(a.x, [c for c in 'abo'])
1456 self.assertEqual(a.x, [c for c in 'abo'])
1457
1457
1458 def test_dict(self):
1458 def test_dict(self):
1459 """Does the EventfulDict work?"""
1459 """Does the EventfulDict work?"""
1460 event_cache = []
1460 event_cache = []
1461
1461
1462 class A(HasTraits):
1462 class A(HasTraits):
1463 x = EventfulDict({c: c for c in 'abc'})
1463 x = EventfulDict({c: c for c in 'abc'})
1464 a = A()
1464 a = A()
1465 a.x.on_events(lambda k, v: event_cache.append('add'), \
1465 a.x.on_events(lambda k, v: event_cache.append('add'), \
1466 lambda k, v: event_cache.append('set'), \
1466 lambda k, v: event_cache.append('set'), \
1467 lambda k: event_cache.append('del'))
1467 lambda k: event_cache.append('del'))
1468
1468
1469 del a.x['c']
1469 del a.x['c']
1470 # ab
1470 # ab
1471 a.x['z'] = 1
1471 a.x['z'] = 1
1472 # abz
1472 # abz
1473 a.x['z'] = 'z'
1473 a.x['z'] = 'z'
1474 # abz
1474 # abz
1475 a.x.pop('a')
1475 a.x.pop('a')
1476 # bz
1476 # bz
1477
1477
1478 # Were the correct events captured?
1478 # Were the correct events captured?
1479 self.assertEqual(event_cache, ['del', 'add', 'set', 'del'])
1479 self.assertEqual(event_cache, ['del', 'add', 'set', 'del'])
1480
1480
1481 # Is the output correct?
1481 # Is the output correct?
1482 self.assertEqual(a.x, {c: c for c in 'bz'})
1482 self.assertEqual(a.x, {c: c for c in 'bz'})
1483
1483
1484 ###
1484 ###
1485 # Traits for Forward Declaration Tests
1485 # Traits for Forward Declaration Tests
1486 ###
1486 ###
1487 class ForwardDeclaredInstanceTrait(HasTraits):
1487 class ForwardDeclaredInstanceTrait(HasTraits):
1488
1488
1489 value = ForwardDeclaredInstance('ForwardDeclaredBar', allow_none=True)
1489 value = ForwardDeclaredInstance('ForwardDeclaredBar', allow_none=True)
1490
1490
1491 class ForwardDeclaredTypeTrait(HasTraits):
1491 class ForwardDeclaredTypeTrait(HasTraits):
1492
1492
1493 value = ForwardDeclaredType('ForwardDeclaredBar', allow_none=True)
1493 value = ForwardDeclaredType('ForwardDeclaredBar', allow_none=True)
1494
1494
1495 class ForwardDeclaredInstanceListTrait(HasTraits):
1495 class ForwardDeclaredInstanceListTrait(HasTraits):
1496
1496
1497 value = List(ForwardDeclaredInstance('ForwardDeclaredBar'))
1497 value = List(ForwardDeclaredInstance('ForwardDeclaredBar'))
1498
1498
1499 class ForwardDeclaredTypeListTrait(HasTraits):
1499 class ForwardDeclaredTypeListTrait(HasTraits):
1500
1500
1501 value = List(ForwardDeclaredType('ForwardDeclaredBar'))
1501 value = List(ForwardDeclaredType('ForwardDeclaredBar'))
1502 ###
1502 ###
1503 # End Traits for Forward Declaration Tests
1503 # End Traits for Forward Declaration Tests
1504 ###
1504 ###
1505
1505
1506 ###
1506 ###
1507 # Classes for Forward Declaration Tests
1507 # Classes for Forward Declaration Tests
1508 ###
1508 ###
1509 class ForwardDeclaredBar(object):
1509 class ForwardDeclaredBar(object):
1510 pass
1510 pass
1511
1511
1512 class ForwardDeclaredBarSub(ForwardDeclaredBar):
1512 class ForwardDeclaredBarSub(ForwardDeclaredBar):
1513 pass
1513 pass
1514 ###
1514 ###
1515 # End Classes for Forward Declaration Tests
1515 # End Classes for Forward Declaration Tests
1516 ###
1516 ###
1517
1517
1518 ###
1518 ###
1519 # Forward Declaration Tests
1519 # Forward Declaration Tests
1520 ###
1520 ###
1521 class TestForwardDeclaredInstanceTrait(TraitTestBase):
1521 class TestForwardDeclaredInstanceTrait(TraitTestBase):
1522
1522
1523 obj = ForwardDeclaredInstanceTrait()
1523 obj = ForwardDeclaredInstanceTrait()
1524 _default_value = None
1524 _default_value = None
1525 _good_values = [None, ForwardDeclaredBar(), ForwardDeclaredBarSub()]
1525 _good_values = [None, ForwardDeclaredBar(), ForwardDeclaredBarSub()]
1526 _bad_values = ['foo', 3, ForwardDeclaredBar, ForwardDeclaredBarSub]
1526 _bad_values = ['foo', 3, ForwardDeclaredBar, ForwardDeclaredBarSub]
1527
1527
1528 class TestForwardDeclaredTypeTrait(TraitTestBase):
1528 class TestForwardDeclaredTypeTrait(TraitTestBase):
1529
1529
1530 obj = ForwardDeclaredTypeTrait()
1530 obj = ForwardDeclaredTypeTrait()
1531 _default_value = None
1531 _default_value = None
1532 _good_values = [None, ForwardDeclaredBar, ForwardDeclaredBarSub]
1532 _good_values = [None, ForwardDeclaredBar, ForwardDeclaredBarSub]
1533 _bad_values = ['foo', 3, ForwardDeclaredBar(), ForwardDeclaredBarSub()]
1533 _bad_values = ['foo', 3, ForwardDeclaredBar(), ForwardDeclaredBarSub()]
1534
1534
1535 class TestForwardDeclaredInstanceList(TraitTestBase):
1535 class TestForwardDeclaredInstanceList(TraitTestBase):
1536
1536
1537 obj = ForwardDeclaredInstanceListTrait()
1537 obj = ForwardDeclaredInstanceListTrait()
1538
1538
1539 def test_klass(self):
1539 def test_klass(self):
1540 """Test that the instance klass is properly assigned."""
1540 """Test that the instance klass is properly assigned."""
1541 self.assertIs(self.obj.traits()['value']._trait.klass, ForwardDeclaredBar)
1541 self.assertIs(self.obj.traits()['value']._trait.klass, ForwardDeclaredBar)
1542
1542
1543 _default_value = []
1543 _default_value = []
1544 _good_values = [
1544 _good_values = [
1545 [ForwardDeclaredBar(), ForwardDeclaredBarSub()],
1545 [ForwardDeclaredBar(), ForwardDeclaredBarSub()],
1546 [],
1546 [],
1547 ]
1547 ]
1548 _bad_values = [
1548 _bad_values = [
1549 ForwardDeclaredBar(),
1549 ForwardDeclaredBar(),
1550 [ForwardDeclaredBar(), 3, None],
1550 [ForwardDeclaredBar(), 3, None],
1551 '1',
1551 '1',
1552 # Note that this is the type, not an instance.
1552 # Note that this is the type, not an instance.
1553 [ForwardDeclaredBar],
1553 [ForwardDeclaredBar],
1554 [None],
1554 [None],
1555 None,
1555 None,
1556 ]
1556 ]
1557
1557
1558 class TestForwardDeclaredTypeList(TraitTestBase):
1558 class TestForwardDeclaredTypeList(TraitTestBase):
1559
1559
1560 obj = ForwardDeclaredTypeListTrait()
1560 obj = ForwardDeclaredTypeListTrait()
1561
1561
1562 def test_klass(self):
1562 def test_klass(self):
1563 """Test that the instance klass is properly assigned."""
1563 """Test that the instance klass is properly assigned."""
1564 self.assertIs(self.obj.traits()['value']._trait.klass, ForwardDeclaredBar)
1564 self.assertIs(self.obj.traits()['value']._trait.klass, ForwardDeclaredBar)
1565
1565
1566 _default_value = []
1566 _default_value = []
1567 _good_values = [
1567 _good_values = [
1568 [ForwardDeclaredBar, ForwardDeclaredBarSub],
1568 [ForwardDeclaredBar, ForwardDeclaredBarSub],
1569 [],
1569 [],
1570 ]
1570 ]
1571 _bad_values = [
1571 _bad_values = [
1572 ForwardDeclaredBar,
1572 ForwardDeclaredBar,
1573 [ForwardDeclaredBar, 3],
1573 [ForwardDeclaredBar, 3],
1574 '1',
1574 '1',
1575 # Note that this is an instance, not the type.
1575 # Note that this is an instance, not the type.
1576 [ForwardDeclaredBar()],
1576 [ForwardDeclaredBar()],
1577 [None],
1577 [None],
1578 None,
1578 None,
1579 ]
1579 ]
1580 ###
1580 ###
1581 # End Forward Declaration Tests
1581 # End Forward Declaration Tests
1582 ###
1582 ###
1583
1583
1584 class TestDynamicTraits(TestCase):
1584 class TestDynamicTraits(TestCase):
1585
1585
1586 def setUp(self):
1586 def setUp(self):
1587 self._notify1 = []
1587 self._notify1 = []
1588
1588
1589 def notify1(self, name, old, new):
1589 def notify1(self, name, old, new):
1590 self._notify1.append((name, old, new))
1590 self._notify1.append((name, old, new))
1591
1591
1592 def test_notify_all(self):
1592 def test_notify_all(self):
1593
1593
1594 class A(HasTraits):
1594 class A(HasTraits):
1595 pass
1595 pass
1596
1596
1597 a = A()
1597 a = A()
1598 self.assertTrue(not hasattr(a, 'x'))
1598 self.assertTrue(not hasattr(a, 'x'))
1599 self.assertTrue(not hasattr(a, 'y'))
1599 self.assertTrue(not hasattr(a, 'y'))
1600
1600
1601 # Dynamically add trait x.
1601 # Dynamically add trait x.
1602 a.add_trait('x', Int())
1602 a.add_trait('x', Int())
1603 self.assertTrue(hasattr(a, 'x'))
1603 self.assertTrue(hasattr(a, 'x'))
1604 self.assertTrue(isinstance(a, (A, )))
1604 self.assertTrue(isinstance(a, (A, )))
1605
1605
1606 # Dynamically add trait y.
1606 # Dynamically add trait y.
1607 a.add_trait('y', Float())
1607 a.add_trait('y', Float())
1608 self.assertTrue(hasattr(a, 'y'))
1608 self.assertTrue(hasattr(a, 'y'))
1609 self.assertTrue(isinstance(a, (A, )))
1609 self.assertTrue(isinstance(a, (A, )))
1610 self.assertEqual(a.__class__.__name__, A.__name__)
1610 self.assertEqual(a.__class__.__name__, A.__name__)
1611
1611
1612 # Create a new instance and verify that x and y
1612 # Create a new instance and verify that x and y
1613 # aren't defined.
1613 # aren't defined.
1614 b = A()
1614 b = A()
1615 self.assertTrue(not hasattr(b, 'x'))
1615 self.assertTrue(not hasattr(b, 'x'))
1616 self.assertTrue(not hasattr(b, 'y'))
1616 self.assertTrue(not hasattr(b, 'y'))
1617
1617
1618 # Verify that notification works like normal.
1618 # Verify that notification works like normal.
1619 a.on_trait_change(self.notify1)
1619 a.on_trait_change(self.notify1)
1620 a.x = 0
1620 a.x = 0
1621 self.assertEqual(len(self._notify1), 0)
1621 self.assertEqual(len(self._notify1), 0)
1622 a.y = 0.0
1622 a.y = 0.0
1623 self.assertEqual(len(self._notify1), 0)
1623 self.assertEqual(len(self._notify1), 0)
1624 a.x = 10
1624 a.x = 10
1625 self.assertTrue(('x', 0, 10) in self._notify1)
1625 self.assertTrue(('x', 0, 10) in self._notify1)
1626 a.y = 10.0
1626 a.y = 10.0
1627 self.assertTrue(('y', 0.0, 10.0) in self._notify1)
1627 self.assertTrue(('y', 0.0, 10.0) in self._notify1)
1628 self.assertRaises(TraitError, setattr, a, 'x', 'bad string')
1628 self.assertRaises(TraitError, setattr, a, 'x', 'bad string')
1629 self.assertRaises(TraitError, setattr, a, 'y', 'bad string')
1629 self.assertRaises(TraitError, setattr, a, 'y', 'bad string')
1630 self._notify1 = []
1630 self._notify1 = []
1631 a.on_trait_change(self.notify1, remove=True)
1631 a.on_trait_change(self.notify1, remove=True)
1632 a.x = 20
1632 a.x = 20
1633 a.y = 20.0
1633 a.y = 20.0
1634 self.assertEqual(len(self._notify1), 0)
1634 self.assertEqual(len(self._notify1), 0)
@@ -1,1875 +1,1874
1 # encoding: utf-8
1 # encoding: utf-8
2 """
2 """
3 A lightweight Traits like module.
3 A lightweight Traits like module.
4
4
5 This is designed to provide a lightweight, simple, pure Python version of
5 This is designed to provide a lightweight, simple, pure Python version of
6 many of the capabilities of enthought.traits. This includes:
6 many of the capabilities of enthought.traits. This includes:
7
7
8 * Validation
8 * Validation
9 * Type specification with defaults
9 * Type specification with defaults
10 * Static and dynamic notification
10 * Static and dynamic notification
11 * Basic predefined types
11 * Basic predefined types
12 * An API that is similar to enthought.traits
12 * An API that is similar to enthought.traits
13
13
14 We don't support:
14 We don't support:
15
15
16 * Delegation
16 * Delegation
17 * Automatic GUI generation
17 * Automatic GUI generation
18 * A full set of trait types. Most importantly, we don't provide container
18 * A full set of trait types. Most importantly, we don't provide container
19 traits (list, dict, tuple) that can trigger notifications if their
19 traits (list, dict, tuple) that can trigger notifications if their
20 contents change.
20 contents change.
21 * API compatibility with enthought.traits
21 * API compatibility with enthought.traits
22
22
23 There are also some important difference in our design:
23 There are also some important difference in our design:
24
24
25 * enthought.traits does not validate default values. We do.
25 * enthought.traits does not validate default values. We do.
26
26
27 We choose to create this module because we need these capabilities, but
27 We choose to create this module because we need these capabilities, but
28 we need them to be pure Python so they work in all Python implementations,
28 we need them to be pure Python so they work in all Python implementations,
29 including Jython and IronPython.
29 including Jython and IronPython.
30
30
31 Inheritance diagram:
31 Inheritance diagram:
32
32
33 .. inheritance-diagram:: IPython.utils.traitlets
33 .. inheritance-diagram:: IPython.utils.traitlets
34 :parts: 3
34 :parts: 3
35 """
35 """
36
36
37 # Copyright (c) IPython Development Team.
37 # Copyright (c) IPython Development Team.
38 # Distributed under the terms of the Modified BSD License.
38 # Distributed under the terms of the Modified BSD License.
39 #
39 #
40 # Adapted from enthought.traits, Copyright (c) Enthought, Inc.,
40 # Adapted from enthought.traits, Copyright (c) Enthought, Inc.,
41 # also under the terms of the Modified BSD License.
41 # also under the terms of the Modified BSD License.
42
42
43 import contextlib
43 import contextlib
44 import inspect
44 import inspect
45 import re
45 import re
46 import sys
46 import sys
47 import types
47 import types
48 from types import FunctionType
48 from types import FunctionType
49 try:
49 try:
50 from types import ClassType, InstanceType
50 from types import ClassType, InstanceType
51 ClassTypes = (ClassType, type)
51 ClassTypes = (ClassType, type)
52 except:
52 except:
53 ClassTypes = (type,)
53 ClassTypes = (type,)
54 from warnings import warn
54 from warnings import warn
55
55
56 from IPython.utils import py3compat
56 from IPython.utils import py3compat
57 from IPython.utils import eventful
57 from IPython.utils import eventful
58 from IPython.utils.getargspec import getargspec
58 from IPython.utils.getargspec import getargspec
59 from IPython.utils.importstring import import_item
59 from IPython.utils.importstring import import_item
60 from IPython.utils.py3compat import iteritems, string_types
60 from IPython.utils.py3compat import iteritems, string_types
61
61
62 from .sentinel import Sentinel
62 from .sentinel import Sentinel
63 SequenceTypes = (list, tuple, set, frozenset)
63 SequenceTypes = (list, tuple, set, frozenset)
64
64
65 #-----------------------------------------------------------------------------
65 #-----------------------------------------------------------------------------
66 # Basic classes
66 # Basic classes
67 #-----------------------------------------------------------------------------
67 #-----------------------------------------------------------------------------
68
68
69
69
70 NoDefaultSpecified = Sentinel('NoDefaultSpecified', __name__,
70 NoDefaultSpecified = Sentinel('NoDefaultSpecified', __name__,
71 '''
71 '''
72 Used in Traitlets to specify that no defaults are set in kwargs
72 Used in Traitlets to specify that no defaults are set in kwargs
73 '''
73 '''
74 )
74 )
75
75
76
76
77 class Undefined ( object ): pass
77 class Undefined ( object ): pass
78 Undefined = Undefined()
78 Undefined = Undefined()
79
79
80 class TraitError(Exception):
80 class TraitError(Exception):
81 pass
81 pass
82
82
83 #-----------------------------------------------------------------------------
83 #-----------------------------------------------------------------------------
84 # Utilities
84 # Utilities
85 #-----------------------------------------------------------------------------
85 #-----------------------------------------------------------------------------
86
86
87
87
88 def class_of ( object ):
88 def class_of ( object ):
89 """ Returns a string containing the class name of an object with the
89 """ Returns a string containing the class name of an object with the
90 correct indefinite article ('a' or 'an') preceding it (e.g., 'an Image',
90 correct indefinite article ('a' or 'an') preceding it (e.g., 'an Image',
91 'a PlotValue').
91 'a PlotValue').
92 """
92 """
93 if isinstance( object, py3compat.string_types ):
93 if isinstance( object, py3compat.string_types ):
94 return add_article( object )
94 return add_article( object )
95
95
96 return add_article( object.__class__.__name__ )
96 return add_article( object.__class__.__name__ )
97
97
98
98
99 def add_article ( name ):
99 def add_article ( name ):
100 """ Returns a string containing the correct indefinite article ('a' or 'an')
100 """ Returns a string containing the correct indefinite article ('a' or 'an')
101 prefixed to the specified string.
101 prefixed to the specified string.
102 """
102 """
103 if name[:1].lower() in 'aeiou':
103 if name[:1].lower() in 'aeiou':
104 return 'an ' + name
104 return 'an ' + name
105
105
106 return 'a ' + name
106 return 'a ' + name
107
107
108
108
109 def repr_type(obj):
109 def repr_type(obj):
110 """ Return a string representation of a value and its type for readable
110 """ Return a string representation of a value and its type for readable
111 error messages.
111 error messages.
112 """
112 """
113 the_type = type(obj)
113 the_type = type(obj)
114 if (not py3compat.PY3) and the_type is InstanceType:
114 if (not py3compat.PY3) and the_type is InstanceType:
115 # Old-style class.
115 # Old-style class.
116 the_type = obj.__class__
116 the_type = obj.__class__
117 msg = '%r %r' % (obj, the_type)
117 msg = '%r %r' % (obj, the_type)
118 return msg
118 return msg
119
119
120
120
121 def is_trait(t):
121 def is_trait(t):
122 """ Returns whether the given value is an instance or subclass of TraitType.
122 """ Returns whether the given value is an instance or subclass of TraitType.
123 """
123 """
124 return (isinstance(t, TraitType) or
124 return (isinstance(t, TraitType) or
125 (isinstance(t, type) and issubclass(t, TraitType)))
125 (isinstance(t, type) and issubclass(t, TraitType)))
126
126
127
127
128 def parse_notifier_name(name):
128 def parse_notifier_name(name):
129 """Convert the name argument to a list of names.
129 """Convert the name argument to a list of names.
130
130
131 Examples
131 Examples
132 --------
132 --------
133
133
134 >>> parse_notifier_name('a')
134 >>> parse_notifier_name('a')
135 ['a']
135 ['a']
136 >>> parse_notifier_name(['a','b'])
136 >>> parse_notifier_name(['a','b'])
137 ['a', 'b']
137 ['a', 'b']
138 >>> parse_notifier_name(None)
138 >>> parse_notifier_name(None)
139 ['anytrait']
139 ['anytrait']
140 """
140 """
141 if isinstance(name, string_types):
141 if isinstance(name, string_types):
142 return [name]
142 return [name]
143 elif name is None:
143 elif name is None:
144 return ['anytrait']
144 return ['anytrait']
145 elif isinstance(name, (list, tuple)):
145 elif isinstance(name, (list, tuple)):
146 for n in name:
146 for n in name:
147 assert isinstance(n, string_types), "names must be strings"
147 assert isinstance(n, string_types), "names must be strings"
148 return name
148 return name
149
149
150
150
151 class _SimpleTest:
151 class _SimpleTest:
152 def __init__ ( self, value ): self.value = value
152 def __init__ ( self, value ): self.value = value
153 def __call__ ( self, test ):
153 def __call__ ( self, test ):
154 return test == self.value
154 return test == self.value
155 def __repr__(self):
155 def __repr__(self):
156 return "<SimpleTest(%r)" % self.value
156 return "<SimpleTest(%r)" % self.value
157 def __str__(self):
157 def __str__(self):
158 return self.__repr__()
158 return self.__repr__()
159
159
160
160
161 def getmembers(object, predicate=None):
161 def getmembers(object, predicate=None):
162 """A safe version of inspect.getmembers that handles missing attributes.
162 """A safe version of inspect.getmembers that handles missing attributes.
163
163
164 This is useful when there are descriptor based attributes that for
164 This is useful when there are descriptor based attributes that for
165 some reason raise AttributeError even though they exist. This happens
165 some reason raise AttributeError even though they exist. This happens
166 in zope.inteface with the __provides__ attribute.
166 in zope.inteface with the __provides__ attribute.
167 """
167 """
168 results = []
168 results = []
169 for key in dir(object):
169 for key in dir(object):
170 try:
170 try:
171 value = getattr(object, key)
171 value = getattr(object, key)
172 except AttributeError:
172 except AttributeError:
173 pass
173 pass
174 else:
174 else:
175 if not predicate or predicate(value):
175 if not predicate or predicate(value):
176 results.append((key, value))
176 results.append((key, value))
177 results.sort()
177 results.sort()
178 return results
178 return results
179
179
180 def _validate_link(*tuples):
180 def _validate_link(*tuples):
181 """Validate arguments for traitlet link functions"""
181 """Validate arguments for traitlet link functions"""
182 for t in tuples:
182 for t in tuples:
183 if not len(t) == 2:
183 if not len(t) == 2:
184 raise TypeError("Each linked traitlet must be specified as (HasTraits, 'trait_name'), not %r" % t)
184 raise TypeError("Each linked traitlet must be specified as (HasTraits, 'trait_name'), not %r" % t)
185 obj, trait_name = t
185 obj, trait_name = t
186 if not isinstance(obj, HasTraits):
186 if not isinstance(obj, HasTraits):
187 raise TypeError("Each object must be HasTraits, not %r" % type(obj))
187 raise TypeError("Each object must be HasTraits, not %r" % type(obj))
188 if not trait_name in obj.traits():
188 if not trait_name in obj.traits():
189 raise TypeError("%r has no trait %r" % (obj, trait_name))
189 raise TypeError("%r has no trait %r" % (obj, trait_name))
190
190
191 class link(object):
191 class link(object):
192 """Link traits from different objects together so they remain in sync.
192 """Link traits from different objects together so they remain in sync.
193
193
194 Parameters
194 Parameters
195 ----------
195 ----------
196 *args : pairs of objects/attributes
196 *args : pairs of objects/attributes
197
197
198 Examples
198 Examples
199 --------
199 --------
200
200
201 >>> c = link((obj1, 'value'), (obj2, 'value'), (obj3, 'value'))
201 >>> c = link((obj1, 'value'), (obj2, 'value'), (obj3, 'value'))
202 >>> obj1.value = 5 # updates other objects as well
202 >>> obj1.value = 5 # updates other objects as well
203 """
203 """
204 updating = False
204 updating = False
205 def __init__(self, *args):
205 def __init__(self, *args):
206 if len(args) < 2:
206 if len(args) < 2:
207 raise TypeError('At least two traitlets must be provided.')
207 raise TypeError('At least two traitlets must be provided.')
208 _validate_link(*args)
208 _validate_link(*args)
209
209
210 self.objects = {}
210 self.objects = {}
211
211
212 initial = getattr(args[0][0], args[0][1])
212 initial = getattr(args[0][0], args[0][1])
213 for obj, attr in args:
213 for obj, attr in args:
214 setattr(obj, attr, initial)
214 setattr(obj, attr, initial)
215
215
216 callback = self._make_closure(obj, attr)
216 callback = self._make_closure(obj, attr)
217 obj.on_trait_change(callback, attr)
217 obj.on_trait_change(callback, attr)
218 self.objects[(obj, attr)] = callback
218 self.objects[(obj, attr)] = callback
219
219
220 @contextlib.contextmanager
220 @contextlib.contextmanager
221 def _busy_updating(self):
221 def _busy_updating(self):
222 self.updating = True
222 self.updating = True
223 try:
223 try:
224 yield
224 yield
225 finally:
225 finally:
226 self.updating = False
226 self.updating = False
227
227
228 def _make_closure(self, sending_obj, sending_attr):
228 def _make_closure(self, sending_obj, sending_attr):
229 def update(name, old, new):
229 def update(name, old, new):
230 self._update(sending_obj, sending_attr, new)
230 self._update(sending_obj, sending_attr, new)
231 return update
231 return update
232
232
233 def _update(self, sending_obj, sending_attr, new):
233 def _update(self, sending_obj, sending_attr, new):
234 if self.updating:
234 if self.updating:
235 return
235 return
236 with self._busy_updating():
236 with self._busy_updating():
237 for obj, attr in self.objects.keys():
237 for obj, attr in self.objects.keys():
238 setattr(obj, attr, new)
238 setattr(obj, attr, new)
239
239
240 def unlink(self):
240 def unlink(self):
241 for key, callback in self.objects.items():
241 for key, callback in self.objects.items():
242 (obj, attr) = key
242 (obj, attr) = key
243 obj.on_trait_change(callback, attr, remove=True)
243 obj.on_trait_change(callback, attr, remove=True)
244
244
245 class directional_link(object):
245 class directional_link(object):
246 """Link the trait of a source object with traits of target objects.
246 """Link the trait of a source object with traits of target objects.
247
247
248 Parameters
248 Parameters
249 ----------
249 ----------
250 source : pair of object, name
250 source : pair of object, name
251 targets : pairs of objects/attributes
251 targets : pairs of objects/attributes
252
252
253 Examples
253 Examples
254 --------
254 --------
255
255
256 >>> c = directional_link((src, 'value'), (tgt1, 'value'), (tgt2, 'value'))
256 >>> c = directional_link((src, 'value'), (tgt1, 'value'), (tgt2, 'value'))
257 >>> src.value = 5 # updates target objects
257 >>> src.value = 5 # updates target objects
258 >>> tgt1.value = 6 # does not update other objects
258 >>> tgt1.value = 6 # does not update other objects
259 """
259 """
260 updating = False
260 updating = False
261
261
262 def __init__(self, source, *targets):
262 def __init__(self, source, *targets):
263 if len(targets) < 1:
263 if len(targets) < 1:
264 raise TypeError('At least two traitlets must be provided.')
264 raise TypeError('At least two traitlets must be provided.')
265 _validate_link(source, *targets)
265 _validate_link(source, *targets)
266 self.source = source
266 self.source = source
267 self.targets = targets
267 self.targets = targets
268
268
269 # Update current value
269 # Update current value
270 src_attr_value = getattr(source[0], source[1])
270 src_attr_value = getattr(source[0], source[1])
271 for obj, attr in targets:
271 for obj, attr in targets:
272 setattr(obj, attr, src_attr_value)
272 setattr(obj, attr, src_attr_value)
273
273
274 # Wire
274 # Wire
275 self.source[0].on_trait_change(self._update, self.source[1])
275 self.source[0].on_trait_change(self._update, self.source[1])
276
276
277 @contextlib.contextmanager
277 @contextlib.contextmanager
278 def _busy_updating(self):
278 def _busy_updating(self):
279 self.updating = True
279 self.updating = True
280 try:
280 try:
281 yield
281 yield
282 finally:
282 finally:
283 self.updating = False
283 self.updating = False
284
284
285 def _update(self, name, old, new):
285 def _update(self, name, old, new):
286 if self.updating:
286 if self.updating:
287 return
287 return
288 with self._busy_updating():
288 with self._busy_updating():
289 for obj, attr in self.targets:
289 for obj, attr in self.targets:
290 setattr(obj, attr, new)
290 setattr(obj, attr, new)
291
291
292 def unlink(self):
292 def unlink(self):
293 self.source[0].on_trait_change(self._update, self.source[1], remove=True)
293 self.source[0].on_trait_change(self._update, self.source[1], remove=True)
294 self.source = None
294 self.source = None
295 self.targets = []
295 self.targets = []
296
296
297 dlink = directional_link
297 dlink = directional_link
298
298
299
299
300 #-----------------------------------------------------------------------------
300 #-----------------------------------------------------------------------------
301 # Base TraitType for all traits
301 # Base TraitType for all traits
302 #-----------------------------------------------------------------------------
302 #-----------------------------------------------------------------------------
303
303
304
304
305 class TraitType(object):
305 class TraitType(object):
306 """A base class for all trait descriptors.
306 """A base class for all trait descriptors.
307
307
308 Notes
308 Notes
309 -----
309 -----
310 Our implementation of traits is based on Python's descriptor
310 Our implementation of traits is based on Python's descriptor
311 prototol. This class is the base class for all such descriptors. The
311 prototol. This class is the base class for all such descriptors. The
312 only magic we use is a custom metaclass for the main :class:`HasTraits`
312 only magic we use is a custom metaclass for the main :class:`HasTraits`
313 class that does the following:
313 class that does the following:
314
314
315 1. Sets the :attr:`name` attribute of every :class:`TraitType`
315 1. Sets the :attr:`name` attribute of every :class:`TraitType`
316 instance in the class dict to the name of the attribute.
316 instance in the class dict to the name of the attribute.
317 2. Sets the :attr:`this_class` attribute of every :class:`TraitType`
317 2. Sets the :attr:`this_class` attribute of every :class:`TraitType`
318 instance in the class dict to the *class* that declared the trait.
318 instance in the class dict to the *class* that declared the trait.
319 This is used by the :class:`This` trait to allow subclasses to
319 This is used by the :class:`This` trait to allow subclasses to
320 accept superclasses for :class:`This` values.
320 accept superclasses for :class:`This` values.
321 """
321 """
322
322
323 metadata = {}
323 metadata = {}
324 default_value = Undefined
324 default_value = Undefined
325 allow_none = False
325 allow_none = False
326 info_text = 'any value'
326 info_text = 'any value'
327
327
328 def __init__(self, default_value=NoDefaultSpecified, allow_none=None, **metadata):
328 def __init__(self, default_value=NoDefaultSpecified, allow_none=None, **metadata):
329 """Create a TraitType.
329 """Create a TraitType.
330 """
330 """
331 if default_value is not NoDefaultSpecified:
331 if default_value is not NoDefaultSpecified:
332 self.default_value = default_value
332 self.default_value = default_value
333 if allow_none is not None:
333 if allow_none is not None:
334 self.allow_none = allow_none
334 self.allow_none = allow_none
335
335
336 if 'default' in metadata:
336 if 'default' in metadata:
337 # Warn the user that they probably meant default_value.
337 # Warn the user that they probably meant default_value.
338 warn(
338 warn(
339 "Parameter 'default' passed to TraitType. "
339 "Parameter 'default' passed to TraitType. "
340 "Did you mean 'default_value'?"
340 "Did you mean 'default_value'?"
341 )
341 )
342
342
343 if len(metadata) > 0:
343 if len(metadata) > 0:
344 if len(self.metadata) > 0:
344 if len(self.metadata) > 0:
345 self._metadata = self.metadata.copy()
345 self._metadata = self.metadata.copy()
346 self._metadata.update(metadata)
346 self._metadata.update(metadata)
347 else:
347 else:
348 self._metadata = metadata
348 self._metadata = metadata
349 else:
349 else:
350 self._metadata = self.metadata
350 self._metadata = self.metadata
351
351
352 self.init()
352 self.init()
353
353
354 def init(self):
354 def init(self):
355 pass
355 pass
356
356
357 def get_default_value(self):
357 def get_default_value(self):
358 """Create a new instance of the default value."""
358 """Create a new instance of the default value."""
359 return self.default_value
359 return self.default_value
360
360
361 def instance_init(self):
361 def instance_init(self):
362 """Part of the initialization which may depends on the underlying
362 """Part of the initialization which may depends on the underlying
363 HasTraits instance.
363 HasTraits instance.
364
364
365 It is typically overloaded for specific trait types.
365 It is typically overloaded for specific trait types.
366
366
367 This method is called by :meth:`HasTraits.__new__` and in the
367 This method is called by :meth:`HasTraits.__new__` and in the
368 :meth:`TraitType.instance_init` method of trait types holding
368 :meth:`TraitType.instance_init` method of trait types holding
369 other trait types.
369 other trait types.
370 """
370 """
371 pass
371 pass
372
372
373 def init_default_value(self, obj):
373 def init_default_value(self, obj):
374 """Instantiate the default value for the trait type.
374 """Instantiate the default value for the trait type.
375
375
376 This method is called by :meth:`TraitType.set_default_value` in the
376 This method is called by :meth:`TraitType.set_default_value` in the
377 case a default value is provided at construction time or later when
377 case a default value is provided at construction time or later when
378 accessing the trait value for the first time in
378 accessing the trait value for the first time in
379 :meth:`HasTraits.__get__`.
379 :meth:`HasTraits.__get__`.
380 """
380 """
381 value = self.get_default_value()
381 value = self.get_default_value()
382 value = self._validate(obj, value)
382 value = self._validate(obj, value)
383 obj._trait_values[self.name] = value
383 obj._trait_values[self.name] = value
384 return value
384 return value
385
385
386 def set_default_value(self, obj):
386 def set_default_value(self, obj):
387 """Set the default value on a per instance basis.
387 """Set the default value on a per instance basis.
388
388
389 This method is called by :meth:`HasTraits.__new__` to instantiate and
389 This method is called by :meth:`HasTraits.__new__` to instantiate and
390 validate the default value. The creation and validation of
390 validate the default value. The creation and validation of
391 default values must be delayed until the parent :class:`HasTraits`
391 default values must be delayed until the parent :class:`HasTraits`
392 class has been instantiated.
392 class has been instantiated.
393 Parameters
393 Parameters
394 ----------
394 ----------
395 obj : :class:`HasTraits` instance
395 obj : :class:`HasTraits` instance
396 The parent :class:`HasTraits` instance that has just been
396 The parent :class:`HasTraits` instance that has just been
397 created.
397 created.
398 """
398 """
399 # Check for a deferred initializer defined in the same class as the
399 # Check for a deferred initializer defined in the same class as the
400 # trait declaration or above.
400 # trait declaration or above.
401 mro = type(obj).mro()
401 mro = type(obj).mro()
402 meth_name = '_%s_default' % self.name
402 meth_name = '_%s_default' % self.name
403 for cls in mro[:mro.index(self.this_class)+1]:
403 for cls in mro[:mro.index(self.this_class)+1]:
404 if meth_name in cls.__dict__:
404 if meth_name in cls.__dict__:
405 break
405 break
406 else:
406 else:
407 # We didn't find one. Do static initialization.
407 # We didn't find one. Do static initialization.
408 self.init_default_value(obj)
408 self.init_default_value(obj)
409 return
409 return
410 # Complete the dynamic initialization.
410 # Complete the dynamic initialization.
411 obj._trait_dyn_inits[self.name] = meth_name
411 obj._trait_dyn_inits[self.name] = meth_name
412
412
413 def __get__(self, obj, cls=None):
413 def __get__(self, obj, cls=None):
414 """Get the value of the trait by self.name for the instance.
414 """Get the value of the trait by self.name for the instance.
415
415
416 Default values are instantiated when :meth:`HasTraits.__new__`
416 Default values are instantiated when :meth:`HasTraits.__new__`
417 is called. Thus by the time this method gets called either the
417 is called. Thus by the time this method gets called either the
418 default value or a user defined value (they called :meth:`__set__`)
418 default value or a user defined value (they called :meth:`__set__`)
419 is in the :class:`HasTraits` instance.
419 is in the :class:`HasTraits` instance.
420 """
420 """
421 if obj is None:
421 if obj is None:
422 return self
422 return self
423 else:
423 else:
424 try:
424 try:
425 value = obj._trait_values[self.name]
425 value = obj._trait_values[self.name]
426 except KeyError:
426 except KeyError:
427 # Check for a dynamic initializer.
427 # Check for a dynamic initializer.
428 if self.name in obj._trait_dyn_inits:
428 if self.name in obj._trait_dyn_inits:
429 method = getattr(obj, obj._trait_dyn_inits[self.name])
429 method = getattr(obj, obj._trait_dyn_inits[self.name])
430 value = method()
430 value = method()
431 # FIXME: Do we really validate here?
431 # FIXME: Do we really validate here?
432 value = self._validate(obj, value)
432 value = self._validate(obj, value)
433 obj._trait_values[self.name] = value
433 obj._trait_values[self.name] = value
434 return value
434 return value
435 else:
435 else:
436 return self.init_default_value(obj)
436 return self.init_default_value(obj)
437 except Exception:
437 except Exception:
438 # HasTraits should call set_default_value to populate
438 # HasTraits should call set_default_value to populate
439 # this. So this should never be reached.
439 # this. So this should never be reached.
440 raise TraitError('Unexpected error in TraitType: '
440 raise TraitError('Unexpected error in TraitType: '
441 'default value not set properly')
441 'default value not set properly')
442 else:
442 else:
443 return value
443 return value
444
444
445 def __set__(self, obj, value):
445 def __set__(self, obj, value):
446 new_value = self._validate(obj, value)
446 new_value = self._validate(obj, value)
447 try:
447 try:
448 old_value = obj._trait_values[self.name]
448 old_value = obj._trait_values[self.name]
449 except KeyError:
449 except KeyError:
450 old_value = Undefined
450 old_value = Undefined
451
451
452 obj._trait_values[self.name] = new_value
452 obj._trait_values[self.name] = new_value
453 try:
453 try:
454 silent = bool(old_value == new_value)
454 silent = bool(old_value == new_value)
455 except:
455 except:
456 # if there is an error in comparing, default to notify
456 # if there is an error in comparing, default to notify
457 silent = False
457 silent = False
458 if silent is not True:
458 if silent is not True:
459 # we explicitly compare silent to True just in case the equality
459 # we explicitly compare silent to True just in case the equality
460 # comparison above returns something other than True/False
460 # comparison above returns something other than True/False
461 obj._notify_trait(self.name, old_value, new_value)
461 obj._notify_trait(self.name, old_value, new_value)
462
462
463 def _validate(self, obj, value):
463 def _validate(self, obj, value):
464 if value is None and self.allow_none:
464 if value is None and self.allow_none:
465 return value
465 return value
466 if hasattr(self, 'validate'):
466 if hasattr(self, 'validate'):
467 value = self.validate(obj, value)
467 value = self.validate(obj, value)
468 if obj._cross_validation_lock is False:
468 if obj._cross_validation_lock is False:
469 value = self._cross_validate(obj, value)
469 value = self._cross_validate(obj, value)
470 return value
470 return value
471
471
472 def _cross_validate(self, obj, value):
472 def _cross_validate(self, obj, value):
473 if hasattr(obj, '_%s_validate' % self.name):
473 if hasattr(obj, '_%s_validate' % self.name):
474 cross_validate = getattr(obj, '_%s_validate' % self.name)
474 cross_validate = getattr(obj, '_%s_validate' % self.name)
475 value = cross_validate(value, self)
475 value = cross_validate(value, self)
476 return value
476 return value
477
477
478 def __or__(self, other):
478 def __or__(self, other):
479 if isinstance(other, Union):
479 if isinstance(other, Union):
480 return Union([self] + other.trait_types)
480 return Union([self] + other.trait_types)
481 else:
481 else:
482 return Union([self, other])
482 return Union([self, other])
483
483
484 def info(self):
484 def info(self):
485 return self.info_text
485 return self.info_text
486
486
487 def error(self, obj, value):
487 def error(self, obj, value):
488 if obj is not None:
488 if obj is not None:
489 e = "The '%s' trait of %s instance must be %s, but a value of %s was specified." \
489 e = "The '%s' trait of %s instance must be %s, but a value of %s was specified." \
490 % (self.name, class_of(obj),
490 % (self.name, class_of(obj),
491 self.info(), repr_type(value))
491 self.info(), repr_type(value))
492 else:
492 else:
493 e = "The '%s' trait must be %s, but a value of %r was specified." \
493 e = "The '%s' trait must be %s, but a value of %r was specified." \
494 % (self.name, self.info(), repr_type(value))
494 % (self.name, self.info(), repr_type(value))
495 raise TraitError(e)
495 raise TraitError(e)
496
496
497 def get_metadata(self, key, default=None):
497 def get_metadata(self, key, default=None):
498 return getattr(self, '_metadata', {}).get(key, default)
498 return getattr(self, '_metadata', {}).get(key, default)
499
499
500 def set_metadata(self, key, value):
500 def set_metadata(self, key, value):
501 getattr(self, '_metadata', {})[key] = value
501 getattr(self, '_metadata', {})[key] = value
502
502
503
503
504 #-----------------------------------------------------------------------------
504 #-----------------------------------------------------------------------------
505 # The HasTraits implementation
505 # The HasTraits implementation
506 #-----------------------------------------------------------------------------
506 #-----------------------------------------------------------------------------
507
507
508
508
509 class MetaHasTraits(type):
509 class MetaHasTraits(type):
510 """A metaclass for HasTraits.
510 """A metaclass for HasTraits.
511
511
512 This metaclass makes sure that any TraitType class attributes are
512 This metaclass makes sure that any TraitType class attributes are
513 instantiated and sets their name attribute.
513 instantiated and sets their name attribute.
514 """
514 """
515
515
516 def __new__(mcls, name, bases, classdict):
516 def __new__(mcls, name, bases, classdict):
517 """Create the HasTraits class.
517 """Create the HasTraits class.
518
518
519 This instantiates all TraitTypes in the class dict and sets their
519 This instantiates all TraitTypes in the class dict and sets their
520 :attr:`name` attribute.
520 :attr:`name` attribute.
521 """
521 """
522 # print "MetaHasTraitlets (mcls, name): ", mcls, name
522 # print "MetaHasTraitlets (mcls, name): ", mcls, name
523 # print "MetaHasTraitlets (bases): ", bases
523 # print "MetaHasTraitlets (bases): ", bases
524 # print "MetaHasTraitlets (classdict): ", classdict
524 # print "MetaHasTraitlets (classdict): ", classdict
525 for k,v in iteritems(classdict):
525 for k,v in iteritems(classdict):
526 if isinstance(v, TraitType):
526 if isinstance(v, TraitType):
527 v.name = k
527 v.name = k
528 elif inspect.isclass(v):
528 elif inspect.isclass(v):
529 if issubclass(v, TraitType):
529 if issubclass(v, TraitType):
530 vinst = v()
530 vinst = v()
531 vinst.name = k
531 vinst.name = k
532 classdict[k] = vinst
532 classdict[k] = vinst
533 return super(MetaHasTraits, mcls).__new__(mcls, name, bases, classdict)
533 return super(MetaHasTraits, mcls).__new__(mcls, name, bases, classdict)
534
534
535 def __init__(cls, name, bases, classdict):
535 def __init__(cls, name, bases, classdict):
536 """Finish initializing the HasTraits class.
536 """Finish initializing the HasTraits class.
537
537
538 This sets the :attr:`this_class` attribute of each TraitType in the
538 This sets the :attr:`this_class` attribute of each TraitType in the
539 class dict to the newly created class ``cls``.
539 class dict to the newly created class ``cls``.
540 """
540 """
541 for k, v in iteritems(classdict):
541 for k, v in iteritems(classdict):
542 if isinstance(v, TraitType):
542 if isinstance(v, TraitType):
543 v.this_class = cls
543 v.this_class = cls
544 super(MetaHasTraits, cls).__init__(name, bases, classdict)
544 super(MetaHasTraits, cls).__init__(name, bases, classdict)
545
545
546
546
547 class HasTraits(py3compat.with_metaclass(MetaHasTraits, object)):
547 class HasTraits(py3compat.with_metaclass(MetaHasTraits, object)):
548
548
549 def __new__(cls, *args, **kw):
549 def __new__(cls, *args, **kw):
550 # This is needed because object.__new__ only accepts
550 # This is needed because object.__new__ only accepts
551 # the cls argument.
551 # the cls argument.
552 new_meth = super(HasTraits, cls).__new__
552 new_meth = super(HasTraits, cls).__new__
553 if new_meth is object.__new__:
553 if new_meth is object.__new__:
554 inst = new_meth(cls)
554 inst = new_meth(cls)
555 else:
555 else:
556 inst = new_meth(cls, **kw)
556 inst = new_meth(cls, **kw)
557 inst._trait_values = {}
557 inst._trait_values = {}
558 inst._trait_notifiers = {}
558 inst._trait_notifiers = {}
559 inst._trait_dyn_inits = {}
559 inst._trait_dyn_inits = {}
560 inst._cross_validation_lock = True
560 inst._cross_validation_lock = True
561 # Here we tell all the TraitType instances to set their default
561 # Here we tell all the TraitType instances to set their default
562 # values on the instance.
562 # values on the instance.
563 for key in dir(cls):
563 for key in dir(cls):
564 # Some descriptors raise AttributeError like zope.interface's
564 # Some descriptors raise AttributeError like zope.interface's
565 # __provides__ attributes even though they exist. This causes
565 # __provides__ attributes even though they exist. This causes
566 # AttributeErrors even though they are listed in dir(cls).
566 # AttributeErrors even though they are listed in dir(cls).
567 try:
567 try:
568 value = getattr(cls, key)
568 value = getattr(cls, key)
569 except AttributeError:
569 except AttributeError:
570 pass
570 pass
571 else:
571 else:
572 if isinstance(value, TraitType):
572 if isinstance(value, TraitType):
573 value.instance_init()
573 value.instance_init()
574 if key not in kw:
574 if key not in kw:
575 value.set_default_value(inst)
575 value.set_default_value(inst)
576 inst._cross_validation_lock = False
576 inst._cross_validation_lock = False
577 return inst
577 return inst
578
578
579 def __init__(self, *args, **kw):
579 def __init__(self, *args, **kw):
580 # Allow trait values to be set using keyword arguments.
580 # Allow trait values to be set using keyword arguments.
581 # We need to use setattr for this to trigger validation and
581 # We need to use setattr for this to trigger validation and
582 # notifications.
582 # notifications.
583 with self.hold_trait_notifications():
583 with self.hold_trait_notifications():
584 for key, value in iteritems(kw):
584 for key, value in iteritems(kw):
585 setattr(self, key, value)
585 setattr(self, key, value)
586
586
587 @contextlib.contextmanager
587 @contextlib.contextmanager
588 def hold_trait_notifications(self):
588 def hold_trait_notifications(self):
589 """Context manager for bundling trait change notifications and cross
589 """Context manager for bundling trait change notifications and cross
590 validation.
590 validation.
591
591
592 Use this when doing multiple trait assignments (init, config), to avoid
592 Use this when doing multiple trait assignments (init, config), to avoid
593 race conditions in trait notifiers requesting other trait values.
593 race conditions in trait notifiers requesting other trait values.
594 All trait notifications will fire after all values have been assigned.
594 All trait notifications will fire after all values have been assigned.
595 """
595 """
596 if self._cross_validation_lock is True:
596 if self._cross_validation_lock is True:
597 yield
597 yield
598 return
598 return
599 else:
599 else:
600 self._cross_validation_lock = True
601 cache = {}
600 cache = {}
602 notifications = {}
603 _notify_trait = self._notify_trait
601 _notify_trait = self._notify_trait
604
602
605 def cache_values(*a):
603 def merge(previous, current):
606 cache[a[0]] = a
604 """merges notifications of the form (name, old, value)"""
607
605 if previous is None:
608 def hold_notifications(*a):
606 return current
609 notifications[a[0]] = a
607 else:
608 return (current[0], previous[1], current[2])
610
609
611 self._notify_trait = cache_values
610 def hold(*a):
611 cache[a[0]] = merge(cache.get(a[0]), a)
612
612
613 try:
613 try:
614 self._notify_trait = hold
615 self._cross_validation_lock = True
614 yield
616 yield
615 finally:
616 try:
617 self._notify_trait = hold_notifications
618 for name in cache:
617 for name in cache:
619 if hasattr(self, '_%s_validate' % name):
618 if hasattr(self, '_%s_validate' % name):
620 cross_validate = getattr(self, '_%s_validate' % name)
619 cross_validate = getattr(self, '_%s_validate' % name)
621 setattr(self, name, cross_validate(getattr(self, name), self))
620 setattr(self, name, cross_validate(getattr(self, name), self))
622 except TraitError as e:
621 except TraitError as e:
623 self._notify_trait = lambda *x: None
622 self._notify_trait = lambda *x: None
624 for name in cache:
623 for name in cache:
625 if cache[name][1] is not Undefined:
624 if cache[name][1] is not Undefined:
626 setattr(self, name, cache[name][1])
625 setattr(self, name, cache[name][1])
627 else:
626 else:
628 delattr(self, name)
627 delattr(self, name)
629 cache = {}
628 cache = {}
630 notifications = {}
631 raise e
629 raise e
632 finally:
630 finally:
633 self._notify_trait = _notify_trait
631 self._notify_trait = _notify_trait
634 self._cross_validation_lock = False
632 self._cross_validation_lock = False
635 if isinstance(_notify_trait, types.MethodType):
633 if isinstance(_notify_trait, types.MethodType):
636 # FIXME: remove when support is bumped to 3.4.
634 # FIXME: remove when support is bumped to 3.4.
637 # when original method is restored,
635 # when original method is restored,
638 # remove the redundant value from __dict__
636 # remove the redundant value from __dict__
639 # (only used to preserve pickleability on Python < 3.4)
637 # (only used to preserve pickleability on Python < 3.4)
640 self.__dict__.pop('_notify_trait', None)
638 self.__dict__.pop('_notify_trait', None)
639
641 # trigger delayed notifications
640 # trigger delayed notifications
642 for v in dict(cache, **notifications).values():
641 for v in cache.values():
643 self._notify_trait(*v)
642 self._notify_trait(*v)
644
643
645 def _notify_trait(self, name, old_value, new_value):
644 def _notify_trait(self, name, old_value, new_value):
646
645
647 # First dynamic ones
646 # First dynamic ones
648 callables = []
647 callables = []
649 callables.extend(self._trait_notifiers.get(name,[]))
648 callables.extend(self._trait_notifiers.get(name,[]))
650 callables.extend(self._trait_notifiers.get('anytrait',[]))
649 callables.extend(self._trait_notifiers.get('anytrait',[]))
651
650
652 # Now static ones
651 # Now static ones
653 try:
652 try:
654 cb = getattr(self, '_%s_changed' % name)
653 cb = getattr(self, '_%s_changed' % name)
655 except:
654 except:
656 pass
655 pass
657 else:
656 else:
658 callables.append(cb)
657 callables.append(cb)
659
658
660 # Call them all now
659 # Call them all now
661 for c in callables:
660 for c in callables:
662 # Traits catches and logs errors here. I allow them to raise
661 # Traits catches and logs errors here. I allow them to raise
663 if callable(c):
662 if callable(c):
664 argspec = getargspec(c)
663 argspec = getargspec(c)
665
664
666 nargs = len(argspec[0])
665 nargs = len(argspec[0])
667 # Bound methods have an additional 'self' argument
666 # Bound methods have an additional 'self' argument
668 # I don't know how to treat unbound methods, but they
667 # I don't know how to treat unbound methods, but they
669 # can't really be used for callbacks.
668 # can't really be used for callbacks.
670 if isinstance(c, types.MethodType):
669 if isinstance(c, types.MethodType):
671 offset = -1
670 offset = -1
672 else:
671 else:
673 offset = 0
672 offset = 0
674 if nargs + offset == 0:
673 if nargs + offset == 0:
675 c()
674 c()
676 elif nargs + offset == 1:
675 elif nargs + offset == 1:
677 c(name)
676 c(name)
678 elif nargs + offset == 2:
677 elif nargs + offset == 2:
679 c(name, new_value)
678 c(name, new_value)
680 elif nargs + offset == 3:
679 elif nargs + offset == 3:
681 c(name, old_value, new_value)
680 c(name, old_value, new_value)
682 else:
681 else:
683 raise TraitError('a trait changed callback '
682 raise TraitError('a trait changed callback '
684 'must have 0-3 arguments.')
683 'must have 0-3 arguments.')
685 else:
684 else:
686 raise TraitError('a trait changed callback '
685 raise TraitError('a trait changed callback '
687 'must be callable.')
686 'must be callable.')
688
687
689
688
690 def _add_notifiers(self, handler, name):
689 def _add_notifiers(self, handler, name):
691 if name not in self._trait_notifiers:
690 if name not in self._trait_notifiers:
692 nlist = []
691 nlist = []
693 self._trait_notifiers[name] = nlist
692 self._trait_notifiers[name] = nlist
694 else:
693 else:
695 nlist = self._trait_notifiers[name]
694 nlist = self._trait_notifiers[name]
696 if handler not in nlist:
695 if handler not in nlist:
697 nlist.append(handler)
696 nlist.append(handler)
698
697
699 def _remove_notifiers(self, handler, name):
698 def _remove_notifiers(self, handler, name):
700 if name in self._trait_notifiers:
699 if name in self._trait_notifiers:
701 nlist = self._trait_notifiers[name]
700 nlist = self._trait_notifiers[name]
702 try:
701 try:
703 index = nlist.index(handler)
702 index = nlist.index(handler)
704 except ValueError:
703 except ValueError:
705 pass
704 pass
706 else:
705 else:
707 del nlist[index]
706 del nlist[index]
708
707
709 def on_trait_change(self, handler, name=None, remove=False):
708 def on_trait_change(self, handler, name=None, remove=False):
710 """Setup a handler to be called when a trait changes.
709 """Setup a handler to be called when a trait changes.
711
710
712 This is used to setup dynamic notifications of trait changes.
711 This is used to setup dynamic notifications of trait changes.
713
712
714 Static handlers can be created by creating methods on a HasTraits
713 Static handlers can be created by creating methods on a HasTraits
715 subclass with the naming convention '_[traitname]_changed'. Thus,
714 subclass with the naming convention '_[traitname]_changed'. Thus,
716 to create static handler for the trait 'a', create the method
715 to create static handler for the trait 'a', create the method
717 _a_changed(self, name, old, new) (fewer arguments can be used, see
716 _a_changed(self, name, old, new) (fewer arguments can be used, see
718 below).
717 below).
719
718
720 Parameters
719 Parameters
721 ----------
720 ----------
722 handler : callable
721 handler : callable
723 A callable that is called when a trait changes. Its
722 A callable that is called when a trait changes. Its
724 signature can be handler(), handler(name), handler(name, new)
723 signature can be handler(), handler(name), handler(name, new)
725 or handler(name, old, new).
724 or handler(name, old, new).
726 name : list, str, None
725 name : list, str, None
727 If None, the handler will apply to all traits. If a list
726 If None, the handler will apply to all traits. If a list
728 of str, handler will apply to all names in the list. If a
727 of str, handler will apply to all names in the list. If a
729 str, the handler will apply just to that name.
728 str, the handler will apply just to that name.
730 remove : bool
729 remove : bool
731 If False (the default), then install the handler. If True
730 If False (the default), then install the handler. If True
732 then unintall it.
731 then unintall it.
733 """
732 """
734 if remove:
733 if remove:
735 names = parse_notifier_name(name)
734 names = parse_notifier_name(name)
736 for n in names:
735 for n in names:
737 self._remove_notifiers(handler, n)
736 self._remove_notifiers(handler, n)
738 else:
737 else:
739 names = parse_notifier_name(name)
738 names = parse_notifier_name(name)
740 for n in names:
739 for n in names:
741 self._add_notifiers(handler, n)
740 self._add_notifiers(handler, n)
742
741
743 @classmethod
742 @classmethod
744 def class_trait_names(cls, **metadata):
743 def class_trait_names(cls, **metadata):
745 """Get a list of all the names of this class' traits.
744 """Get a list of all the names of this class' traits.
746
745
747 This method is just like the :meth:`trait_names` method,
746 This method is just like the :meth:`trait_names` method,
748 but is unbound.
747 but is unbound.
749 """
748 """
750 return cls.class_traits(**metadata).keys()
749 return cls.class_traits(**metadata).keys()
751
750
752 @classmethod
751 @classmethod
753 def class_traits(cls, **metadata):
752 def class_traits(cls, **metadata):
754 """Get a `dict` of all the traits of this class. The dictionary
753 """Get a `dict` of all the traits of this class. The dictionary
755 is keyed on the name and the values are the TraitType objects.
754 is keyed on the name and the values are the TraitType objects.
756
755
757 This method is just like the :meth:`traits` method, but is unbound.
756 This method is just like the :meth:`traits` method, but is unbound.
758
757
759 The TraitTypes returned don't know anything about the values
758 The TraitTypes returned don't know anything about the values
760 that the various HasTrait's instances are holding.
759 that the various HasTrait's instances are holding.
761
760
762 The metadata kwargs allow functions to be passed in which
761 The metadata kwargs allow functions to be passed in which
763 filter traits based on metadata values. The functions should
762 filter traits based on metadata values. The functions should
764 take a single value as an argument and return a boolean. If
763 take a single value as an argument and return a boolean. If
765 any function returns False, then the trait is not included in
764 any function returns False, then the trait is not included in
766 the output. This does not allow for any simple way of
765 the output. This does not allow for any simple way of
767 testing that a metadata name exists and has any
766 testing that a metadata name exists and has any
768 value because get_metadata returns None if a metadata key
767 value because get_metadata returns None if a metadata key
769 doesn't exist.
768 doesn't exist.
770 """
769 """
771 traits = dict([memb for memb in getmembers(cls) if
770 traits = dict([memb for memb in getmembers(cls) if
772 isinstance(memb[1], TraitType)])
771 isinstance(memb[1], TraitType)])
773
772
774 if len(metadata) == 0:
773 if len(metadata) == 0:
775 return traits
774 return traits
776
775
777 for meta_name, meta_eval in metadata.items():
776 for meta_name, meta_eval in metadata.items():
778 if type(meta_eval) is not FunctionType:
777 if type(meta_eval) is not FunctionType:
779 metadata[meta_name] = _SimpleTest(meta_eval)
778 metadata[meta_name] = _SimpleTest(meta_eval)
780
779
781 result = {}
780 result = {}
782 for name, trait in traits.items():
781 for name, trait in traits.items():
783 for meta_name, meta_eval in metadata.items():
782 for meta_name, meta_eval in metadata.items():
784 if not meta_eval(trait.get_metadata(meta_name)):
783 if not meta_eval(trait.get_metadata(meta_name)):
785 break
784 break
786 else:
785 else:
787 result[name] = trait
786 result[name] = trait
788
787
789 return result
788 return result
790
789
791 def trait_names(self, **metadata):
790 def trait_names(self, **metadata):
792 """Get a list of all the names of this class' traits."""
791 """Get a list of all the names of this class' traits."""
793 return self.traits(**metadata).keys()
792 return self.traits(**metadata).keys()
794
793
795 def traits(self, **metadata):
794 def traits(self, **metadata):
796 """Get a `dict` of all the traits of this class. The dictionary
795 """Get a `dict` of all the traits of this class. The dictionary
797 is keyed on the name and the values are the TraitType objects.
796 is keyed on the name and the values are the TraitType objects.
798
797
799 The TraitTypes returned don't know anything about the values
798 The TraitTypes returned don't know anything about the values
800 that the various HasTrait's instances are holding.
799 that the various HasTrait's instances are holding.
801
800
802 The metadata kwargs allow functions to be passed in which
801 The metadata kwargs allow functions to be passed in which
803 filter traits based on metadata values. The functions should
802 filter traits based on metadata values. The functions should
804 take a single value as an argument and return a boolean. If
803 take a single value as an argument and return a boolean. If
805 any function returns False, then the trait is not included in
804 any function returns False, then the trait is not included in
806 the output. This does not allow for any simple way of
805 the output. This does not allow for any simple way of
807 testing that a metadata name exists and has any
806 testing that a metadata name exists and has any
808 value because get_metadata returns None if a metadata key
807 value because get_metadata returns None if a metadata key
809 doesn't exist.
808 doesn't exist.
810 """
809 """
811 traits = dict([memb for memb in getmembers(self.__class__) if
810 traits = dict([memb for memb in getmembers(self.__class__) if
812 isinstance(memb[1], TraitType)])
811 isinstance(memb[1], TraitType)])
813
812
814 if len(metadata) == 0:
813 if len(metadata) == 0:
815 return traits
814 return traits
816
815
817 for meta_name, meta_eval in metadata.items():
816 for meta_name, meta_eval in metadata.items():
818 if type(meta_eval) is not FunctionType:
817 if type(meta_eval) is not FunctionType:
819 metadata[meta_name] = _SimpleTest(meta_eval)
818 metadata[meta_name] = _SimpleTest(meta_eval)
820
819
821 result = {}
820 result = {}
822 for name, trait in traits.items():
821 for name, trait in traits.items():
823 for meta_name, meta_eval in metadata.items():
822 for meta_name, meta_eval in metadata.items():
824 if not meta_eval(trait.get_metadata(meta_name)):
823 if not meta_eval(trait.get_metadata(meta_name)):
825 break
824 break
826 else:
825 else:
827 result[name] = trait
826 result[name] = trait
828
827
829 return result
828 return result
830
829
831 def trait_metadata(self, traitname, key, default=None):
830 def trait_metadata(self, traitname, key, default=None):
832 """Get metadata values for trait by key."""
831 """Get metadata values for trait by key."""
833 try:
832 try:
834 trait = getattr(self.__class__, traitname)
833 trait = getattr(self.__class__, traitname)
835 except AttributeError:
834 except AttributeError:
836 raise TraitError("Class %s does not have a trait named %s" %
835 raise TraitError("Class %s does not have a trait named %s" %
837 (self.__class__.__name__, traitname))
836 (self.__class__.__name__, traitname))
838 else:
837 else:
839 return trait.get_metadata(key, default)
838 return trait.get_metadata(key, default)
840
839
841 def add_trait(self, traitname, trait):
840 def add_trait(self, traitname, trait):
842 """Dynamically add a trait attribute to the HasTraits instance."""
841 """Dynamically add a trait attribute to the HasTraits instance."""
843 self.__class__ = type(self.__class__.__name__, (self.__class__,),
842 self.__class__ = type(self.__class__.__name__, (self.__class__,),
844 {traitname: trait})
843 {traitname: trait})
845 trait.set_default_value(self)
844 trait.set_default_value(self)
846
845
847 #-----------------------------------------------------------------------------
846 #-----------------------------------------------------------------------------
848 # Actual TraitTypes implementations/subclasses
847 # Actual TraitTypes implementations/subclasses
849 #-----------------------------------------------------------------------------
848 #-----------------------------------------------------------------------------
850
849
851 #-----------------------------------------------------------------------------
850 #-----------------------------------------------------------------------------
852 # TraitTypes subclasses for handling classes and instances of classes
851 # TraitTypes subclasses for handling classes and instances of classes
853 #-----------------------------------------------------------------------------
852 #-----------------------------------------------------------------------------
854
853
855
854
856 class ClassBasedTraitType(TraitType):
855 class ClassBasedTraitType(TraitType):
857 """
856 """
858 A trait with error reporting and string -> type resolution for Type,
857 A trait with error reporting and string -> type resolution for Type,
859 Instance and This.
858 Instance and This.
860 """
859 """
861
860
862 def _resolve_string(self, string):
861 def _resolve_string(self, string):
863 """
862 """
864 Resolve a string supplied for a type into an actual object.
863 Resolve a string supplied for a type into an actual object.
865 """
864 """
866 return import_item(string)
865 return import_item(string)
867
866
868 def error(self, obj, value):
867 def error(self, obj, value):
869 kind = type(value)
868 kind = type(value)
870 if (not py3compat.PY3) and kind is InstanceType:
869 if (not py3compat.PY3) and kind is InstanceType:
871 msg = 'class %s' % value.__class__.__name__
870 msg = 'class %s' % value.__class__.__name__
872 else:
871 else:
873 msg = '%s (i.e. %s)' % ( str( kind )[1:-1], repr( value ) )
872 msg = '%s (i.e. %s)' % ( str( kind )[1:-1], repr( value ) )
874
873
875 if obj is not None:
874 if obj is not None:
876 e = "The '%s' trait of %s instance must be %s, but a value of %s was specified." \
875 e = "The '%s' trait of %s instance must be %s, but a value of %s was specified." \
877 % (self.name, class_of(obj),
876 % (self.name, class_of(obj),
878 self.info(), msg)
877 self.info(), msg)
879 else:
878 else:
880 e = "The '%s' trait must be %s, but a value of %r was specified." \
879 e = "The '%s' trait must be %s, but a value of %r was specified." \
881 % (self.name, self.info(), msg)
880 % (self.name, self.info(), msg)
882
881
883 raise TraitError(e)
882 raise TraitError(e)
884
883
885
884
886 class Type(ClassBasedTraitType):
885 class Type(ClassBasedTraitType):
887 """A trait whose value must be a subclass of a specified class."""
886 """A trait whose value must be a subclass of a specified class."""
888
887
889 def __init__ (self, default_value=None, klass=None, allow_none=False,
888 def __init__ (self, default_value=None, klass=None, allow_none=False,
890 **metadata):
889 **metadata):
891 """Construct a Type trait
890 """Construct a Type trait
892
891
893 A Type trait specifies that its values must be subclasses of
892 A Type trait specifies that its values must be subclasses of
894 a particular class.
893 a particular class.
895
894
896 If only ``default_value`` is given, it is used for the ``klass`` as
895 If only ``default_value`` is given, it is used for the ``klass`` as
897 well.
896 well.
898
897
899 Parameters
898 Parameters
900 ----------
899 ----------
901 default_value : class, str or None
900 default_value : class, str or None
902 The default value must be a subclass of klass. If an str,
901 The default value must be a subclass of klass. If an str,
903 the str must be a fully specified class name, like 'foo.bar.Bah'.
902 the str must be a fully specified class name, like 'foo.bar.Bah'.
904 The string is resolved into real class, when the parent
903 The string is resolved into real class, when the parent
905 :class:`HasTraits` class is instantiated.
904 :class:`HasTraits` class is instantiated.
906 klass : class, str, None
905 klass : class, str, None
907 Values of this trait must be a subclass of klass. The klass
906 Values of this trait must be a subclass of klass. The klass
908 may be specified in a string like: 'foo.bar.MyClass'.
907 may be specified in a string like: 'foo.bar.MyClass'.
909 The string is resolved into real class, when the parent
908 The string is resolved into real class, when the parent
910 :class:`HasTraits` class is instantiated.
909 :class:`HasTraits` class is instantiated.
911 allow_none : bool [ default True ]
910 allow_none : bool [ default True ]
912 Indicates whether None is allowed as an assignable value. Even if
911 Indicates whether None is allowed as an assignable value. Even if
913 ``False``, the default value may be ``None``.
912 ``False``, the default value may be ``None``.
914 """
913 """
915 if default_value is None:
914 if default_value is None:
916 if klass is None:
915 if klass is None:
917 klass = object
916 klass = object
918 elif klass is None:
917 elif klass is None:
919 klass = default_value
918 klass = default_value
920
919
921 if not (inspect.isclass(klass) or isinstance(klass, py3compat.string_types)):
920 if not (inspect.isclass(klass) or isinstance(klass, py3compat.string_types)):
922 raise TraitError("A Type trait must specify a class.")
921 raise TraitError("A Type trait must specify a class.")
923
922
924 self.klass = klass
923 self.klass = klass
925
924
926 super(Type, self).__init__(default_value, allow_none=allow_none, **metadata)
925 super(Type, self).__init__(default_value, allow_none=allow_none, **metadata)
927
926
928 def validate(self, obj, value):
927 def validate(self, obj, value):
929 """Validates that the value is a valid object instance."""
928 """Validates that the value is a valid object instance."""
930 if isinstance(value, py3compat.string_types):
929 if isinstance(value, py3compat.string_types):
931 try:
930 try:
932 value = self._resolve_string(value)
931 value = self._resolve_string(value)
933 except ImportError:
932 except ImportError:
934 raise TraitError("The '%s' trait of %s instance must be a type, but "
933 raise TraitError("The '%s' trait of %s instance must be a type, but "
935 "%r could not be imported" % (self.name, obj, value))
934 "%r could not be imported" % (self.name, obj, value))
936 try:
935 try:
937 if issubclass(value, self.klass):
936 if issubclass(value, self.klass):
938 return value
937 return value
939 except:
938 except:
940 pass
939 pass
941
940
942 self.error(obj, value)
941 self.error(obj, value)
943
942
944 def info(self):
943 def info(self):
945 """ Returns a description of the trait."""
944 """ Returns a description of the trait."""
946 if isinstance(self.klass, py3compat.string_types):
945 if isinstance(self.klass, py3compat.string_types):
947 klass = self.klass
946 klass = self.klass
948 else:
947 else:
949 klass = self.klass.__name__
948 klass = self.klass.__name__
950 result = 'a subclass of ' + klass
949 result = 'a subclass of ' + klass
951 if self.allow_none:
950 if self.allow_none:
952 return result + ' or None'
951 return result + ' or None'
953 return result
952 return result
954
953
955 def instance_init(self):
954 def instance_init(self):
956 self._resolve_classes()
955 self._resolve_classes()
957 super(Type, self).instance_init()
956 super(Type, self).instance_init()
958
957
959 def _resolve_classes(self):
958 def _resolve_classes(self):
960 if isinstance(self.klass, py3compat.string_types):
959 if isinstance(self.klass, py3compat.string_types):
961 self.klass = self._resolve_string(self.klass)
960 self.klass = self._resolve_string(self.klass)
962 if isinstance(self.default_value, py3compat.string_types):
961 if isinstance(self.default_value, py3compat.string_types):
963 self.default_value = self._resolve_string(self.default_value)
962 self.default_value = self._resolve_string(self.default_value)
964
963
965 def get_default_value(self):
964 def get_default_value(self):
966 return self.default_value
965 return self.default_value
967
966
968
967
969 class DefaultValueGenerator(object):
968 class DefaultValueGenerator(object):
970 """A class for generating new default value instances."""
969 """A class for generating new default value instances."""
971
970
972 def __init__(self, *args, **kw):
971 def __init__(self, *args, **kw):
973 self.args = args
972 self.args = args
974 self.kw = kw
973 self.kw = kw
975
974
976 def generate(self, klass):
975 def generate(self, klass):
977 return klass(*self.args, **self.kw)
976 return klass(*self.args, **self.kw)
978
977
979
978
980 class Instance(ClassBasedTraitType):
979 class Instance(ClassBasedTraitType):
981 """A trait whose value must be an instance of a specified class.
980 """A trait whose value must be an instance of a specified class.
982
981
983 The value can also be an instance of a subclass of the specified class.
982 The value can also be an instance of a subclass of the specified class.
984
983
985 Subclasses can declare default classes by overriding the klass attribute
984 Subclasses can declare default classes by overriding the klass attribute
986 """
985 """
987
986
988 klass = None
987 klass = None
989
988
990 def __init__(self, klass=None, args=None, kw=None, allow_none=False,
989 def __init__(self, klass=None, args=None, kw=None, allow_none=False,
991 **metadata ):
990 **metadata ):
992 """Construct an Instance trait.
991 """Construct an Instance trait.
993
992
994 This trait allows values that are instances of a particular
993 This trait allows values that are instances of a particular
995 class or its subclasses. Our implementation is quite different
994 class or its subclasses. Our implementation is quite different
996 from that of enthough.traits as we don't allow instances to be used
995 from that of enthough.traits as we don't allow instances to be used
997 for klass and we handle the ``args`` and ``kw`` arguments differently.
996 for klass and we handle the ``args`` and ``kw`` arguments differently.
998
997
999 Parameters
998 Parameters
1000 ----------
999 ----------
1001 klass : class, str
1000 klass : class, str
1002 The class that forms the basis for the trait. Class names
1001 The class that forms the basis for the trait. Class names
1003 can also be specified as strings, like 'foo.bar.Bar'.
1002 can also be specified as strings, like 'foo.bar.Bar'.
1004 args : tuple
1003 args : tuple
1005 Positional arguments for generating the default value.
1004 Positional arguments for generating the default value.
1006 kw : dict
1005 kw : dict
1007 Keyword arguments for generating the default value.
1006 Keyword arguments for generating the default value.
1008 allow_none : bool [default True]
1007 allow_none : bool [default True]
1009 Indicates whether None is allowed as a value.
1008 Indicates whether None is allowed as a value.
1010
1009
1011 Notes
1010 Notes
1012 -----
1011 -----
1013 If both ``args`` and ``kw`` are None, then the default value is None.
1012 If both ``args`` and ``kw`` are None, then the default value is None.
1014 If ``args`` is a tuple and ``kw`` is a dict, then the default is
1013 If ``args`` is a tuple and ``kw`` is a dict, then the default is
1015 created as ``klass(*args, **kw)``. If exactly one of ``args`` or ``kw`` is
1014 created as ``klass(*args, **kw)``. If exactly one of ``args`` or ``kw`` is
1016 None, the None is replaced by ``()`` or ``{}``, respectively.
1015 None, the None is replaced by ``()`` or ``{}``, respectively.
1017 """
1016 """
1018 if klass is None:
1017 if klass is None:
1019 klass = self.klass
1018 klass = self.klass
1020
1019
1021 if (klass is not None) and (inspect.isclass(klass) or isinstance(klass, py3compat.string_types)):
1020 if (klass is not None) and (inspect.isclass(klass) or isinstance(klass, py3compat.string_types)):
1022 self.klass = klass
1021 self.klass = klass
1023 else:
1022 else:
1024 raise TraitError('The klass attribute must be a class'
1023 raise TraitError('The klass attribute must be a class'
1025 ' not: %r' % klass)
1024 ' not: %r' % klass)
1026
1025
1027 # self.klass is a class, so handle default_value
1026 # self.klass is a class, so handle default_value
1028 if args is None and kw is None:
1027 if args is None and kw is None:
1029 default_value = None
1028 default_value = None
1030 else:
1029 else:
1031 if args is None:
1030 if args is None:
1032 # kw is not None
1031 # kw is not None
1033 args = ()
1032 args = ()
1034 elif kw is None:
1033 elif kw is None:
1035 # args is not None
1034 # args is not None
1036 kw = {}
1035 kw = {}
1037
1036
1038 if not isinstance(kw, dict):
1037 if not isinstance(kw, dict):
1039 raise TraitError("The 'kw' argument must be a dict or None.")
1038 raise TraitError("The 'kw' argument must be a dict or None.")
1040 if not isinstance(args, tuple):
1039 if not isinstance(args, tuple):
1041 raise TraitError("The 'args' argument must be a tuple or None.")
1040 raise TraitError("The 'args' argument must be a tuple or None.")
1042
1041
1043 default_value = DefaultValueGenerator(*args, **kw)
1042 default_value = DefaultValueGenerator(*args, **kw)
1044
1043
1045 super(Instance, self).__init__(default_value, allow_none=allow_none, **metadata)
1044 super(Instance, self).__init__(default_value, allow_none=allow_none, **metadata)
1046
1045
1047 def validate(self, obj, value):
1046 def validate(self, obj, value):
1048 if isinstance(value, self.klass):
1047 if isinstance(value, self.klass):
1049 return value
1048 return value
1050 else:
1049 else:
1051 self.error(obj, value)
1050 self.error(obj, value)
1052
1051
1053 def info(self):
1052 def info(self):
1054 if isinstance(self.klass, py3compat.string_types):
1053 if isinstance(self.klass, py3compat.string_types):
1055 klass = self.klass
1054 klass = self.klass
1056 else:
1055 else:
1057 klass = self.klass.__name__
1056 klass = self.klass.__name__
1058 result = class_of(klass)
1057 result = class_of(klass)
1059 if self.allow_none:
1058 if self.allow_none:
1060 return result + ' or None'
1059 return result + ' or None'
1061
1060
1062 return result
1061 return result
1063
1062
1064 def instance_init(self):
1063 def instance_init(self):
1065 self._resolve_classes()
1064 self._resolve_classes()
1066 super(Instance, self).instance_init()
1065 super(Instance, self).instance_init()
1067
1066
1068 def _resolve_classes(self):
1067 def _resolve_classes(self):
1069 if isinstance(self.klass, py3compat.string_types):
1068 if isinstance(self.klass, py3compat.string_types):
1070 self.klass = self._resolve_string(self.klass)
1069 self.klass = self._resolve_string(self.klass)
1071
1070
1072 def get_default_value(self):
1071 def get_default_value(self):
1073 """Instantiate a default value instance.
1072 """Instantiate a default value instance.
1074
1073
1075 This is called when the containing HasTraits classes'
1074 This is called when the containing HasTraits classes'
1076 :meth:`__new__` method is called to ensure that a unique instance
1075 :meth:`__new__` method is called to ensure that a unique instance
1077 is created for each HasTraits instance.
1076 is created for each HasTraits instance.
1078 """
1077 """
1079 dv = self.default_value
1078 dv = self.default_value
1080 if isinstance(dv, DefaultValueGenerator):
1079 if isinstance(dv, DefaultValueGenerator):
1081 return dv.generate(self.klass)
1080 return dv.generate(self.klass)
1082 else:
1081 else:
1083 return dv
1082 return dv
1084
1083
1085
1084
1086 class ForwardDeclaredMixin(object):
1085 class ForwardDeclaredMixin(object):
1087 """
1086 """
1088 Mixin for forward-declared versions of Instance and Type.
1087 Mixin for forward-declared versions of Instance and Type.
1089 """
1088 """
1090 def _resolve_string(self, string):
1089 def _resolve_string(self, string):
1091 """
1090 """
1092 Find the specified class name by looking for it in the module in which
1091 Find the specified class name by looking for it in the module in which
1093 our this_class attribute was defined.
1092 our this_class attribute was defined.
1094 """
1093 """
1095 modname = self.this_class.__module__
1094 modname = self.this_class.__module__
1096 return import_item('.'.join([modname, string]))
1095 return import_item('.'.join([modname, string]))
1097
1096
1098
1097
1099 class ForwardDeclaredType(ForwardDeclaredMixin, Type):
1098 class ForwardDeclaredType(ForwardDeclaredMixin, Type):
1100 """
1099 """
1101 Forward-declared version of Type.
1100 Forward-declared version of Type.
1102 """
1101 """
1103 pass
1102 pass
1104
1103
1105
1104
1106 class ForwardDeclaredInstance(ForwardDeclaredMixin, Instance):
1105 class ForwardDeclaredInstance(ForwardDeclaredMixin, Instance):
1107 """
1106 """
1108 Forward-declared version of Instance.
1107 Forward-declared version of Instance.
1109 """
1108 """
1110 pass
1109 pass
1111
1110
1112
1111
1113 class This(ClassBasedTraitType):
1112 class This(ClassBasedTraitType):
1114 """A trait for instances of the class containing this trait.
1113 """A trait for instances of the class containing this trait.
1115
1114
1116 Because how how and when class bodies are executed, the ``This``
1115 Because how how and when class bodies are executed, the ``This``
1117 trait can only have a default value of None. This, and because we
1116 trait can only have a default value of None. This, and because we
1118 always validate default values, ``allow_none`` is *always* true.
1117 always validate default values, ``allow_none`` is *always* true.
1119 """
1118 """
1120
1119
1121 info_text = 'an instance of the same type as the receiver or None'
1120 info_text = 'an instance of the same type as the receiver or None'
1122
1121
1123 def __init__(self, **metadata):
1122 def __init__(self, **metadata):
1124 super(This, self).__init__(None, **metadata)
1123 super(This, self).__init__(None, **metadata)
1125
1124
1126 def validate(self, obj, value):
1125 def validate(self, obj, value):
1127 # What if value is a superclass of obj.__class__? This is
1126 # What if value is a superclass of obj.__class__? This is
1128 # complicated if it was the superclass that defined the This
1127 # complicated if it was the superclass that defined the This
1129 # trait.
1128 # trait.
1130 if isinstance(value, self.this_class) or (value is None):
1129 if isinstance(value, self.this_class) or (value is None):
1131 return value
1130 return value
1132 else:
1131 else:
1133 self.error(obj, value)
1132 self.error(obj, value)
1134
1133
1135
1134
1136 class Union(TraitType):
1135 class Union(TraitType):
1137 """A trait type representing a Union type."""
1136 """A trait type representing a Union type."""
1138
1137
1139 def __init__(self, trait_types, **metadata):
1138 def __init__(self, trait_types, **metadata):
1140 """Construct a Union trait.
1139 """Construct a Union trait.
1141
1140
1142 This trait allows values that are allowed by at least one of the
1141 This trait allows values that are allowed by at least one of the
1143 specified trait types. A Union traitlet cannot have metadata on
1142 specified trait types. A Union traitlet cannot have metadata on
1144 its own, besides the metadata of the listed types.
1143 its own, besides the metadata of the listed types.
1145
1144
1146 Parameters
1145 Parameters
1147 ----------
1146 ----------
1148 trait_types: sequence
1147 trait_types: sequence
1149 The list of trait types of length at least 1.
1148 The list of trait types of length at least 1.
1150
1149
1151 Notes
1150 Notes
1152 -----
1151 -----
1153 Union([Float(), Bool(), Int()]) attempts to validate the provided values
1152 Union([Float(), Bool(), Int()]) attempts to validate the provided values
1154 with the validation function of Float, then Bool, and finally Int.
1153 with the validation function of Float, then Bool, and finally Int.
1155 """
1154 """
1156 self.trait_types = trait_types
1155 self.trait_types = trait_types
1157 self.info_text = " or ".join([tt.info_text for tt in self.trait_types])
1156 self.info_text = " or ".join([tt.info_text for tt in self.trait_types])
1158 self.default_value = self.trait_types[0].get_default_value()
1157 self.default_value = self.trait_types[0].get_default_value()
1159 super(Union, self).__init__(**metadata)
1158 super(Union, self).__init__(**metadata)
1160
1159
1161 def instance_init(self):
1160 def instance_init(self):
1162 for trait_type in self.trait_types:
1161 for trait_type in self.trait_types:
1163 trait_type.name = self.name
1162 trait_type.name = self.name
1164 trait_type.this_class = self.this_class
1163 trait_type.this_class = self.this_class
1165 trait_type.instance_init()
1164 trait_type.instance_init()
1166 super(Union, self).instance_init()
1165 super(Union, self).instance_init()
1167
1166
1168 def validate(self, obj, value):
1167 def validate(self, obj, value):
1169 for trait_type in self.trait_types:
1168 for trait_type in self.trait_types:
1170 try:
1169 try:
1171 v = trait_type._validate(obj, value)
1170 v = trait_type._validate(obj, value)
1172 self._metadata = trait_type._metadata
1171 self._metadata = trait_type._metadata
1173 return v
1172 return v
1174 except TraitError:
1173 except TraitError:
1175 continue
1174 continue
1176 self.error(obj, value)
1175 self.error(obj, value)
1177
1176
1178 def __or__(self, other):
1177 def __or__(self, other):
1179 if isinstance(other, Union):
1178 if isinstance(other, Union):
1180 return Union(self.trait_types + other.trait_types)
1179 return Union(self.trait_types + other.trait_types)
1181 else:
1180 else:
1182 return Union(self.trait_types + [other])
1181 return Union(self.trait_types + [other])
1183
1182
1184 #-----------------------------------------------------------------------------
1183 #-----------------------------------------------------------------------------
1185 # Basic TraitTypes implementations/subclasses
1184 # Basic TraitTypes implementations/subclasses
1186 #-----------------------------------------------------------------------------
1185 #-----------------------------------------------------------------------------
1187
1186
1188
1187
1189 class Any(TraitType):
1188 class Any(TraitType):
1190 default_value = None
1189 default_value = None
1191 info_text = 'any value'
1190 info_text = 'any value'
1192
1191
1193
1192
1194 class Int(TraitType):
1193 class Int(TraitType):
1195 """An int trait."""
1194 """An int trait."""
1196
1195
1197 default_value = 0
1196 default_value = 0
1198 info_text = 'an int'
1197 info_text = 'an int'
1199
1198
1200 def validate(self, obj, value):
1199 def validate(self, obj, value):
1201 if isinstance(value, int):
1200 if isinstance(value, int):
1202 return value
1201 return value
1203 self.error(obj, value)
1202 self.error(obj, value)
1204
1203
1205 class CInt(Int):
1204 class CInt(Int):
1206 """A casting version of the int trait."""
1205 """A casting version of the int trait."""
1207
1206
1208 def validate(self, obj, value):
1207 def validate(self, obj, value):
1209 try:
1208 try:
1210 return int(value)
1209 return int(value)
1211 except:
1210 except:
1212 self.error(obj, value)
1211 self.error(obj, value)
1213
1212
1214 if py3compat.PY3:
1213 if py3compat.PY3:
1215 Long, CLong = Int, CInt
1214 Long, CLong = Int, CInt
1216 Integer = Int
1215 Integer = Int
1217 else:
1216 else:
1218 class Long(TraitType):
1217 class Long(TraitType):
1219 """A long integer trait."""
1218 """A long integer trait."""
1220
1219
1221 default_value = 0
1220 default_value = 0
1222 info_text = 'a long'
1221 info_text = 'a long'
1223
1222
1224 def validate(self, obj, value):
1223 def validate(self, obj, value):
1225 if isinstance(value, long):
1224 if isinstance(value, long):
1226 return value
1225 return value
1227 if isinstance(value, int):
1226 if isinstance(value, int):
1228 return long(value)
1227 return long(value)
1229 self.error(obj, value)
1228 self.error(obj, value)
1230
1229
1231
1230
1232 class CLong(Long):
1231 class CLong(Long):
1233 """A casting version of the long integer trait."""
1232 """A casting version of the long integer trait."""
1234
1233
1235 def validate(self, obj, value):
1234 def validate(self, obj, value):
1236 try:
1235 try:
1237 return long(value)
1236 return long(value)
1238 except:
1237 except:
1239 self.error(obj, value)
1238 self.error(obj, value)
1240
1239
1241 class Integer(TraitType):
1240 class Integer(TraitType):
1242 """An integer trait.
1241 """An integer trait.
1243
1242
1244 Longs that are unnecessary (<= sys.maxint) are cast to ints."""
1243 Longs that are unnecessary (<= sys.maxint) are cast to ints."""
1245
1244
1246 default_value = 0
1245 default_value = 0
1247 info_text = 'an integer'
1246 info_text = 'an integer'
1248
1247
1249 def validate(self, obj, value):
1248 def validate(self, obj, value):
1250 if isinstance(value, int):
1249 if isinstance(value, int):
1251 return value
1250 return value
1252 if isinstance(value, long):
1251 if isinstance(value, long):
1253 # downcast longs that fit in int:
1252 # downcast longs that fit in int:
1254 # note that int(n > sys.maxint) returns a long, so
1253 # note that int(n > sys.maxint) returns a long, so
1255 # we don't need a condition on this cast
1254 # we don't need a condition on this cast
1256 return int(value)
1255 return int(value)
1257 if sys.platform == "cli":
1256 if sys.platform == "cli":
1258 from System import Int64
1257 from System import Int64
1259 if isinstance(value, Int64):
1258 if isinstance(value, Int64):
1260 return int(value)
1259 return int(value)
1261 self.error(obj, value)
1260 self.error(obj, value)
1262
1261
1263
1262
1264 class Float(TraitType):
1263 class Float(TraitType):
1265 """A float trait."""
1264 """A float trait."""
1266
1265
1267 default_value = 0.0
1266 default_value = 0.0
1268 info_text = 'a float'
1267 info_text = 'a float'
1269
1268
1270 def validate(self, obj, value):
1269 def validate(self, obj, value):
1271 if isinstance(value, float):
1270 if isinstance(value, float):
1272 return value
1271 return value
1273 if isinstance(value, int):
1272 if isinstance(value, int):
1274 return float(value)
1273 return float(value)
1275 self.error(obj, value)
1274 self.error(obj, value)
1276
1275
1277
1276
1278 class CFloat(Float):
1277 class CFloat(Float):
1279 """A casting version of the float trait."""
1278 """A casting version of the float trait."""
1280
1279
1281 def validate(self, obj, value):
1280 def validate(self, obj, value):
1282 try:
1281 try:
1283 return float(value)
1282 return float(value)
1284 except:
1283 except:
1285 self.error(obj, value)
1284 self.error(obj, value)
1286
1285
1287 class Complex(TraitType):
1286 class Complex(TraitType):
1288 """A trait for complex numbers."""
1287 """A trait for complex numbers."""
1289
1288
1290 default_value = 0.0 + 0.0j
1289 default_value = 0.0 + 0.0j
1291 info_text = 'a complex number'
1290 info_text = 'a complex number'
1292
1291
1293 def validate(self, obj, value):
1292 def validate(self, obj, value):
1294 if isinstance(value, complex):
1293 if isinstance(value, complex):
1295 return value
1294 return value
1296 if isinstance(value, (float, int)):
1295 if isinstance(value, (float, int)):
1297 return complex(value)
1296 return complex(value)
1298 self.error(obj, value)
1297 self.error(obj, value)
1299
1298
1300
1299
1301 class CComplex(Complex):
1300 class CComplex(Complex):
1302 """A casting version of the complex number trait."""
1301 """A casting version of the complex number trait."""
1303
1302
1304 def validate (self, obj, value):
1303 def validate (self, obj, value):
1305 try:
1304 try:
1306 return complex(value)
1305 return complex(value)
1307 except:
1306 except:
1308 self.error(obj, value)
1307 self.error(obj, value)
1309
1308
1310 # We should always be explicit about whether we're using bytes or unicode, both
1309 # We should always be explicit about whether we're using bytes or unicode, both
1311 # for Python 3 conversion and for reliable unicode behaviour on Python 2. So
1310 # for Python 3 conversion and for reliable unicode behaviour on Python 2. So
1312 # we don't have a Str type.
1311 # we don't have a Str type.
1313 class Bytes(TraitType):
1312 class Bytes(TraitType):
1314 """A trait for byte strings."""
1313 """A trait for byte strings."""
1315
1314
1316 default_value = b''
1315 default_value = b''
1317 info_text = 'a bytes object'
1316 info_text = 'a bytes object'
1318
1317
1319 def validate(self, obj, value):
1318 def validate(self, obj, value):
1320 if isinstance(value, bytes):
1319 if isinstance(value, bytes):
1321 return value
1320 return value
1322 self.error(obj, value)
1321 self.error(obj, value)
1323
1322
1324
1323
1325 class CBytes(Bytes):
1324 class CBytes(Bytes):
1326 """A casting version of the byte string trait."""
1325 """A casting version of the byte string trait."""
1327
1326
1328 def validate(self, obj, value):
1327 def validate(self, obj, value):
1329 try:
1328 try:
1330 return bytes(value)
1329 return bytes(value)
1331 except:
1330 except:
1332 self.error(obj, value)
1331 self.error(obj, value)
1333
1332
1334
1333
1335 class Unicode(TraitType):
1334 class Unicode(TraitType):
1336 """A trait for unicode strings."""
1335 """A trait for unicode strings."""
1337
1336
1338 default_value = u''
1337 default_value = u''
1339 info_text = 'a unicode string'
1338 info_text = 'a unicode string'
1340
1339
1341 def validate(self, obj, value):
1340 def validate(self, obj, value):
1342 if isinstance(value, py3compat.unicode_type):
1341 if isinstance(value, py3compat.unicode_type):
1343 return value
1342 return value
1344 if isinstance(value, bytes):
1343 if isinstance(value, bytes):
1345 try:
1344 try:
1346 return value.decode('ascii', 'strict')
1345 return value.decode('ascii', 'strict')
1347 except UnicodeDecodeError:
1346 except UnicodeDecodeError:
1348 msg = "Could not decode {!r} for unicode trait '{}' of {} instance."
1347 msg = "Could not decode {!r} for unicode trait '{}' of {} instance."
1349 raise TraitError(msg.format(value, self.name, class_of(obj)))
1348 raise TraitError(msg.format(value, self.name, class_of(obj)))
1350 self.error(obj, value)
1349 self.error(obj, value)
1351
1350
1352
1351
1353 class CUnicode(Unicode):
1352 class CUnicode(Unicode):
1354 """A casting version of the unicode trait."""
1353 """A casting version of the unicode trait."""
1355
1354
1356 def validate(self, obj, value):
1355 def validate(self, obj, value):
1357 try:
1356 try:
1358 return py3compat.unicode_type(value)
1357 return py3compat.unicode_type(value)
1359 except:
1358 except:
1360 self.error(obj, value)
1359 self.error(obj, value)
1361
1360
1362
1361
1363 class ObjectName(TraitType):
1362 class ObjectName(TraitType):
1364 """A string holding a valid object name in this version of Python.
1363 """A string holding a valid object name in this version of Python.
1365
1364
1366 This does not check that the name exists in any scope."""
1365 This does not check that the name exists in any scope."""
1367 info_text = "a valid object identifier in Python"
1366 info_text = "a valid object identifier in Python"
1368
1367
1369 if py3compat.PY3:
1368 if py3compat.PY3:
1370 # Python 3:
1369 # Python 3:
1371 coerce_str = staticmethod(lambda _,s: s)
1370 coerce_str = staticmethod(lambda _,s: s)
1372
1371
1373 else:
1372 else:
1374 # Python 2:
1373 # Python 2:
1375 def coerce_str(self, obj, value):
1374 def coerce_str(self, obj, value):
1376 "In Python 2, coerce ascii-only unicode to str"
1375 "In Python 2, coerce ascii-only unicode to str"
1377 if isinstance(value, unicode):
1376 if isinstance(value, unicode):
1378 try:
1377 try:
1379 return str(value)
1378 return str(value)
1380 except UnicodeEncodeError:
1379 except UnicodeEncodeError:
1381 self.error(obj, value)
1380 self.error(obj, value)
1382 return value
1381 return value
1383
1382
1384 def validate(self, obj, value):
1383 def validate(self, obj, value):
1385 value = self.coerce_str(obj, value)
1384 value = self.coerce_str(obj, value)
1386
1385
1387 if isinstance(value, string_types) and py3compat.isidentifier(value):
1386 if isinstance(value, string_types) and py3compat.isidentifier(value):
1388 return value
1387 return value
1389 self.error(obj, value)
1388 self.error(obj, value)
1390
1389
1391 class DottedObjectName(ObjectName):
1390 class DottedObjectName(ObjectName):
1392 """A string holding a valid dotted object name in Python, such as A.b3._c"""
1391 """A string holding a valid dotted object name in Python, such as A.b3._c"""
1393 def validate(self, obj, value):
1392 def validate(self, obj, value):
1394 value = self.coerce_str(obj, value)
1393 value = self.coerce_str(obj, value)
1395
1394
1396 if isinstance(value, string_types) and py3compat.isidentifier(value, dotted=True):
1395 if isinstance(value, string_types) and py3compat.isidentifier(value, dotted=True):
1397 return value
1396 return value
1398 self.error(obj, value)
1397 self.error(obj, value)
1399
1398
1400
1399
1401 class Bool(TraitType):
1400 class Bool(TraitType):
1402 """A boolean (True, False) trait."""
1401 """A boolean (True, False) trait."""
1403
1402
1404 default_value = False
1403 default_value = False
1405 info_text = 'a boolean'
1404 info_text = 'a boolean'
1406
1405
1407 def validate(self, obj, value):
1406 def validate(self, obj, value):
1408 if isinstance(value, bool):
1407 if isinstance(value, bool):
1409 return value
1408 return value
1410 self.error(obj, value)
1409 self.error(obj, value)
1411
1410
1412
1411
1413 class CBool(Bool):
1412 class CBool(Bool):
1414 """A casting version of the boolean trait."""
1413 """A casting version of the boolean trait."""
1415
1414
1416 def validate(self, obj, value):
1415 def validate(self, obj, value):
1417 try:
1416 try:
1418 return bool(value)
1417 return bool(value)
1419 except:
1418 except:
1420 self.error(obj, value)
1419 self.error(obj, value)
1421
1420
1422
1421
1423 class Enum(TraitType):
1422 class Enum(TraitType):
1424 """An enum that whose value must be in a given sequence."""
1423 """An enum that whose value must be in a given sequence."""
1425
1424
1426 def __init__(self, values, default_value=None, **metadata):
1425 def __init__(self, values, default_value=None, **metadata):
1427 self.values = values
1426 self.values = values
1428 super(Enum, self).__init__(default_value, **metadata)
1427 super(Enum, self).__init__(default_value, **metadata)
1429
1428
1430 def validate(self, obj, value):
1429 def validate(self, obj, value):
1431 if value in self.values:
1430 if value in self.values:
1432 return value
1431 return value
1433 self.error(obj, value)
1432 self.error(obj, value)
1434
1433
1435 def info(self):
1434 def info(self):
1436 """ Returns a description of the trait."""
1435 """ Returns a description of the trait."""
1437 result = 'any of ' + repr(self.values)
1436 result = 'any of ' + repr(self.values)
1438 if self.allow_none:
1437 if self.allow_none:
1439 return result + ' or None'
1438 return result + ' or None'
1440 return result
1439 return result
1441
1440
1442 class CaselessStrEnum(Enum):
1441 class CaselessStrEnum(Enum):
1443 """An enum of strings that are caseless in validate."""
1442 """An enum of strings that are caseless in validate."""
1444
1443
1445 def validate(self, obj, value):
1444 def validate(self, obj, value):
1446 if not isinstance(value, py3compat.string_types):
1445 if not isinstance(value, py3compat.string_types):
1447 self.error(obj, value)
1446 self.error(obj, value)
1448
1447
1449 for v in self.values:
1448 for v in self.values:
1450 if v.lower() == value.lower():
1449 if v.lower() == value.lower():
1451 return v
1450 return v
1452 self.error(obj, value)
1451 self.error(obj, value)
1453
1452
1454 class Container(Instance):
1453 class Container(Instance):
1455 """An instance of a container (list, set, etc.)
1454 """An instance of a container (list, set, etc.)
1456
1455
1457 To be subclassed by overriding klass.
1456 To be subclassed by overriding klass.
1458 """
1457 """
1459 klass = None
1458 klass = None
1460 _cast_types = ()
1459 _cast_types = ()
1461 _valid_defaults = SequenceTypes
1460 _valid_defaults = SequenceTypes
1462 _trait = None
1461 _trait = None
1463
1462
1464 def __init__(self, trait=None, default_value=None, allow_none=False,
1463 def __init__(self, trait=None, default_value=None, allow_none=False,
1465 **metadata):
1464 **metadata):
1466 """Create a container trait type from a list, set, or tuple.
1465 """Create a container trait type from a list, set, or tuple.
1467
1466
1468 The default value is created by doing ``List(default_value)``,
1467 The default value is created by doing ``List(default_value)``,
1469 which creates a copy of the ``default_value``.
1468 which creates a copy of the ``default_value``.
1470
1469
1471 ``trait`` can be specified, which restricts the type of elements
1470 ``trait`` can be specified, which restricts the type of elements
1472 in the container to that TraitType.
1471 in the container to that TraitType.
1473
1472
1474 If only one arg is given and it is not a Trait, it is taken as
1473 If only one arg is given and it is not a Trait, it is taken as
1475 ``default_value``:
1474 ``default_value``:
1476
1475
1477 ``c = List([1,2,3])``
1476 ``c = List([1,2,3])``
1478
1477
1479 Parameters
1478 Parameters
1480 ----------
1479 ----------
1481
1480
1482 trait : TraitType [ optional ]
1481 trait : TraitType [ optional ]
1483 the type for restricting the contents of the Container. If unspecified,
1482 the type for restricting the contents of the Container. If unspecified,
1484 types are not checked.
1483 types are not checked.
1485
1484
1486 default_value : SequenceType [ optional ]
1485 default_value : SequenceType [ optional ]
1487 The default value for the Trait. Must be list/tuple/set, and
1486 The default value for the Trait. Must be list/tuple/set, and
1488 will be cast to the container type.
1487 will be cast to the container type.
1489
1488
1490 allow_none : bool [ default False ]
1489 allow_none : bool [ default False ]
1491 Whether to allow the value to be None
1490 Whether to allow the value to be None
1492
1491
1493 **metadata : any
1492 **metadata : any
1494 further keys for extensions to the Trait (e.g. config)
1493 further keys for extensions to the Trait (e.g. config)
1495
1494
1496 """
1495 """
1497 # allow List([values]):
1496 # allow List([values]):
1498 if default_value is None and not is_trait(trait):
1497 if default_value is None and not is_trait(trait):
1499 default_value = trait
1498 default_value = trait
1500 trait = None
1499 trait = None
1501
1500
1502 if default_value is None:
1501 if default_value is None:
1503 args = ()
1502 args = ()
1504 elif isinstance(default_value, self._valid_defaults):
1503 elif isinstance(default_value, self._valid_defaults):
1505 args = (default_value,)
1504 args = (default_value,)
1506 else:
1505 else:
1507 raise TypeError('default value of %s was %s' %(self.__class__.__name__, default_value))
1506 raise TypeError('default value of %s was %s' %(self.__class__.__name__, default_value))
1508
1507
1509 if is_trait(trait):
1508 if is_trait(trait):
1510 self._trait = trait() if isinstance(trait, type) else trait
1509 self._trait = trait() if isinstance(trait, type) else trait
1511 self._trait.name = 'element'
1510 self._trait.name = 'element'
1512 elif trait is not None:
1511 elif trait is not None:
1513 raise TypeError("`trait` must be a Trait or None, got %s"%repr_type(trait))
1512 raise TypeError("`trait` must be a Trait or None, got %s"%repr_type(trait))
1514
1513
1515 super(Container,self).__init__(klass=self.klass, args=args,
1514 super(Container,self).__init__(klass=self.klass, args=args,
1516 allow_none=allow_none, **metadata)
1515 allow_none=allow_none, **metadata)
1517
1516
1518 def element_error(self, obj, element, validator):
1517 def element_error(self, obj, element, validator):
1519 e = "Element of the '%s' trait of %s instance must be %s, but a value of %s was specified." \
1518 e = "Element of the '%s' trait of %s instance must be %s, but a value of %s was specified." \
1520 % (self.name, class_of(obj), validator.info(), repr_type(element))
1519 % (self.name, class_of(obj), validator.info(), repr_type(element))
1521 raise TraitError(e)
1520 raise TraitError(e)
1522
1521
1523 def validate(self, obj, value):
1522 def validate(self, obj, value):
1524 if isinstance(value, self._cast_types):
1523 if isinstance(value, self._cast_types):
1525 value = self.klass(value)
1524 value = self.klass(value)
1526 value = super(Container, self).validate(obj, value)
1525 value = super(Container, self).validate(obj, value)
1527 if value is None:
1526 if value is None:
1528 return value
1527 return value
1529
1528
1530 value = self.validate_elements(obj, value)
1529 value = self.validate_elements(obj, value)
1531
1530
1532 return value
1531 return value
1533
1532
1534 def validate_elements(self, obj, value):
1533 def validate_elements(self, obj, value):
1535 validated = []
1534 validated = []
1536 if self._trait is None or isinstance(self._trait, Any):
1535 if self._trait is None or isinstance(self._trait, Any):
1537 return value
1536 return value
1538 for v in value:
1537 for v in value:
1539 try:
1538 try:
1540 v = self._trait._validate(obj, v)
1539 v = self._trait._validate(obj, v)
1541 except TraitError:
1540 except TraitError:
1542 self.element_error(obj, v, self._trait)
1541 self.element_error(obj, v, self._trait)
1543 else:
1542 else:
1544 validated.append(v)
1543 validated.append(v)
1545 return self.klass(validated)
1544 return self.klass(validated)
1546
1545
1547 def instance_init(self):
1546 def instance_init(self):
1548 if isinstance(self._trait, TraitType):
1547 if isinstance(self._trait, TraitType):
1549 self._trait.this_class = self.this_class
1548 self._trait.this_class = self.this_class
1550 self._trait.instance_init()
1549 self._trait.instance_init()
1551 super(Container, self).instance_init()
1550 super(Container, self).instance_init()
1552
1551
1553
1552
1554 class List(Container):
1553 class List(Container):
1555 """An instance of a Python list."""
1554 """An instance of a Python list."""
1556 klass = list
1555 klass = list
1557 _cast_types = (tuple,)
1556 _cast_types = (tuple,)
1558
1557
1559 def __init__(self, trait=None, default_value=None, minlen=0, maxlen=sys.maxsize, **metadata):
1558 def __init__(self, trait=None, default_value=None, minlen=0, maxlen=sys.maxsize, **metadata):
1560 """Create a List trait type from a list, set, or tuple.
1559 """Create a List trait type from a list, set, or tuple.
1561
1560
1562 The default value is created by doing ``List(default_value)``,
1561 The default value is created by doing ``List(default_value)``,
1563 which creates a copy of the ``default_value``.
1562 which creates a copy of the ``default_value``.
1564
1563
1565 ``trait`` can be specified, which restricts the type of elements
1564 ``trait`` can be specified, which restricts the type of elements
1566 in the container to that TraitType.
1565 in the container to that TraitType.
1567
1566
1568 If only one arg is given and it is not a Trait, it is taken as
1567 If only one arg is given and it is not a Trait, it is taken as
1569 ``default_value``:
1568 ``default_value``:
1570
1569
1571 ``c = List([1,2,3])``
1570 ``c = List([1,2,3])``
1572
1571
1573 Parameters
1572 Parameters
1574 ----------
1573 ----------
1575
1574
1576 trait : TraitType [ optional ]
1575 trait : TraitType [ optional ]
1577 the type for restricting the contents of the Container. If unspecified,
1576 the type for restricting the contents of the Container. If unspecified,
1578 types are not checked.
1577 types are not checked.
1579
1578
1580 default_value : SequenceType [ optional ]
1579 default_value : SequenceType [ optional ]
1581 The default value for the Trait. Must be list/tuple/set, and
1580 The default value for the Trait. Must be list/tuple/set, and
1582 will be cast to the container type.
1581 will be cast to the container type.
1583
1582
1584 minlen : Int [ default 0 ]
1583 minlen : Int [ default 0 ]
1585 The minimum length of the input list
1584 The minimum length of the input list
1586
1585
1587 maxlen : Int [ default sys.maxsize ]
1586 maxlen : Int [ default sys.maxsize ]
1588 The maximum length of the input list
1587 The maximum length of the input list
1589
1588
1590 allow_none : bool [ default False ]
1589 allow_none : bool [ default False ]
1591 Whether to allow the value to be None
1590 Whether to allow the value to be None
1592
1591
1593 **metadata : any
1592 **metadata : any
1594 further keys for extensions to the Trait (e.g. config)
1593 further keys for extensions to the Trait (e.g. config)
1595
1594
1596 """
1595 """
1597 self._minlen = minlen
1596 self._minlen = minlen
1598 self._maxlen = maxlen
1597 self._maxlen = maxlen
1599 super(List, self).__init__(trait=trait, default_value=default_value,
1598 super(List, self).__init__(trait=trait, default_value=default_value,
1600 **metadata)
1599 **metadata)
1601
1600
1602 def length_error(self, obj, value):
1601 def length_error(self, obj, value):
1603 e = "The '%s' trait of %s instance must be of length %i <= L <= %i, but a value of %s was specified." \
1602 e = "The '%s' trait of %s instance must be of length %i <= L <= %i, but a value of %s was specified." \
1604 % (self.name, class_of(obj), self._minlen, self._maxlen, value)
1603 % (self.name, class_of(obj), self._minlen, self._maxlen, value)
1605 raise TraitError(e)
1604 raise TraitError(e)
1606
1605
1607 def validate_elements(self, obj, value):
1606 def validate_elements(self, obj, value):
1608 length = len(value)
1607 length = len(value)
1609 if length < self._minlen or length > self._maxlen:
1608 if length < self._minlen or length > self._maxlen:
1610 self.length_error(obj, value)
1609 self.length_error(obj, value)
1611
1610
1612 return super(List, self).validate_elements(obj, value)
1611 return super(List, self).validate_elements(obj, value)
1613
1612
1614 def validate(self, obj, value):
1613 def validate(self, obj, value):
1615 value = super(List, self).validate(obj, value)
1614 value = super(List, self).validate(obj, value)
1616 value = self.validate_elements(obj, value)
1615 value = self.validate_elements(obj, value)
1617 return value
1616 return value
1618
1617
1619
1618
1620 class Set(List):
1619 class Set(List):
1621 """An instance of a Python set."""
1620 """An instance of a Python set."""
1622 klass = set
1621 klass = set
1623 _cast_types = (tuple, list)
1622 _cast_types = (tuple, list)
1624
1623
1625
1624
1626 class Tuple(Container):
1625 class Tuple(Container):
1627 """An instance of a Python tuple."""
1626 """An instance of a Python tuple."""
1628 klass = tuple
1627 klass = tuple
1629 _cast_types = (list,)
1628 _cast_types = (list,)
1630
1629
1631 def __init__(self, *traits, **metadata):
1630 def __init__(self, *traits, **metadata):
1632 """Tuple(*traits, default_value=None, **medatata)
1631 """Tuple(*traits, default_value=None, **medatata)
1633
1632
1634 Create a tuple from a list, set, or tuple.
1633 Create a tuple from a list, set, or tuple.
1635
1634
1636 Create a fixed-type tuple with Traits:
1635 Create a fixed-type tuple with Traits:
1637
1636
1638 ``t = Tuple(Int, Str, CStr)``
1637 ``t = Tuple(Int, Str, CStr)``
1639
1638
1640 would be length 3, with Int,Str,CStr for each element.
1639 would be length 3, with Int,Str,CStr for each element.
1641
1640
1642 If only one arg is given and it is not a Trait, it is taken as
1641 If only one arg is given and it is not a Trait, it is taken as
1643 default_value:
1642 default_value:
1644
1643
1645 ``t = Tuple((1,2,3))``
1644 ``t = Tuple((1,2,3))``
1646
1645
1647 Otherwise, ``default_value`` *must* be specified by keyword.
1646 Otherwise, ``default_value`` *must* be specified by keyword.
1648
1647
1649 Parameters
1648 Parameters
1650 ----------
1649 ----------
1651
1650
1652 *traits : TraitTypes [ optional ]
1651 *traits : TraitTypes [ optional ]
1653 the types for restricting the contents of the Tuple. If unspecified,
1652 the types for restricting the contents of the Tuple. If unspecified,
1654 types are not checked. If specified, then each positional argument
1653 types are not checked. If specified, then each positional argument
1655 corresponds to an element of the tuple. Tuples defined with traits
1654 corresponds to an element of the tuple. Tuples defined with traits
1656 are of fixed length.
1655 are of fixed length.
1657
1656
1658 default_value : SequenceType [ optional ]
1657 default_value : SequenceType [ optional ]
1659 The default value for the Tuple. Must be list/tuple/set, and
1658 The default value for the Tuple. Must be list/tuple/set, and
1660 will be cast to a tuple. If `traits` are specified, the
1659 will be cast to a tuple. If `traits` are specified, the
1661 `default_value` must conform to the shape and type they specify.
1660 `default_value` must conform to the shape and type they specify.
1662
1661
1663 allow_none : bool [ default False ]
1662 allow_none : bool [ default False ]
1664 Whether to allow the value to be None
1663 Whether to allow the value to be None
1665
1664
1666 **metadata : any
1665 **metadata : any
1667 further keys for extensions to the Trait (e.g. config)
1666 further keys for extensions to the Trait (e.g. config)
1668
1667
1669 """
1668 """
1670 default_value = metadata.pop('default_value', None)
1669 default_value = metadata.pop('default_value', None)
1671 allow_none = metadata.pop('allow_none', True)
1670 allow_none = metadata.pop('allow_none', True)
1672
1671
1673 # allow Tuple((values,)):
1672 # allow Tuple((values,)):
1674 if len(traits) == 1 and default_value is None and not is_trait(traits[0]):
1673 if len(traits) == 1 and default_value is None and not is_trait(traits[0]):
1675 default_value = traits[0]
1674 default_value = traits[0]
1676 traits = ()
1675 traits = ()
1677
1676
1678 if default_value is None:
1677 if default_value is None:
1679 args = ()
1678 args = ()
1680 elif isinstance(default_value, self._valid_defaults):
1679 elif isinstance(default_value, self._valid_defaults):
1681 args = (default_value,)
1680 args = (default_value,)
1682 else:
1681 else:
1683 raise TypeError('default value of %s was %s' %(self.__class__.__name__, default_value))
1682 raise TypeError('default value of %s was %s' %(self.__class__.__name__, default_value))
1684
1683
1685 self._traits = []
1684 self._traits = []
1686 for trait in traits:
1685 for trait in traits:
1687 t = trait() if isinstance(trait, type) else trait
1686 t = trait() if isinstance(trait, type) else trait
1688 t.name = 'element'
1687 t.name = 'element'
1689 self._traits.append(t)
1688 self._traits.append(t)
1690
1689
1691 if self._traits and default_value is None:
1690 if self._traits and default_value is None:
1692 # don't allow default to be an empty container if length is specified
1691 # don't allow default to be an empty container if length is specified
1693 args = None
1692 args = None
1694 super(Container,self).__init__(klass=self.klass, args=args, allow_none=allow_none, **metadata)
1693 super(Container,self).__init__(klass=self.klass, args=args, allow_none=allow_none, **metadata)
1695
1694
1696 def validate_elements(self, obj, value):
1695 def validate_elements(self, obj, value):
1697 if not self._traits:
1696 if not self._traits:
1698 # nothing to validate
1697 # nothing to validate
1699 return value
1698 return value
1700 if len(value) != len(self._traits):
1699 if len(value) != len(self._traits):
1701 e = "The '%s' trait of %s instance requires %i elements, but a value of %s was specified." \
1700 e = "The '%s' trait of %s instance requires %i elements, but a value of %s was specified." \
1702 % (self.name, class_of(obj), len(self._traits), repr_type(value))
1701 % (self.name, class_of(obj), len(self._traits), repr_type(value))
1703 raise TraitError(e)
1702 raise TraitError(e)
1704
1703
1705 validated = []
1704 validated = []
1706 for t, v in zip(self._traits, value):
1705 for t, v in zip(self._traits, value):
1707 try:
1706 try:
1708 v = t._validate(obj, v)
1707 v = t._validate(obj, v)
1709 except TraitError:
1708 except TraitError:
1710 self.element_error(obj, v, t)
1709 self.element_error(obj, v, t)
1711 else:
1710 else:
1712 validated.append(v)
1711 validated.append(v)
1713 return tuple(validated)
1712 return tuple(validated)
1714
1713
1715 def instance_init(self):
1714 def instance_init(self):
1716 for trait in self._traits:
1715 for trait in self._traits:
1717 if isinstance(trait, TraitType):
1716 if isinstance(trait, TraitType):
1718 trait.this_class = self.this_class
1717 trait.this_class = self.this_class
1719 trait.instance_init()
1718 trait.instance_init()
1720 super(Container, self).instance_init()
1719 super(Container, self).instance_init()
1721
1720
1722
1721
1723 class Dict(Instance):
1722 class Dict(Instance):
1724 """An instance of a Python dict."""
1723 """An instance of a Python dict."""
1725 _trait = None
1724 _trait = None
1726
1725
1727 def __init__(self, trait=None, default_value=NoDefaultSpecified, allow_none=False, **metadata):
1726 def __init__(self, trait=None, default_value=NoDefaultSpecified, allow_none=False, **metadata):
1728 """Create a dict trait type from a dict.
1727 """Create a dict trait type from a dict.
1729
1728
1730 The default value is created by doing ``dict(default_value)``,
1729 The default value is created by doing ``dict(default_value)``,
1731 which creates a copy of the ``default_value``.
1730 which creates a copy of the ``default_value``.
1732
1731
1733 trait : TraitType [ optional ]
1732 trait : TraitType [ optional ]
1734 the type for restricting the contents of the Container. If unspecified,
1733 the type for restricting the contents of the Container. If unspecified,
1735 types are not checked.
1734 types are not checked.
1736
1735
1737 default_value : SequenceType [ optional ]
1736 default_value : SequenceType [ optional ]
1738 The default value for the Dict. Must be dict, tuple, or None, and
1737 The default value for the Dict. Must be dict, tuple, or None, and
1739 will be cast to a dict if not None. If `trait` is specified, the
1738 will be cast to a dict if not None. If `trait` is specified, the
1740 `default_value` must conform to the constraints it specifies.
1739 `default_value` must conform to the constraints it specifies.
1741
1740
1742 allow_none : bool [ default False ]
1741 allow_none : bool [ default False ]
1743 Whether to allow the value to be None
1742 Whether to allow the value to be None
1744
1743
1745 """
1744 """
1746 if default_value is NoDefaultSpecified and trait is not None:
1745 if default_value is NoDefaultSpecified and trait is not None:
1747 if not is_trait(trait):
1746 if not is_trait(trait):
1748 default_value = trait
1747 default_value = trait
1749 trait = None
1748 trait = None
1750 if default_value is NoDefaultSpecified:
1749 if default_value is NoDefaultSpecified:
1751 default_value = {}
1750 default_value = {}
1752 if default_value is None:
1751 if default_value is None:
1753 args = None
1752 args = None
1754 elif isinstance(default_value, dict):
1753 elif isinstance(default_value, dict):
1755 args = (default_value,)
1754 args = (default_value,)
1756 elif isinstance(default_value, SequenceTypes):
1755 elif isinstance(default_value, SequenceTypes):
1757 args = (default_value,)
1756 args = (default_value,)
1758 else:
1757 else:
1759 raise TypeError('default value of Dict was %s' % default_value)
1758 raise TypeError('default value of Dict was %s' % default_value)
1760
1759
1761 if is_trait(trait):
1760 if is_trait(trait):
1762 self._trait = trait() if isinstance(trait, type) else trait
1761 self._trait = trait() if isinstance(trait, type) else trait
1763 self._trait.name = 'element'
1762 self._trait.name = 'element'
1764 elif trait is not None:
1763 elif trait is not None:
1765 raise TypeError("`trait` must be a Trait or None, got %s"%repr_type(trait))
1764 raise TypeError("`trait` must be a Trait or None, got %s"%repr_type(trait))
1766
1765
1767 super(Dict,self).__init__(klass=dict, args=args,
1766 super(Dict,self).__init__(klass=dict, args=args,
1768 allow_none=allow_none, **metadata)
1767 allow_none=allow_none, **metadata)
1769
1768
1770 def element_error(self, obj, element, validator):
1769 def element_error(self, obj, element, validator):
1771 e = "Element of the '%s' trait of %s instance must be %s, but a value of %s was specified." \
1770 e = "Element of the '%s' trait of %s instance must be %s, but a value of %s was specified." \
1772 % (self.name, class_of(obj), validator.info(), repr_type(element))
1771 % (self.name, class_of(obj), validator.info(), repr_type(element))
1773 raise TraitError(e)
1772 raise TraitError(e)
1774
1773
1775 def validate(self, obj, value):
1774 def validate(self, obj, value):
1776 value = super(Dict, self).validate(obj, value)
1775 value = super(Dict, self).validate(obj, value)
1777 if value is None:
1776 if value is None:
1778 return value
1777 return value
1779 value = self.validate_elements(obj, value)
1778 value = self.validate_elements(obj, value)
1780 return value
1779 return value
1781
1780
1782 def validate_elements(self, obj, value):
1781 def validate_elements(self, obj, value):
1783 if self._trait is None or isinstance(self._trait, Any):
1782 if self._trait is None or isinstance(self._trait, Any):
1784 return value
1783 return value
1785 validated = {}
1784 validated = {}
1786 for key in value:
1785 for key in value:
1787 v = value[key]
1786 v = value[key]
1788 try:
1787 try:
1789 v = self._trait._validate(obj, v)
1788 v = self._trait._validate(obj, v)
1790 except TraitError:
1789 except TraitError:
1791 self.element_error(obj, v, self._trait)
1790 self.element_error(obj, v, self._trait)
1792 else:
1791 else:
1793 validated[key] = v
1792 validated[key] = v
1794 return self.klass(validated)
1793 return self.klass(validated)
1795
1794
1796 def instance_init(self):
1795 def instance_init(self):
1797 if isinstance(self._trait, TraitType):
1796 if isinstance(self._trait, TraitType):
1798 self._trait.this_class = self.this_class
1797 self._trait.this_class = self.this_class
1799 self._trait.instance_init()
1798 self._trait.instance_init()
1800 super(Dict, self).instance_init()
1799 super(Dict, self).instance_init()
1801
1800
1802
1801
1803 class EventfulDict(Instance):
1802 class EventfulDict(Instance):
1804 """An instance of an EventfulDict."""
1803 """An instance of an EventfulDict."""
1805
1804
1806 def __init__(self, default_value={}, allow_none=False, **metadata):
1805 def __init__(self, default_value={}, allow_none=False, **metadata):
1807 """Create a EventfulDict trait type from a dict.
1806 """Create a EventfulDict trait type from a dict.
1808
1807
1809 The default value is created by doing
1808 The default value is created by doing
1810 ``eventful.EvenfulDict(default_value)``, which creates a copy of the
1809 ``eventful.EvenfulDict(default_value)``, which creates a copy of the
1811 ``default_value``.
1810 ``default_value``.
1812 """
1811 """
1813 if default_value is None:
1812 if default_value is None:
1814 args = None
1813 args = None
1815 elif isinstance(default_value, dict):
1814 elif isinstance(default_value, dict):
1816 args = (default_value,)
1815 args = (default_value,)
1817 elif isinstance(default_value, SequenceTypes):
1816 elif isinstance(default_value, SequenceTypes):
1818 args = (default_value,)
1817 args = (default_value,)
1819 else:
1818 else:
1820 raise TypeError('default value of EventfulDict was %s' % default_value)
1819 raise TypeError('default value of EventfulDict was %s' % default_value)
1821
1820
1822 super(EventfulDict, self).__init__(klass=eventful.EventfulDict, args=args,
1821 super(EventfulDict, self).__init__(klass=eventful.EventfulDict, args=args,
1823 allow_none=allow_none, **metadata)
1822 allow_none=allow_none, **metadata)
1824
1823
1825
1824
1826 class EventfulList(Instance):
1825 class EventfulList(Instance):
1827 """An instance of an EventfulList."""
1826 """An instance of an EventfulList."""
1828
1827
1829 def __init__(self, default_value=None, allow_none=False, **metadata):
1828 def __init__(self, default_value=None, allow_none=False, **metadata):
1830 """Create a EventfulList trait type from a dict.
1829 """Create a EventfulList trait type from a dict.
1831
1830
1832 The default value is created by doing
1831 The default value is created by doing
1833 ``eventful.EvenfulList(default_value)``, which creates a copy of the
1832 ``eventful.EvenfulList(default_value)``, which creates a copy of the
1834 ``default_value``.
1833 ``default_value``.
1835 """
1834 """
1836 if default_value is None:
1835 if default_value is None:
1837 args = ((),)
1836 args = ((),)
1838 else:
1837 else:
1839 args = (default_value,)
1838 args = (default_value,)
1840
1839
1841 super(EventfulList, self).__init__(klass=eventful.EventfulList, args=args,
1840 super(EventfulList, self).__init__(klass=eventful.EventfulList, args=args,
1842 allow_none=allow_none, **metadata)
1841 allow_none=allow_none, **metadata)
1843
1842
1844
1843
1845 class TCPAddress(TraitType):
1844 class TCPAddress(TraitType):
1846 """A trait for an (ip, port) tuple.
1845 """A trait for an (ip, port) tuple.
1847
1846
1848 This allows for both IPv4 IP addresses as well as hostnames.
1847 This allows for both IPv4 IP addresses as well as hostnames.
1849 """
1848 """
1850
1849
1851 default_value = ('127.0.0.1', 0)
1850 default_value = ('127.0.0.1', 0)
1852 info_text = 'an (ip, port) tuple'
1851 info_text = 'an (ip, port) tuple'
1853
1852
1854 def validate(self, obj, value):
1853 def validate(self, obj, value):
1855 if isinstance(value, tuple):
1854 if isinstance(value, tuple):
1856 if len(value) == 2:
1855 if len(value) == 2:
1857 if isinstance(value[0], py3compat.string_types) and isinstance(value[1], int):
1856 if isinstance(value[0], py3compat.string_types) and isinstance(value[1], int):
1858 port = value[1]
1857 port = value[1]
1859 if port >= 0 and port <= 65535:
1858 if port >= 0 and port <= 65535:
1860 return value
1859 return value
1861 self.error(obj, value)
1860 self.error(obj, value)
1862
1861
1863 class CRegExp(TraitType):
1862 class CRegExp(TraitType):
1864 """A casting compiled regular expression trait.
1863 """A casting compiled regular expression trait.
1865
1864
1866 Accepts both strings and compiled regular expressions. The resulting
1865 Accepts both strings and compiled regular expressions. The resulting
1867 attribute will be a compiled regular expression."""
1866 attribute will be a compiled regular expression."""
1868
1867
1869 info_text = 'a regular expression'
1868 info_text = 'a regular expression'
1870
1869
1871 def validate(self, obj, value):
1870 def validate(self, obj, value):
1872 try:
1871 try:
1873 return re.compile(value)
1872 return re.compile(value)
1874 except:
1873 except:
1875 self.error(obj, value)
1874 self.error(obj, value)
General Comments 0
You need to be logged in to leave comments. Login now