The seq property.
        
        Args:
            value (string). the property value.
328153
def seq(self, value):
        
        if value == self._defaults['seq'] and 'seq' in self._values:
            del self._values['seq']
        else:
            self._values['seq'] = value
666305
def distinct_on(self, value):
        
        if isinstance(value, str):
            value = [value]
        self._distinct_on[:] = value
1353570
def value(self, value):
        
        args = (self.__ptr, int(value))
        _ec.metric_set(args)
1322086
public void setValue(CharSequence value, int offset, int len) {
		Validate.notNull(value);
		if (offset < 0 || len < 0 || offset > value.length() - len) {
			throw new IndexOutOfBoundsException("offset: " + offset + " len: " + len + " value.len: " + len);
		}

		ensureSize(len);
		this.len = len;		
		for (int i = 0; i < len; i++) {
			this.value[i] = value.charAt(offset + i);
		}
		this.len = len;
		this.hashCode = 0;
	}
691074
private void appendValue(Object value) {
        if (value == null) {
            append("null");
        } else if (value instanceof MwsObject) {
            append("{");
            needComma = false;
            ((MwsObject) value).writeFragmentTo(this);
            append("}");
        } else if (value instanceof Boolean || value instanceof Number) {
            append(value.toString());
        } else if (value instanceof String) {
            append("\"");
            escape((String) value);
            append("\"");
        } else if (value instanceof Node) {
            appendValue(MwsUtl.toXmlString((Node) value));
        } else if (value instanceof XMLGregorianCalendar) {
            append(((XMLGregorianCalendar) value).toXMLFormat());
        } else if (value instanceof Enum) {
            append(value.toString());
        } else {
            throw new IllegalArgumentException("Unsupported type "+value.getClass().getName());
        }
        needComma = true;
    }
613445
def sequential(value)
      index = index_variable_for(value)
      index = (index ? index + 1 : 0)
      index = 0 if index == value.length
      set_index_variable(value, index)
      value[index]
    end
1258028
def setCurrentValue(self, value):
        
        enum = self.enum()
        if not enum:
            return
        
        if self.isCheckable():
            indexes = []
            for i in range(self.count()):
                try:
                    check_value = enum[nativestring(self.itemText(i))]
                except KeyError:
                    continue
                
                if check_value & value:
                    indexes.append(i)
            self.setCheckedIndexes(indexes)
        else:
            try:
                text = enum[value]
            except (AttributeError, KeyError):
                return
            
            self.setCurrentIndex(self.findText(text))
1002645
public void setValue(CharSequence value) {
		Validate.notNull(value);
		setValue(value, 0, value.length());
	}
232634
def key_on(self, value):
        
        if isinstance(value, BASESTRING):
            value = (value,)
        self._key_on = value
108313
public void setValue(Object value) {
    if (value instanceof Iterable<?>) {
      this.value = stream((Iterable<?>) value).map(this::toValue).collect(toList());
    } else {
      this.value = toValue(value);
    }
  }
876831
def line(self, value):
        
        if value == self._defaults['line'] and 'line' in self._values:
            del self._values['line']
        else:
            self._values['line'] = value
1056705
def check(self, inst, value):
        
        if not (self.or_none and value is None):
            if self.seq:
                self.checktype_seq(value, self.kind,
                                   unique=self.unique, inst=inst)
            else:
                self.checktype(value, self.kind, inst=inst)
312306
def insert (self, properties, value):
        
        assert is_iterable_typed(properties, basestring)
        assert isinstance(value, basestring)
        self.__properties.append(properties)
        self.__values.append(value)
974652
def startswith(self, event_property, value):
        
        c = self.copy()
        c.filters.append(filters.RE(event_property, "^{value}".format(
            value=value)))
        return c
317223
def set(self, value):
        

        if not isinstance(value, int_types) and not isinstance(value, str_cls):
            raise TypeError(unwrap(
                '''
                %s value must be an integer or a unicode string, not %s
                ''',
                type_name(self),
                type_name(value)
            ))

        if isinstance(value, str_cls):
            if value not in self._reverse_map:
                raise ValueError(unwrap(
                    '''
                    %s value "%s" is not a valid value
                    ''',
                    type_name(self),
                    value
                ))

            value = self._reverse_map[value]

        elif value not in self._map:
            raise ValueError(unwrap(
                '''
                %s value %s is not a valid value
                ''',
                type_name(self),
                value
            ))

        Integer.set(self, value)
160071
def run(self, value):
        
        if self.pass_ and not value.strip():
            return True

        if len((value.strip() if self.strip else value)) != self.length:
            self.error = self.error.format(value, self.length)
            return False
        return True
559677
def get_prep_value(self, value):
        
        if isinstance(value, six.string_types):
            return value
        else:
            return ', '.join(map(lambda s: s.strip(), value))