Ejemplo n.º 1
0
 def validate_type(self, key, value, definition):
     if value in ('?', '.'): return
     item_type = definition.type
     if item_type in self.item_type_list:
         match = re.match(self.item_type_list[item_type], value)
         if match is None:
             self.report_error(2001,
                               key=key,
                               value=value,
                               item_type=item_type)
     elif item_type == 'numb':
         # only for DDL1
         try:
             builders.float_from_string(value)
         except Exception as e:
             # can't interpret as numb
             self.report_error(2001,
                               key=key,
                               value=value,
                               item_type=definition.type)
         else:
             # check any type conditions
             type_condition = definition.type_conditions
             if type_condition not in ('esd', 'su'):
                 try:
                     float(value)
                 except Exception as e:
                     # if we have got here, then from the data type checking we can assume
                     # that the value is given with an esd, which causes it to be invalid.
                     self.report_error(2002, key=key)
Ejemplo n.º 2
0
 def validate_enumeration(self, key, value, definition):
     if isinstance(value, string_types):
         values = [value]
     else:
         values = value
     enum_values = definition.enumeration
     enum_min, enum_max = definition.get_min_max()
     if enum_values is None and enum_max is None and enum_min is None:
         return  # nothing to check
     for value in values:
         if value in ('.', '?'): continue
         elif enum_values is not None and value not in enum_values:
             enum_lower = [v.lower() for v in enum_values]
             if value.lower() in enum_lower:
                 self.report_error(
                     1002, key=key,
                     value=value)  # case sensitive match failure
             else:
                 # invalid choice for enumeration
                 self.report_error(2102,
                                   key=key,
                                   value=value,
                                   enum=tuple(enum_values))
         if definition.type in ('numb', 'float', 'int'):
             try:
                 v = builders.float_from_string(value)
             except Exception:
                 return  # this error is handled with elsewhere
             # DDL1 range is inclusive, DDL2 is exclusive
             if self.DDL_version == 1:
                 if not ((enum_min is None or v >= float(enum_min)) and
                         (enum_max is None or v <= float(enum_max))):
                     self.report_error(2101,
                                       key=key,
                                       value=value,
                                       enum="%s:%s" % (enum_min, enum_max))
             else:
                 if enum_min is None and enum_max is None: return
                 elif enum_min is None:
                     enum_min = '.' * len(enum_max)
                 elif enum_max is None:
                     enum_max = '.' * len(enum_min)
                 for min, max in zip(enum_min, enum_max):
                     if ((min == '.' or v > float(min))
                             and (max == '.' or v < float(max))):
                         return  # at least one condition was met, so value is inside range
                     elif (min == max and v == float(min)):
                         return  # matched boundary value
                 # else value out of range
                 self.report_error(2101,
                                   key=key,
                                   value=value,
                                   enum="%s:%s" % (min, max))
Ejemplo n.º 3
0
 def validate_type(self, key, value, definition):
   if value in ('?', '.'): return
   item_type = definition.type
   if item_type in self.item_type_list:
     match = re.match(self.item_type_list[item_type], value)
     if match is None:
       self.report_error(2001, key=key, value=value, item_type=item_type)
   elif item_type == 'numb':
     # only for DDL1
     try:
       builders.float_from_string(value)
     except Exception, e:
       # can't interpret as numb
       self.report_error(2001, key=key, value=value, item_type=definition.type)
     else:
       # check any type conditions
       type_condition = definition.type_conditions
       if type_condition not in ('esd', 'su'):
         try:
           float(value)
         except Exception, e:
           # if we have got here, then from the data type checking we can assume
           # that the value is given with an esd, which causes it to be invalid.
           self.report_error(2002, key=key)
Ejemplo n.º 4
0
 def validate_enumeration(self, key, value, definition):
   if isinstance(value, basestring):
     values = [value]
   else:
     values = value
   enum_values = definition.enumeration
   enum_min, enum_max = definition.get_min_max()
   if enum_values is None and enum_max is None and enum_min is None:
     return # nothing to check
   for value in values:
     if value in ('.', '?'): continue
     elif enum_values is not None and value not in enum_values:
       enum_lower = [v.lower() for v in enum_values]
       if value.lower() in enum_lower:
         self.report_error(1002, key=key, value=value) # case sensitive match failure
       else:
         # invalid choice for enumeration
         self.report_error(2102, key=key, value=value, enum=tuple(enum_values))
     if definition.type in ('numb', 'float', 'int'):
       try:
         v = builders.float_from_string(value)
       except Exception: return # this error is handled with elsewhere
       # DDL1 range is inclusive, DDL2 is exclusive
       if self.DDL_version == 1:
         if not ((enum_min is None or v >= float(enum_min)) and
                 (enum_max is None or v <= float(enum_max))):
           self.report_error(
             2101, key=key, value=value, enum="%s:%s" %(enum_min, enum_max))
       else:
         if enum_min is None and enum_max is None: return
         elif enum_min is None:
           enum_min = '.'*len(enum_max)
         elif enum_max is None:
           enum_max = '.'*len(enum_min)
         for min, max in zip(enum_min, enum_max):
           if ((min == '.' or v > float(min)) and
               (max == '.' or v < float(max))):
             return # at least one condition was met, so value is inside range
           elif (min == max and v == float(min)):
             return # matched boundary value
         # else value out of range
         self.report_error(2101, key=key, value=value, enum="%s:%s" %(min, max))