def group(self):
     if isinstance(self._group, basestring):
         return self._group
     elif speaklater.is_lazy_string(self._group):
         return self._group.value
     else:
         return self._group()

	def default(self, obj):
		if is_lazy_string(obj):
			try:
				return unicode(obj) #python 2
			except NameError:
				return str(obj)  #python 3
		return super(CustomJSONEncoder, self).default(obj)

def serialize(obj, additional_attrs=(), ignore_error=False):
    """Converts some kinds of object to serilized object. (In fact, it does 
    not serialize object, but converts to generally serializable object.)
    """
    if obj is None:
        return None
    elif isinstance(obj, tuple(_user_model_map.keys())):
        for type in _user_model_map.iterkeys():
            if isinstance(obj, type):
                return _user_model_map[type](obj, additional_attrs,
                    ignore_error)
    elif callable(getattr(obj, 'serialize', None)):
        d = obj.serialize()
        d.update(_serialize_addtional(obj, additional_attrs, ignore_error))
        return d
    elif ismoduleinstance(obj, 'werkzeug.FileStorage'): # Werkzeug filestorage
        return _serialize_file_storage(obj, additional_attrs, ignore_error)
    elif isinstance(obj, datetime):
        return _serialize_date(obj, additional_attrs, ignore_error)
    elif isinstance(obj, tuple):
        return tuple(map(lambda x:serialize(x, additional_attrs, ignore_error),
            obj))
    elif isinstance(obj, (numbers.Number, basestring)):
        return obj
    elif is_lazy_string(obj):
        return u(obj)
    elif isinstance(obj, collections.Mapping):
        d={}
        for k, v in dict(obj).iteritems():
            d[k] = serialize(v, additional_attrs, ignore_error)
        return d
    elif is_list_like(obj):
        return [serialize(x, additional_attrs, ignore_error) for x in obj]
    else:
        raise NotSerializable(repr(obj))

 def _wrapper(*args, **kwargs):
     rv = f(*args, **kwargs)
     if not rv:
         return ""
     if is_lazy_string(rv):
         rv = rv.value
     return rv.encode("utf-8") if isinstance(rv, unicode) else str(rv)

 def lazy_gettext(string, **variables):
     if is_lazy_string(string):
         return string
     translations = TrytonTranslations(module, 'nereid')
     return make_lazy_string(
         translations.lazy_ugettext, string, **variables
     )

 def default(self, o):
     from speaklater import is_lazy_string
     if is_lazy_string(o):
         try:
             return unicode(o)
         except NameError:
             return str(o)
     return super(CustomJSONEncoder, self).default(o)

def _prepare_excel_data(data):
    if isinstance(data, (list, tuple)):
        data = ', '.join(data)
    elif isinstance(data, set):
        data = ', '.join(sorted(data, key=unicode.lower))
    elif is_lazy_string(data) or isinstance(data, Markup):
        data = unicode(data)
    return data

def get_message(key, **kwargs):
    rv = config_value('MSG_' + key)
    
    if is_lazy_string:
        if is_lazy_string(rv[0]):
            return unicode(rv[0]) % kwargs, rv[1]
        
    return rv[0] % kwargs, rv[1]

def test_title(db):
    user = User(first_name='Guinea', last_name='Pig')
    db.session.add(user)
    db.session.flush()
    assert user.title == ''
    user.title = UserTitle.prof
    assert user.title == UserTitle.prof.title
    assert is_lazy_string(user.title)
    assert User.find_one(title=UserTitle.prof) == user

def fix_xls_value(value):
    """
    Perform any data type fixes that must be made
    prior to sending a value to be written by the spreadsheet library
    """
    if is_lazy_string(value):
        return six.text_type(value)

    return value

def _prepare_excel_data(data, tz=None):
    if isinstance(data, (list, tuple)):
        data = ', '.join(data)
    elif isinstance(data, set):
        data = ', '.join(sorted(data, key=unicode.lower))
    elif is_lazy_string(data) or isinstance(data, Markup):
        data = unicode(data)
    elif isinstance(data, datetime):
        data = format_datetime(data, timezone=tz).decode('utf-8')
    return data

 def default(self, obj):
     if is_lazy_string(obj):
         return unicode(obj)
     elif isinstance(obj, bson.objectid.ObjectId):
         return str(obj)
     elif isinstance(obj, datetime.datetime):
         return obj.isoformat()
     elif hasattr(obj, 'serialize'):
         return obj.serialize()
     elif hasattr(obj, '_data'): # Serialize Raw data for Document and EmbeddedDocument
         return obj._data
     return super(UDataJsonEncoder, self).default(obj)

 def encode(self, obj, *args, **kwargs):
     if isinstance(obj, dict):
         new_obj = type(obj)()
         for key, value in six.iteritems(obj):
             if is_lazy_string(key):
                 try:
                     key = unicode(key)
                 except NameError:
                     key = str(key)
             new_obj[key] = value
         obj = new_obj 
     return super(JSONEncoder, self).encode(obj, *args, **kwargs)

 def _validate(var):
     if isinstance(var, (tuple, list)):
         for i, v in enumerate(var):
             var[i] = _validate(v)
     elif isinstance(var, dict):
         for k in var:
             var[k] = _validate(var[k])
     else:
         if is_lazy_string(var):
             return unicode(var)
         return var
     return var

 def default(self, obj):
     if is_lazy_string(obj):
         return unicode(obj)
     elif isinstance(obj, bson.objectid.ObjectId):
         return str(obj)
     elif isinstance(obj, datetime.datetime):
         return obj.isoformat()
     elif hasattr(obj, 'to_dict'):
         return obj.to_dict()
     elif hasattr(obj, 'serialize'):
         return obj.serialize()
     # Serialize Raw data for Document and EmbeddedDocument.
     elif hasattr(obj, '_data'):
         return obj._data
     # Serialize raw data from Elasticsearch DSL AttrList
     elif hasattr(obj, '_l_'):
         return obj._l_
     return super(UDataJsonEncoder, self).default(obj)

def flash(message, category='message'):
    """
    Lazy strings are no real strings so pickling them results in strange issues.
    Pickling cannot be avoided because of the way sessions work. Hence, this
    special flash function converts lazy strings to unicode content.

    .. versionadded:: 3.0.4.1

    :param message: the message to be flashed.
    :param category: the category for the message.  The following values
                     are recommended: ``'message'`` for any kind of message,
                     ``'error'`` for errors, ``'info'`` for information
                     messages and ``'warning'`` for warnings.  However any
                     kind of string can be used as category.
    """
    if is_lazy_string(message):
        message = unicode(message)
    return _flash(message, category)

    def prepare(self):
        super(CookieConsentWidget, self).prepare()

        if self.options:
            cfg = self.options
        else:
            cfg = self.default_options

        # always use full URLs for themes
        theme = cfg.get('theme', 'light-floating')
        rl = request_local()
        cfg['theme'] = (
            rl['middleware'].config.res_prefix + 'tw2.cookieconsent/static/'
            + theme + ".css")

        # evaluate any lazy strings
        for key, value in cfg.items():
            if is_lazy_string(value):
                cfg[key] = str(value)

        self.add_call(js_function(
            "(function(window,cfg){window.cookieconsent_options=cfg;})"
        )(js_symbol("window"), cfg), location='head')
        inject_resources()

 def lazy_gettext(string, *args, **kwargs):
     if is_lazy_string(string):
         return string
     return make_lazy_string(lookup_func(), string, *args, **kwargs)

 def default(self, obj):
     from speaklater import is_lazy_string
     if is_lazy_string(obj):
         return str(obj)  # python 3
     return super(CustomJSONEncoder, self).default(obj)

    def scaffold_filters(self, name):
        """
            Return list of enabled filters
        """

        attr, joins = tools.get_field_with_path(self.model, name)

        if attr is None:
            raise Exception('Failed to find field for filter: %s' % name)

        # Figure out filters for related column
        if is_relationship(attr):
            filters = []

            for p in self._get_model_iterator(attr.property.mapper.class_):
                if hasattr(p, 'columns'):
                    # TODO: Check for multiple columns
                    column = p.columns[0]

                    if column.foreign_keys or column.primary_key:
                        continue

                    visible_name = '%s / %s' % (self.get_column_name(attr.prop.table.name),
                                                self.get_column_name(p.key))

                    type_name = type(column.type).__name__
                    flt = self.filter_converter.convert(type_name,
                                                        column,
                                                        visible_name)

                    if flt:
                        table = column.table

                        if joins:
                            self._filter_joins[column] = joins
                        elif tools.need_join(self.model, table):
                            self._filter_joins[column] = [table]

                        filters.extend(flt)

            return filters
        else:
            is_hybrid_property = tools.is_hybrid_property(self.model, name)
            if is_hybrid_property:
                column = attr
                if isinstance(name, string_types):
                    column.key = name.split('.')[-1]
            else:
                columns = tools.get_columns_for_field(attr)

                if len(columns) > 1:
                    raise Exception('Can not filter more than on one column for %s' % name)

                column = columns[0]

            # If filter related to relation column (represented by
            # relation_name.target_column) we collect here relation name
            joined_column_name = None
            if '.' in name:
                joined_column_name = name.split('.')[0]

            # Join not needed for hybrid properties
            if (not is_hybrid_property and tools.need_join(self.model, column.table) and
                    name not in self.column_labels):
                if joined_column_name:
                    visible_name = '%s / %s / %s' % (
                        joined_column_name,
                        self.get_column_name(column.table.name),
                        self.get_column_name(column.name)
                    )
                else:
                    visible_name = '%s / %s' % (
                        self.get_column_name(column.table.name),
                        self.get_column_name(column.name)
                    )
            else:
                if not isinstance(name, string_types):
                    visible_name = self.get_column_name(name.property.key)
                else:
                    column_name = self.get_column_name(name)

                    def prettify():
                        return column_name.replace('.', ' / ')
                    if is_lazy_string(column_name):
                        visible_name = make_lazy_string(prettify)
                    else:
                        visible_name = prettify()

            type_name = type(column.type).__name__

            flt = self.filter_converter.convert(
                type_name,
                column,
                visible_name,
                options=self.column_choices.get(name),
            )

            key_name = column
            # In case of filter related to relation column filter key
            # must be named with relation name (to prevent following same
#.........这里部分代码省略.........