def validate_configuration_setting(specification, name, value): if not isinstance(value, specification.type): if isinstance(specification.type, type): type_names = specification.type.__name__ else: type_names = ', '.join( imap(lambda t: t.__name__, specification.type)) raise ValueError('Expected {} value, not {}={}'.format( type_names, name, repr(value))) if specification.constraint and not specification.constraint(value): raise ValueError('Illegal value: {}={}'.format(name, repr(value))) return value
def iteritems(self): iteritems = SearchCommand.ConfigurationSettings.iteritems(self) version = self.command.protocol_version if version == 1: if self.required_fields is None: iteritems = ifilter(lambda name_value: name_value[0] != 'clear_required_fields', iteritems) else: iteritems = ifilter(lambda name_value2: name_value2[0] != 'distributed', iteritems) if not self.distributed: iteritems = imap( lambda name_value1: (name_value1[0], 'stateful') if name_value1[0] == 'type' else (name_value1[0], name_value1[1]), iteritems) return iteritems
def iteritems(self): iteritems = SearchCommand.ConfigurationSettings.iteritems(self) version = self.command.protocol_version if version == 2: iteritems = ifilter( lambda name_value1: name_value1[0] != 'distributed', iteritems) if not self.distributed and self.type == 'streaming': iteritems = imap( lambda name_value: (name_value[0], 'stateful') if name_value[0] == 'type' else (name_value[0], name_value[1]), iteritems) return iteritems
def __repr__(self): text = 'Option.View([' + ','.join(imap(lambda item: repr(item), six.itervalues(self))) + '])' return text
def fix_up(cls, values): is_configuration_setting = lambda attribute: isinstance(attribute, ConfigurationSetting) definitions = getmembers(cls, is_configuration_setting) i = 0 for name, setting in definitions: if setting._name is None: setting._name = name = six.text_type(name) else: name = setting._name validate, specification = setting._get_specification() backing_field_name = '_' + name if setting.fget is None and setting.fset is None and setting.fdel is None: value = setting._value if setting._readonly or value is not None: validate(specification, name, value) def fget(bfn, value): return lambda this: getattr(this, bfn, value) setting = setting.getter(fget(backing_field_name, value)) if not setting._readonly: def fset(bfn, validate, specification, name): return lambda this, value: setattr(this, bfn, validate(specification, name, value)) setting = setting.setter(fset(backing_field_name, validate, specification, name)) setattr(cls, name, setting) def is_supported_by_protocol(supporting_protocols): def is_supported_by_protocol(version): return version in supporting_protocols return is_supported_by_protocol del setting._name, setting._value, setting._readonly setting.is_supported_by_protocol = is_supported_by_protocol(specification.supporting_protocols) setting.supporting_protocols = specification.supporting_protocols setting.backing_field_name = backing_field_name definitions[i] = setting setting.name = name i += 1 try: value = values[name] except KeyError: continue if setting.fset is None: raise ValueError('The value of configuration setting {} is fixed'.format(name)) setattr(cls, backing_field_name, validate(specification, name, value)) del values[name] if len(values) > 0: settings = sorted(list(six.iteritems(values))) settings = imap(lambda n_v: '{}={}'.format(n_v[0], repr(n_v[1])), settings) raise AttributeError('Inapplicable configuration settings: ' + ', '.join(settings)) cls.configuration_setting_definitions = definitions
def _write_record(self, record): fieldnames = self._fieldnames if fieldnames is None: self._fieldnames = fieldnames = list(record.keys()) value_list = imap(lambda fn: (str(fn), str('__mv_') + str(fn)), fieldnames) self._writerow(list(chain.from_iterable(value_list))) get_value = record.get values = [] for fieldname in fieldnames: value = get_value(fieldname, None) if value is None: values += (None, None) continue value_t = type(value) if issubclass(value_t, (list, tuple)): if len(value) == 0: values += (None, None) continue if len(value) > 1: value_list = value sv = '' mv = '$' for value in value_list: if value is None: sv += '\n' mv += '$;$' continue value_t = type(value) if value_t is not bytes: if value_t is bool: value = str(value.real) elif value_t is six.text_type: value = value elif value_t is int or value_t is int or value_t is float or value_t is complex: value = str(value) elif issubclass(value_t, (dict, list, tuple)): value = str(''.join( RecordWriter._iterencode_json(value, 0))) else: value = repr(value).encode( 'utf-8', errors='backslashreplace') sv += value + '\n' mv += value.replace('$', '$$') + '$;$' values += (sv[:-1], mv[:-2]) continue value = value[0] value_t = type(value) if value_t is bool: values += (str(value.real), None) continue if value_t is bytes: values += (value, None) continue if value_t is six.text_type: if six.PY2: value = value.encode('utf-8') values += (value, None) continue if value_t is int or value_t is int or value_t is float or value_t is complex: values += (str(value), None) continue if issubclass(value_t, dict): values += (str(''.join(RecordWriter._iterencode_json(value, 0))), None) continue values += (repr(value), None) self._writerow(values) self._record_count += 1 if self._record_count >= self._maxresultrows: self.flush(partial=True)
def iteritems(self): iteritems = SearchCommand.ConfigurationSettings.iteritems(self) return imap(lambda name_value: (name_value[0], 'events' if name_value[0] == 'type' else name_value[1]), iteritems)