Setter for **self.__splitters** attribute.

        :param value: Attribute value.
        :type value: tuple or list
396
def splitters(self, value):
        

        if value is not None:
            assert type(value) in (tuple, list), "'{0}' attribute: '{1}' type is not 'tuple' or 'list'!".format(
                "splitters", value)
            for element in value:
                assert type(element) is unicode, "'{0}' attribute: '{1}' type is not 'unicode'!".format(
                    "splitters", element)
                assert len(element) == 1, "'{0}' attribute: '{1}' has multiples characters!".format(
                    "splitter", element)
                assert not re.search(r"\w", element), "'{0}' attribute: '{1}' is an alphanumeric character!".format(
                    "splitter", element)
        self.__splitters = value
1289982
def instance_set(attribute, value)
      setter = :"#{self.name}_#{attribute}="
      self.instance.send(setter, value) if instance.respond_to?(setter)
    end
1341764
def split_input(val, mapper=None):
    '''
    
    '''
    if mapper is None:
        mapper = lambda x: x
    if isinstance(val, list):
        return list(map(mapper, val))
    try:
        return list(map(mapper, [x.strip() for x in val.split(',')]))
    except AttributeError:
        return list(map(mapper, [x.strip() for x in six.text_type(val).split(',')]))
91607
def version(self, value):
        
        if isinstance(value, tuple):
            value = unparse_version(value)

        self._version = value
177566
def formats(self, value):
        

        if value is not None:
            assert type(value) is FormatsTree, "'{0}' attribute: '{1}' type is not 'FormatsTree'!".format(
                "formats", value)
        self.__formats = value
201293
def set_value(self, value):
        
        self.raw_value = self.preference.serializer.serialize(value)
792002
def target(self, value):
        
        if value == self._defaults['target'] and 'target' in self._values:
            del self._values['target']
        else:
            self._values['target'] = value
567369
def validate(self, value):
        
        if not isinstance(value, (list, tuple)) or isinstance(value, str_types):
            self.raise_error('Only lists and tuples may be used in the ListField vs provided {0}'
                             .format(type(value).__name__))
        super(ListField, self).validate(value)
1182002
def type(self, value):
        
        if value not in list(defines.Types.values()):
            raise AttributeError
        self._type = value
702466
def set_lane_list(self, value):
        
        if value is None or not isinstance(value, list):
            raise TypeError("LaneList new value must be a list")
        else:
            for element in value:
                if not isinstance(element, lane.Lane):
                    raise TypeError("LaneList elements in variable must be of Lane class")
            self.__lane_list = value
310703
def set_value(self, value: datetime):
        
        assert isinstance(value, datetime)

        self.value = value
1133805
def split(self, value=10, unit=None):  # noqa: F811
        
        if type(value) == int and unit is None:
            # default value is 10 m
            unit = "m"

        for data in _split(self.data, value, unit):
            yield self.__class__(data)
740266
def labels(self, value):
        
        if value is not None:
            assert type(value) is tuple, "'{0}' attribute: '{1}' type is not 'tuple'!".format("labels", value)
            assert len(value) == 2, "'{0}' attribute: '{1}' length should be '2'!".format("labels", value)
            for index in range(len(value)):
                assert type(value[index]) is unicode, \
                    "'{0}' attribute element '{1}': '{2}' type is not 'unicode'!".format("labels", index, value)
        self.__labels = value
385108
def as_tuple(self, value):
        """"""
        if isinstance(value, list):
            value = tuple(value)
        return value
117650
def __wrap_accepted_val(self, value):
        
        if isinstance(value, tuple):
            value = list(value)
        elif not isinstance(value, list):
            value = [value]
        return value
22613
def namespace_splitter(self, value):
        

        if value is not None:
            assert type(value) is unicode, "'{0}' attribute: '{1}' type is not 'unicode'!".format(
                "namespace_splitter", value)
            assert len(value) == 1, "'{0}' attribute: '{1}' has multiples characters!".format("namespace_splitter",
                                                                                              value)
            assert not re.search(r"\w", value), "'{0}' attribute: '{1}' is an alphanumeric character!".format(
                "namespace_splitter", value)
        self.__namespace_splitter = value
697324
def set_flow_element_list(self, value):
        
        if value is None or not isinstance(value, list):
            raise TypeError("FlowElementList new value must be a list")
        else:
            for element in value:
                if not isinstance(element, flow_element.FlowElement):
                    raise TypeError("FlowElementList elements in variable must be of FlowElement class")
            self.__flow_element_list = value