Python compat.text_type函数代码示例

    def __call__(self, field, **kwargs):
        html = []
        kwargs.setdefault('id', field.id)
        with_div = True
        expended = False

        exp_text = 'style=display:none' if expended else ''

        if with_div:
            html.append('<div>')
        html.append('<span %s>' % widgets.html_params(**kwargs))
        hidden = ''
        html.append('<span class="range-span">')
        for subfield in field:
            if subfield.type == 'HiddenField':
                hidden += text_type(subfield)
            else:
                html.append('<div class="range-div">%s%s</div>' % (hidden, text_type(subfield)))
                hidden = ''

        html.append('</span>')
        html.append('<button type="button" class="btn btn-default btn-sm" id="%s-toggle-button"  name="%s-toggle-button" style="font-size: 16px;">' % (field.name, field.name))
        html.append('  <span></span>')
        html.append('</button>')
        html.append('</span>')

        if with_div:
            html.append('</div>')

        if hidden:
            html.append(hidden)

        return widgets.HTMLString(''.join(html))

def html_params(**kwargs):
    """
    This is Verbatim from WTForms BUT "aria_" is handled like "data_"

    Generate HTML attribute syntax from inputted keyword arguments.
    The output value is sorted by the passed keys, to provide consistent output
    each time this function is called with the same parameters. Because of the
    frequent use of the normally reserved keywords `class` and `for`, suffixing
    these with an underscore will allow them to be used.
    In order to facilitate the use of ``data-`` attributes, the first underscore
    behind the ``data``-element is replaced with a hyphen.
    >>> html_params(data_any_attribute='something')
    'data-any_attribute="something"'
    In addition, the values ``True`` and ``False`` are special:
      * ``attr=True`` generates the HTML compact output of a boolean attribute,
        e.g. ``checked=True`` will generate simply ``checked``
      * ``attr=False`` will be ignored and generate no output.
    >>> html_params(name='text1', id='f', class_='text')
    'class="text" id="f" name="text1"'
    >>> html_params(checked=True, readonly=False, name="text1", abc="hello")
    'abc="hello" checked name="text1"'
    """
    params = []
    for k, v in sorted(iteritems(kwargs)):
        if k in ('class_', 'class__', 'for_'):
            k = k[:-1]
        elif k.startswith('data_') or k.startswith('aria_') :
            k = k.replace('_', '-', 1)
        if v is True:
            params.append(k)
        elif v is False:
            pass
        else:
            params.append('%s="%s"' % (text_type(k), escape(text_type(v), quote=True)))
    return ' '.join(params)

def html_params(**kwargs):
    """
    Generate HTML attribute syntax from inputted keyword arguments.

    The output value is sorted by the passed keys, to provide consistent output
    each time this function is called with the same parameters. Because of the
    frequent use of the normally reserved keywords `class` and `for`, suffixing
    these with an underscore will allow them to be used.

    In addition, the values ``True`` and ``False`` are special:
      * ``attr=True`` generates the HTML compact output of a boolean attribute,
        e.g. ``checked=True`` will generate simply ``checked``
      * ``attr=`False`` will be ignored and generate no output.

    >>> html_params(name='text1', id='f', class_='text')
    'class="text" id="f" name="text1"'
    >>> html_params(checked=True, readonly=False, name="text1", abc="hello")
    'abc="hello" checked name="text1"'
    """
    params = []
    for k, v in sorted(iteritems(kwargs)):
        if k in ('class_', 'class__', 'for_'):
            k = k[:-1]
        if v is True:
            params.append(k)
        elif v is False:
            pass
        else:
            params.append('%s="%s"' % (text_type(k), escape(text_type(v), quote=True)))
    return ' '.join(params)

    def __call__(self, field, **kwargs):

        rendered = []
        rendered.append('<table class="%s">' % kwargs.pop('table_class', 'table'))
        rendered.append('<thead>')
        rendered.append('<tr>')
        rendered.append('<th>%s</th>' % field.label)
        for value, label in field.choices:
            rendered.append('<th>%s</th>' % label)
        rendered.append('</th>')
        rendered.append('</thead>')
        rendered.append('<tbody>')
        for name, title in field.fields:
            rendered.append('<tr>')
            rendered.append('<td>%s</td>' % title)
            selected = field.data.get(name)
            for value, label in field.choices:
                params = {'type': 'radio', 'name': name, 'value': value}
                if text_type(selected) == text_type(value):
                    params['checked'] = True
                rendered.append('<td><input %s/></td>' % wtforms.widgets.html_params(**params))
            rendered.append('</tr>')
        rendered.append('</tbody>')
        rendered.append('</table>')

        return Markup('\n'.join(rendered))

 def __call__(self, field, class_='', row_class='row', **kwargs):
     """
     There are Bootstrap 3 specific improvements for row wrapping.
     """
     html = []
     hidden = ''
     arguments = self.defaults
     arguments.update(kwargs)
     classes = arguments.get('classes', {})
     for i, subfield in enumerate(field):
         if subfield.type == 'HiddenField':
             hidden += text_type(subfield)
         else:
             wrapper_class = classes.get(i, '')
             html.append('%s<div class="%s">%s</div>' % (
                 hidden,
                 wrapper_class,
                 text_type(subfield(
                     class_=class_,
                     placeholder=subfield.label.text))))
             hidden = ''
     if hidden:
         html.append(hidden)
     return HTMLString('<div class="%s">' % (row_class, ) +
                       ''.join(html) + '</div>')

    def render_option(cls, value, label, selected, **kwargs):
        if value is True:
            # Handle the special case of a 'True' value.
            value = text_type(value)

        options = dict(kwargs, value=value)
        if selected:
            options['selected'] = True
        return HTMLString('<option %s>%s</option>' % (html_params(**options), escape(text_type(label), quote=False)))

    def __init__(self, enum_class, enums, label=None, validators=None, default=None, **kwargs):
        self._enum_class = enum_class
        self._enums = enums

        # Column(Enum(enum.Enum)) case
        if enum_class is not None:
            labels = [text_type(enum_class.__members__[enum_member].value)
                      for enum_member in enums]

            def coerce(value):
                if value is None:
                    return None
                elif isinstance(value, enum_class):
                    return value
                else:
                    return enum_class.__members__[value]


        # Column(Enum(*enums)) case
        else:
            labels = enums

            def coerce(value):
                if value is None:
                    return None
                return text_type(value)

        choices = list(zip(enums, labels))

        super(EnumField, self).__init__(label=label, validators=validators, default=default,
                                        coerce=coerce, choices=choices, **kwargs)

 def __call__(self, field, **kwargs):
     kwargs.setdefault('id', field.id)
     kwargs.setdefault('rows', self.rows)
     return HTMLString('<textarea %(html_params)s>%(value)s</textarea>' % {
         'html_params': html_params(name=field.name, **kwargs),
         'value': escape(text_type(field._value())),
     })

 def test(self):
     form = self.F()
     self.assertEqual(form.a.data, 'a')
     self.assertEqual(form.b.data, None)
     self.assertEqual(form.validate(), False)
     self.assertEqual(
         form.a(),
         (
             """<ul id="a">"""
             """<li><input checked id="a-0" name="a" type="radio" value="a"> <label for="a-0">hello</label></li>"""
             """<li><input id="a-1" name="a" type="radio" value="b"> <label for="a-1">bye</label></li></ul>"""
         )
     )
     self.assertEqual(
         form.b(),
         (
             """<ul id="b">"""
             """<li><input id="b-0" name="b" type="radio" value="1"> <label for="b-0">Item 1</label></li>"""
             """<li><input id="b-1" name="b" type="radio" value="2"> <label for="b-1">Item 2</label></li></ul>"""
         )
     )
     self.assertEqual(
         [text_type(x) for x in form.a],
         ['<input checked id="a-0" name="a" type="radio" value="a">', '<input id="a-1" name="a" type="radio" value="b">']
     )

    def _get_pk_from_identity(obj):
        """Copied / pasted, and fixed, from WTForms_sqlalchemy due to issue w/
        SQLAlchemy >= 1.2."""
        from sqlalchemy.orm.util import identity_key

        cls, key = identity_key(instance=obj)[0:2]
        return ":".join(text_type(x) for x in key)

 def _get_object_list(self):
     if self._object_list is None:
         objs = self.query_func()
         self._object_list = list(
             (text_type(self.get_pk_func(obj)), obj) for obj in objs
         )
     return self._object_list

 def render_option(cls, value, label, selected, disabled=False, **kwargs):
     options = dict(kwargs, value=value)
     if selected:
         options["selected"] = True
     if disabled:
         options["disabled"] = True
     return HTMLString("<option %s>%s</option>" % (html_params(**options), escape(text_type(label))))

 def __call__(self, field, **kwargs):
     html = []
     kwargs.setdefault('id', field.id)
     html.append(u'<div %s>' % html_params(**kwargs))
     hidden = u''
     for subfield in field:
         if subfield.type == 'HiddenField':
             hidden += text_type(subfield)
         else:
             html.append(u'<div><span>%s</span>%s%s</div>' % (
                 text_type(subfield.label), hidden, text_type(subfield)))
             hidden = u''
     html.append(u'</div>')
     if hidden:
         html.append(hidden)
     return HTMLString(u''.join(html))

 def _value(self):
     if self.raw_data:
         return self.raw_data[0]
     elif self.data is not None:
         return text_type(self.data)
     else:
         return ''

 def test_second_book(self):
     authors = set(text_type(x.key.id()) for x in fill_authors(Author))
     authors.add('__None')
     form = model_form(second_ndb_module.SecondBook)
     keys = set()
     for key, b, c in form().author.iter_choices():
         keys.add(key)