1
2
3
4
5
6
7
8
9
10
11 """
12 Type checking for the Vision Egg.
13
14 """
15
16 import VisionEgg
17
18 import types, warnings
19 import numpy
20 import numpy.oldnumeric as numpyNumeric
21
22 array_types = [numpy.ndarray]
23
24 try:
25 import numarray
26 array_types.append( numarray.numarraycore.NumArray )
27 except ImportError:
28 pass
29 try:
30 import Numeric as orig_Numeric
31 array_types.append( orig_Numeric.ArrayType )
32 except ImportError:
33 pass
34
36 """Base class for all parameter type definitions"""
38
39 raise RuntimeError('must override base class method verify')
40 verify = staticmethod(verify)
41
43
44 result = [klass]
45 for base_klass in klass.__bases__:
46 result.extend(get_all_classes_list(base_klass))
47 return result
48
50 if type(item_type) == types.ClassType:
51 if Sequence in get_all_classes_list(item_type):
52 raise TypeError("Sequence definition must be an instance (with a contained type).")
53 else:
54 return ParameterTypeDef in get_all_classes_list(item_type)
55 elif isinstance(item_type,ParameterTypeDef):
56 return True
57 elif issubclass(item_type,ParameterTypeDef):
58 return True
59 elif item_type == types.NoneType:
60 warnings.warn("types.NoneType will stop being a supported type "+\
61 "argument. Please call "+\
62 "VisionEgg.ParameterTypes.get_type(None) to get the "+\
63 "supported value",DeprecationWarning,stacklevel=2)
64 return True
65 else:
66 return False
67
68 -class AnyOf(ParameterTypeDef):
70 for item_type in item_types:
71 if not is_parameter_type_def(item_type):
72 raise TypeError("%s is not a valid type definition")
73 self.item_types = item_types
75 return 'AnyOf(%s)'%(' or '.join(map(str,self.item_types)))
77 for item_type in self.item_types:
78 if item_type.verify(is_any_of):
79 return True
80 return False
82 return self.item_types
83
85 """metaclass for NoneType"""
88
94
96 """metaclass for Boolean"""
99
101 __metaclass__ = BooleanMC
103 if isinstance(is_boolean,(bool,int,numpy.integer)):
104 return True
105 else:
106 return False
107 verify = staticmethod(verify)
108
110 """metaclass for Callable"""
113
119
121 """metaclass for AnyClass"""
124
126 """parameter is a class"""
127 __metaclass__ = AnyClassMC
129 return type(is_class) == types.ClassType
130 verify = staticmethod(verify)
131
133 """parameter is derived from base_class"""
135 if type(base_class) != types.ClassType:
136 raise TypeError("base_class must be ClassType")
137 self.base_class = base_class
139 if type(self.base_class) != types.ClassType:
140 return False
141 return self.base_class in get_all_classes_list(is_class)
143 return 'SubClass of %s'%str(self.base_class)
144
146 """parameter is an instance of class_type"""
148 if type(class_type) not in (types.ClassType, types.TypeType):
149 raise TypeError("expected a class type")
150 self.class_type = class_type
152 contained_string = str(self.class_type)
153 return 'Instance of %s'%contained_string
154 - def verify(self,is_instance):
155 return isinstance(is_instance,self.class_type)
156
158 """metaclass for Integer"""
161
167
169 """metaclass for UnsignedInteger"""
171 return 'UnsignedInteger'
172
180
182 """metaclass for Real"""
185
186 -class Real(ParameterTypeDef):
187 __metaclass__ = RealMC
189 if isinstance(is_real, (int, float, numpy.floating, numpy.integer)):
190 return True
191 elif type(is_real) in array_types:
192
193 if len(is_real.shape)==0:
194 try:
195 float(is_real)
196 return True
197 except:
198 return False
199 return False
200 verify = staticmethod(verify)
201
203 """A tuple, list or Numeric array"""
205 if not is_parameter_type_def(item_type):
206 raise TypeError("%s is not a valid type definition"%item_type)
207 self.item_type = item_type
209 contained_string = str(self.item_type)
210 return 'Sequence of %s'%contained_string
211 - def verify(self,is_sequence):
212 try:
213 len(is_sequence)
214 except TypeError:
215 return False
216 for i in xrange(len(is_sequence)):
217 if not self.item_type.verify(is_sequence[i]):
218 return False
219 return True
220
223 contained_string = str(self.item_type)
224 return 'Sequence2 of %s'%contained_string
225 - def verify(self,is_sequence2):
226 if not Sequence.verify(self,is_sequence2):
227 return False
228 if not len(is_sequence2) == 2:
229 return False
230 return True
231
234 contained_string = str(self.item_type)
235 return 'Sequence3 of %s'%contained_string
236 - def verify(self,is_sequence3):
237 if not Sequence.verify(self,is_sequence3):
238 return False
239 if not len(is_sequence3) == 3:
240 return False
241 return True
242
245 contained_string = str(self.item_type)
246 return 'Sequence4 of %s'%contained_string
247 - def verify(self,is_sequence4):
248 if not Sequence.verify(self,is_sequence4):
249 return False
250 if not len(is_sequence4) == 4:
251 return False
252 return True
253
256 contained_string = str(self.item_type)
257 return 'Sequence4x4 of %s'%contained_string
258 - def verify(self,is_sequence4x4):
259 try:
260 len(is_sequence4x4)
261 except TypeError:
262 return False
263 if not len(is_sequence4x4) == 4:
264 return False
265 for i in range(4):
266 if not Sequence4.verify(self,is_sequence4x4[i]):
267 return False
268 return True
269
271 """metaclass for String"""
274
275 -class String(ParameterTypeDef):
276 __metaclass__ = StringMC
278 if isinstance(is_string,str):
279 return True
280 else:
281 return False
282 verify = staticmethod(verify)
283
285 """metaclass for Unicode"""
288
290 __metaclass__ = UnicodeMC
292 if isinstance(is_unicode,unicode):
293 return True
294 else:
295 return False
296 verify = staticmethod(verify)
297
299 """Take a value and return best guess of ParameterTypeDef it is."""
300 py_type = type(value)
301
302 if isinstance(value,bool):
303 return Boolean
304 elif value is None:
305 return NoneType
306 elif isinstance(value,(int,numpy.integer)):
307 if py_type >= 0:
308 return UnsignedInteger
309 else:
310 return Integer
311 elif isinstance(value,(float,numpy.floating)):
312 return Real
313 elif py_type == types.InstanceType:
314
315 return Instance(value.__class__)
316 elif callable(value):
317 return Callable
318 else:
319 try:
320 len(value)
321 except TypeError:
322 is_sequence = False
323 else:
324 is_sequence = True
325 if is_sequence:
326 if len(value) == 4:
327
328 is_sequence4x4 = True
329 for i in range(4):
330 try:
331 len(value[i])
332 except TypeError:
333 is_sequence4x4 = False
334 if is_sequence4x4:
335 sequence4x4_type = get_type(value[0][0])
336 return Sequence4x4(sequence4x4_type)
337 if type(value) == str:
338 return String
339 lcd_type = get_type(value[0])
340 for i in range(len(value)):
341 this_type = get_type(value[i])
342 if lcd_type != this_type:
343
344 if lcd_type.verify( this_type ):
345 continue
346 elif this_type.verify( lcd_type ):
347 lcd_type = this_type
348 else:
349 lcd_type = AnyOf( lcd_type, this_type )
350 sequence_type = lcd_type
351 if len(value) == 2:
352 return Sequence2(sequence_type)
353 elif len(value) == 3:
354 return Sequence3(sequence_type)
355 elif len(value) == 4:
356 return Sequence4(sequence_type)
357 else:
358 return Sequence(sequence_type)
359
360 if isinstance(value, object):
361
362
363 return Instance(value.__class__)
364 else:
365 raise TypeError("Unable to determine type for '%s'"%value)
366
368 if not is_parameter_type_def(check_type):
369 raise ValueError("require a ParameterTypeDef as argument (not %s)"%check_type)
370 if not is_parameter_type_def(require_type):
371 raise ValueError("require a ParameterTypeDef as argument (not %s)"%require_type)
372 if check_type == require_type:
373 return
374
375 if check_type in (Integer,UnsignedInteger) and require_type == Boolean:
376 return
377
378 if isinstance(check_type,ParameterTypeDef):
379 check_class = check_type.__class__
380 else:
381 check_class = check_type
382
383 if isinstance(require_type,ParameterTypeDef):
384 if isinstance(require_type,AnyOf):
385 passed = False
386 for ok_type in require_type.get_item_types():
387 try:
388 assert_type(check_type, ok_type )
389 return
390 except:
391 pass
392 else:
393 require_class = require_type.__class__
394 else:
395 require_class = require_type
396
397 if require_class in get_all_classes_list(check_class):
398 return
399
400 if issubclass(require_class,Real):
401 if issubclass(check_class,Boolean):
402 return
403 elif issubclass(check_class,Integer):
404 return
405
406 if issubclass(require_class,Integer):
407 if issubclass(check_class,Boolean):
408 return
409
410 raise TypeError("%s not of type %s"%(check_type,require_type))
411