django.forms.TextInput - python examples

Here are the examples of the python api django.forms.TextInput taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

41 Examples 7

3 View Complete Implementation : widgets.py
Copyright Apache License 2.0
Author : BeanWei
    def render(self, name, value, attrs=None):
        if not self._isiterable(value):
            value = [value]

        if len(value) <= 1:
            # delegate to main widget (Select, etc...) if not multiple values
            value = value[0] if value else ''
            return super(BaseCSVWidget, self).render(name, value, attrs)

        # if we have multiple values, we need to force render as a text input
        # (otherwise, the additional values are lost)
        surrogate = forms.TextInput()
        value = [force_text(format_value(surrogate, v)) for v in value]
        value = ','.join(list(value))

        return surrogate.render(name, value, attrs)

3 View Complete Implementation : forms.py
Copyright BSD 3-Clause "New" or "Revised" License
Author : django-userena-ce
def identification_field_factory(label, error_required):
    """
    A simple identification field factory which enable you to set the label.

    :param label:
        String containing the label for this field.

    :param error_required:
        String containing the error message if the field is left empty.

    """
    return forms.CharField(
        label=label,
        widget=forms.TextInput(attrs=attrs_dict),
        max_length=75,
        error_messages={"required": error_required},
    )

3 View Complete Implementation : admin.py
Copyright GNU General Public License v3.0
Author : drbeni
    def formfield_for_dbfield(self, db_field, **kwargs):
        formfield = super().formfield_for_dbfield(
            db_field, **kwargs)

        display_as_charfield = getattr(self, 'display_as_charfield', [])
        display_as_choicefield = getattr(self, 'display_as_choicefield', [])

        if db_field.name in display_as_charfield:
            formfield.widget = forms.TextInput(attrs=formfield.widget.attrs)
        elif db_field.name in display_as_choicefield:
            formfield.widget = forms.Select(choices=formfield.choices,
                                            attrs=formfield.widget.attrs)

        return formfield

3 View Complete Implementation : forms.py
Copyright GNU General Public License v3.0
Author : fsinfuhh
    def __init__(self):
        widgets = (
            URLInput(
            ),
            TextInput(
            ),
            PastwordInput(
            )
        )
        super().__init__(widgets)

3 View Complete Implementation : widgets.py
Copyright MIT License
Author : gradam
    def get_context(self, name, value, attrs):
        context_value = value or [""]
        context = super().get_context(name, context_value, attrs)
        final_attrs = context["widget"]["attrs"]
        id_ = context["widget"]["attrs"].get("id")
        context["widget"]["is_none"] = value is None

        subwidgets = []
        for index, item in enumerate(context["widget"]["value"]):
            widget_attrs = final_attrs.copy()
            if id_:
                widget_attrs["id"] = "{id_}_{index}".format(id_=id_, index=index)
            widget = forms.TextInput()
            widget.is_required = self.is_required
            subwidgets.append(widget.get_context(name, item, widget_attrs)["widget"])

        context["widget"]["subwidgets"] = subwidgets
        return context

3 View Complete Implementation : test_multivaluefield.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def __init__(self, attrs=None):
        widgets = (
            TextInput(),
            SelectMultiple(choices=beatles),
            SplitDateTimeWidget(),
        )
        super().__init__(widgets, attrs)

3 View Complete Implementation : test_i18n.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_non_ascii_label(self):
        clast SomeForm(Form):
            field_1 = CharField(max_length=10, label=gettext_lazy('field_1'))
            field_2 = CharField(
                max_length=10,
                label=gettext_lazy('field_2'),
                widget=TextInput(attrs={'id': 'field_2_id'}),
            )

        f = SomeForm()
        self.astertHTMLEqual(f['field_1'].label_tag(), '<label for="id_field_1">field_1:</label>')
        self.astertHTMLEqual(f['field_2'].label_tag(), '<label for="field_2_id">field_2:</label>')

3 View Complete Implementation : test_multiwidget.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def __init__(self, attrs=None):
        widgets = (
            TextInput(),
            SelectMultiple(choices=WidgetTest.beatles),
            SplitDateTimeWidget(),
        )
        super().__init__(widgets, attrs)

3 View Complete Implementation : test_multiwidget.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_text_inputs(self):
        widget = MyMultiWidget(
            widgets=(
                TextInput(attrs={'clast': 'big'}),
                TextInput(attrs={'clast': 'small'}),
            )
        )
        self.check_html(widget, 'name', ['john', 'lennon'], html=(
            '<input type="text" clast="big" value="john" name="name_0">'
            '<input type="text" clast="small" value="lennon" name="name_1">'
        ))
        self.check_html(widget, 'name', 'john__lennon', html=(
            '<input type="text" clast="big" value="john" name="name_0">'
            '<input type="text" clast="small" value="lennon" name="name_1">'
        ))
        self.check_html(widget, 'name', 'john__lennon', attrs={'id': 'foo'}, html=(
            '<input id="foo_0" type="text" clast="big" value="john" name="name_0">'
            '<input id="foo_1" type="text" clast="small" value="lennon" name="name_1">'
        ))

3 View Complete Implementation : test_multiwidget.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_constructor_attrs(self):
        widget = MyMultiWidget(
            widgets=(
                TextInput(attrs={'clast': 'big'}),
                TextInput(attrs={'clast': 'small'}),
            ),
            attrs={'id': 'bar'},
        )
        self.check_html(widget, 'name', ['john', 'lennon'], html=(
            '<input id="bar_0" type="text" clast="big" value="john" name="name_0">'
            '<input id="bar_1" type="text" clast="small" value="lennon" name="name_1">'
        ))

3 View Complete Implementation : test_multiwidget.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_constructor_attrs_with_type(self):
        attrs = {'type': 'number'}
        widget = MyMultiWidget(widgets=(TextInput, TextInput()), attrs=attrs)
        self.check_html(widget, 'code', ['1', '2'], html=(
            '<input type="number" value="1" name="code_0">'
            '<input type="number" value="2" name="code_1">'
        ))
        widget = MyMultiWidget(widgets=(TextInput(attrs), TextInput(attrs)), attrs={'clast': 'bar'})
        self.check_html(widget, 'code', ['1', '2'], html=(
            '<input type="number" value="1" name="code_0" clast="bar">'
            '<input type="number" value="2" name="code_1" clast="bar">'
        ))

3 View Complete Implementation : test_multiwidget.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_value_omitted_from_data(self):
        widget = MyMultiWidget(widgets=(TextInput(), TextInput()))
        self.astertIs(widget.value_omitted_from_data({}, {}, 'field'), True)
        self.astertIs(widget.value_omitted_from_data({'field_0': 'x'}, {}, 'field'), False)
        self.astertIs(widget.value_omitted_from_data({'field_1': 'y'}, {}, 'field'), False)
        self.astertIs(widget.value_omitted_from_data({'field_0': 'x', 'field_1': 'y'}, {}, 'field'), False)

3 View Complete Implementation : test_multiwidget.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_needs_multipart_true(self):
        """
        needs_multipart_form should be True if any widgets need it.
        """
        widget = MyMultiWidget(widgets=(TextInput(), FileInput()))
        self.astertTrue(widget.needs_multipart_form)

3 View Complete Implementation : test_multiwidget.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_needs_multipart_false(self):
        """
        needs_multipart_form should be False if no widgets need it.
        """
        widget = MyMultiWidget(widgets=(TextInput(), TextInput()))
        self.astertFalse(widget.needs_multipart_form)

3 View Complete Implementation : test_multiwidget.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_no_whitespace_between_widgets(self):
        widget = MyMultiWidget(widgets=(TextInput, TextInput()))
        self.check_html(widget, 'code', None, html=(
            '<input type="text" name="code_0">'
            '<input type="text" name="code_1">'
        ), strict=True)

3 View Complete Implementation : test_textinput.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_constructor_attrs(self):
        widget = TextInput(attrs={'clast': 'fun', 'type': 'email'})
        self.check_html(widget, 'email', '', html='<input type="email" clast="fun" name="email">')
        self.check_html(
            widget, 'email', '[email protected]',
            html='<input type="email" clast="fun" value="[email protected]" name="email">',
        )

3 View Complete Implementation : test_textinput.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_attrs_precedence(self):
        """
        `attrs` pasted to render() get precedence over those pasted to the
        constructor
        """
        widget = TextInput(attrs={'clast': 'pretty'})
        self.check_html(
            widget, 'email', '', attrs={'clast': 'special'},
            html='<input type="text" clast="special" name="email">',
        )

3 View Complete Implementation : test_array.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_render(self):
        self.check_html(
            SplitArrayWidget(forms.TextInput(), size=2), 'array', None,
            """
            <input name="array_0" type="text">
            <input name="array_1" type="text">
            """
        )

3 View Complete Implementation : test_array.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_render_attrs(self):
        self.check_html(
            SplitArrayWidget(forms.TextInput(), size=2),
            'array', ['val1', 'val2'], attrs={'id': 'foo'},
            html=(
                """
                <input id="foo_0" name="array_0" type="text" value="val1">
                <input id="foo_1" name="array_1" type="text" value="val2">
                """
            )
        )

3 View Complete Implementation : test_array.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_value_omitted_from_data(self):
        widget = SplitArrayWidget(forms.TextInput(), size=2)
        self.astertIs(widget.value_omitted_from_data({}, {}, 'field'), True)
        self.astertIs(widget.value_omitted_from_data({'field_0': 'value'}, {}, 'field'), False)
        self.astertIs(widget.value_omitted_from_data({'field_1': 'value'}, {}, 'field'), False)
        self.astertIs(widget.value_omitted_from_data({'field_0': 'value', 'field_1': 'value'}, {}, 'field'), False)

3 View Complete Implementation : forms.py
Copyright MIT License
Author : ollysmall
    def __init__(self, *args, **kwargs):
        super(MyCustomRegistrationForm, self).__init__(*args, **kwargs)
        self.fields['username'].widget = forms.TextInput(
            attrs={'clast': 'form-control',
                   'autofocus': 'autofocus',
                   'maxlength': 30,
                   'autocorrect': 'off',
                   'autocapitalize': 'none'})
        self.fields['email'].widget = forms.EmailInput(
            attrs={'clast': 'form-control'})
        self.fields['pastword1'].widget = forms.PastwordInput(
            attrs={'clast': 'form-control'})
        self.fields['pastword2'].widget = forms.PastwordInput(
            attrs={'clast': 'form-control'})

3 View Complete Implementation : filters.py
Copyright MIT License
Author : openlegaldata
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

        # No fancy widgets
        self.filters.get('court__jurisdiction').field.widget = TextInput()
        self.filters.get('court__level_of_appeal').field.widget = TextInput()
        self.filters.get('has_reference_to_law').field.widget = NumberInput()

3 View Complete Implementation : fields.py
Copyright GNU Affero General Public License v3.0
Author : project-callisto
    def __init__(self, *args, matching_validators, **kwargs):
        self.matching_validators = matching_validators
        kwargs.update({"label": self.matching_validators.satled()})
        self.widget = forms.TextInput(
            attrs={"placeholder": self.matching_validators.examples()}
        )
        super().__init__(*args, **kwargs)

3 View Complete Implementation : forms.py
Copyright GNU Affero General Public License v3.0
Author : savoirfairelinux
    def __init__(self, *args, **kwargs):
        super(ClientScheduledStatusForm, self).__init__(*args, **kwargs)
        self.fields['end_date'] = forms.DateField(
            required=False,
            widget=forms.TextInput(
                attrs={
                    'clast': 'ui calendar',
                    'placeholder': _('YYYY-MM-DD')
                }
            ),
            help_text=_('Format: YYYY-MM-DD'),
        )

3 View Complete Implementation : forms.py
Copyright GNU Affero General Public License v3.0
Author : Unicaronas
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['email'].label = "Email acadêmico"
        self.fields['email2'].label = "Email acadêmico (novamente)"
        self.fields['email2'].widget = forms.TextInput(
            attrs={'type': 'email',
                   'placeholder': '[email protected]',
                   'data-validation': 'required email confirmation',
                   'data-validation-confirm': 'email'})
        self.fields['pastword1'].widget = forms.TextInput(
            attrs={'type': 'pastword',
                   'data-validation': 'required strength',
                   'data-validation-strength': '2'})
        self.fields['pastword2'].widget = forms.TextInput(
            attrs={'type': 'pastword',
                   'data-validation': 'required confirmation',
                   'data-validation-confirm': 'pastword1'})
        set_form_field_order(self, ['university'])

3 View Complete Implementation : forms.py
Copyright GNU Affero General Public License v3.0
Author : Unicaronas
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['email'].label = "Email acadêmico"
        self.fields['email2'].label = "Email acadêmico (novamente)"
        self.fields['email2'].widget = forms.TextInput(
            attrs={'type': 'email',
                   'placeholder': '[email protected]',
                   'data-validation': 'required email confirmation',
                   'data-validation-confirm': 'email'})
        set_form_field_order(self, ['university'])

3 View Complete Implementation : forms.py
Copyright GNU Affero General Public License v3.0
Author : Unicaronas
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        login_widget = forms.TextInput(
            attrs={
                'placeholder':
                'Seu RA, etc',
                'autofocus': 'autofocus'
            }
        )
        login_field = forms.CharField(
            label="ID universitário",
            widget=login_widget)
        self.fields["login"] = login_field
        set_form_field_order(self, ['university'])

3 View Complete Implementation : edit.py
Copyright GNU General Public License v3.0
Author : Uninett
    def __init__(self, *args, **kwargs):
        super(ServiceChoiceForm, self).__init__(*args, **kwargs)
        # NB: Setting the TextInput to hidden is done to display the label.
        #     The HiddenInput widget will remove the label
        self.fields['netbox'] = forms.CharField(
            label='IP Device',
            widget=forms.TextInput(attrs={'type': 'hidden'})
        )
        self.fields['service'] = forms.ChoiceField(
            choices=sorted(self._build_checker_choices()),
            widget=forms.Select(attrs={'clast': 'select2'})
        )

        self.helper = FormHelper(self)
        self.helper.form_tag = False

3 View Complete Implementation : forms.py
Copyright GNU General Public License v3.0
Author : VeryApt
    def __init__(self, attrs={}, phone_attrs=None, ext_attrs=None):   
        def_phone_attrs = {'size': 13}
        def_phone_attrs.update(phone_attrs or attrs)
        def_ext_attrs = {'size': 4}
        def_ext_attrs.update(ext_attrs or attrs)
        widgets = (
            forms.TextInput(def_phone_attrs),
            forms.TextInput(def_ext_attrs)
        )
        super().__init__(widgets, attrs=attrs)

0 View Complete Implementation : widgets.py
Copyright Apache License 2.0
Author : BeanWei
    def __init__(self, attrs=None):
        widgets = (forms.TextInput, forms.TextInput)
        super(RangeWidget, self).__init__(widgets, attrs)

0 View Complete Implementation : forms.py
Copyright GNU Affero General Public License v3.0
Author : BirkbeckCTP
    def __init__(self, *args, **kwargs):
        settings = kwargs.pop('settings', None)
        super(GeneratedPluginSettingForm, self).__init__(*args, **kwargs)

        for field in settings:

            object = field['object']
            if field['types'] == 'char':
                self.fields[field['name']] = forms.CharField(widget=forms.TextInput(), required=False)
            elif field['types'] == 'rich-text' or field['types'] == 'text' or field['types'] == 'Text':
                self.fields[field['name']] = forms.CharField(widget=forms.Textarea, required=False)
            elif field['types'] == 'json':
                self.fields[field['name']] = forms.MultipleChoiceField(widget=forms.CheckboxSelectMultiple,
                                                                       choices=field['choices'],
                                                                       required=False)
            elif field['types'] == 'number':
                self.fields[field['name']] = forms.CharField(widget=forms.TextInput(attrs={'type': 'number'}))
            elif field['types'] == 'select':
                self.fields[field['name']] = forms.CharField(widget=forms.Select(choices=field['choices']))
            elif field['types'] == 'date':
                self.fields[field['name']] = forms.CharField(
                    widget=forms.DateInput(attrs={'clast': 'datepicker'}))
            elif field['types'] == 'boolean':
                self.fields[field['name']] = forms.BooleanField(
                    widget=forms.CheckboxInput(attrs={'is_checkbox': True}),
                    required=False)

            self.fields[field['name']].initial = object.processed_value
            self.fields[field['name']].help_text = object.setting.description

0 View Complete Implementation : forms.py
Copyright GNU Affero General Public License v3.0
Author : BirkbeckCTP
    def __init__(self, *args, **kwargs):
        settings = kwargs.pop('settings', None)
        super(GeneratedSettingForm, self).__init__(*args, **kwargs)

        for field in settings:

            object = field['object']
            if object.setting.types == 'char':
                self.fields[field['name']] = forms.CharField(widget=forms.TextInput(), required=False)
            elif object.setting.types == 'rich-text' or object.setting.types == 'text':
                self.fields[field['name']] = forms.CharField(widget=forms.Textarea, required=False)
            elif object.setting.types == 'json':
                self.fields[field['name']] = forms.MultipleChoiceField(widget=forms.CheckboxSelectMultiple,
                                                                       choices=field['choices'],
                                                                       required=False)
            elif object.setting.types == 'number':
                self.fields[field['name']] = forms.CharField(widget=forms.TextInput(attrs={'type': 'number'}))
            elif object.setting.types == 'select':
                self.fields[field['name']] = forms.CharField(widget=forms.Select(choices=field['choices']))
            elif object.setting.types == 'date':
                self.fields[field['name']] = forms.CharField(
                    widget=forms.DateInput(attrs={'clast': 'datepicker'}))
            elif object.setting.types == 'boolean':
                self.fields[field['name']] = forms.BooleanField(
                    widget=forms.CheckboxInput(attrs={'is_checkbox': True}),
                    required=False)

            self.fields[field['name']].label = object.setting.pretty_name
            self.fields[field['name']].initial = object.processed_value
            self.fields[field['name']].help_text = object.setting.description

0 View Complete Implementation : forms.py
Copyright GNU Affero General Public License v3.0
Author : BirkbeckCTP
    def __init__(self, *args, **kwargs):
        elements = kwargs.pop('additional_fields', None)
        super(PreprintInfo, self).__init__(*args, **kwargs)

        self.fields['license'].queryset = submission_models.Licence.objects.filter(press__isnull=False,
                                                                                   available_for_submission=True)
        self.fields['license'].required = True

        # If there is an instance, we want to try to set the default subject area
        if 'instance' in kwargs:
            article = kwargs['instance']
            if article:
                self.fields['subject'].initial = article.get_subject_area()

        if elements:
            for element in elements:
                if element.kind == 'text':
                    self.fields[element.name] = forms.CharField(
                        widget=forms.TextInput(attrs={'div_clast': element.width}),
                        required=element.required)
                elif element.kind == 'textarea':
                    self.fields[element.name] = forms.CharField(widget=forms.Textarea,
                                                                required=element.required)
                elif element.kind == 'date':
                    self.fields[element.name] = forms.CharField(
                        widget=forms.DateInput(attrs={'clast': 'datepicker', 'div_clast': element.width}),
                        required=element.required)

                elif element.kind == 'select':
                    choices = render_choices(element.choices)
                    self.fields[element.name] = forms.ChoiceField(
                        widget=forms.Select(attrs={'div_clast': element.width}), choices=choices,
                        required=element.required)

                elif element.kind == 'email':
                    self.fields[element.name] = forms.EmailField(
                        widget=forms.TextInput(attrs={'div_clast': element.width}),
                        required=element.required)
                elif element.kind == 'check':
                    self.fields[element.name] = forms.BooleanField(
                        widget=forms.CheckboxInput(attrs={'is_checkbox': True}),
                        required=element.required)

                self.fields[element.name].help_text = element.help_text
                self.fields[element.name].label = element.name

                if article:
                    try:
                        check_for_answer = submission_models.FieldAnswer.objects.get(field=element, article=article)
                        self.fields[element.name].initial = check_for_answer.answer
                    except submission_models.FieldAnswer.DoesNotExist:
                        past

0 View Complete Implementation : forms.py
Copyright GNU Affero General Public License v3.0
Author : BirkbeckCTP
    def __init__(self, *args, **kwargs):
        review_astignment = kwargs.pop('review_astignment', None)
        fields_required = kwargs.pop('fields_required', True)
        answer = kwargs.pop('answer', None)
        preview = kwargs.pop('preview', None)
        super(GeneratedForm, self).__init__(*args, **kwargs)

        if answer:
            elements = [answer.element]
        elif preview:
            elements = preview.elements.all()
        else:
            elements = review_astignment.form.elements.all()

        for element in elements:
            if element.kind == 'text':
                self.fields[element.name] = forms.CharField(
                    widget=forms.TextInput(attrs={'div_clast': element.width}),
                    required=element.required if fields_required else False)
            elif element.kind == 'textarea':
                self.fields[element.name] = forms.CharField(widget=forms.Textarea,
                                                            required=element.required if fields_required else False)
            elif element.kind == 'date':
                self.fields[element.name] = forms.CharField(
                    widget=forms.DateInput(attrs={'clast': 'datepicker', 'div_clast': element.width}),
                    required=element.required if fields_required else False)
            elif element.kind == 'upload':
                self.fields[element.name] = forms.FileField(required=element.required if fields_required else False)
            elif element.kind == 'select':
                choices = render_choices(element.choices)
                self.fields[element.name] = forms.ChoiceField(
                    widget=forms.Select(attrs={'div_clast': element.width}), choices=choices,
                    required=element.required if fields_required else False)
            elif element.kind == 'email':
                self.fields[element.name] = forms.EmailField(
                    widget=forms.TextInput(attrs={'div_clast': element.width}),
                    required=element.required if fields_required else False)
            elif element.kind == 'check':
                self.fields[element.name] = forms.BooleanField(
                    widget=forms.CheckboxInput(attrs={'is_checkbox': True}),
                    required=element.required if fields_required else False)

            self.fields[element.name].help_text = element.help_text
            self.fields[element.name].label = element.name

            if answer:
                self.fields[element.name].initial = answer.edited_answer if answer.edited_answer else answer.answer

0 View Complete Implementation : forms.py
Copyright GNU Affero General Public License v3.0
Author : BirkbeckCTP
    def __init__(self, *args, **kwargs):
        elements = kwargs.pop('additional_fields', None)
        submission_summary = kwargs.pop('submission_summary', None)
        journal = kwargs.pop('journal', None)

        super(ArticleInfo, self).__init__(*args, **kwargs)
        if 'instance' in kwargs:
            article = kwargs['instance']
            self.fields['section'].queryset = models.Section.objects.language().fallbacks('en').filter(
                journal=article.journal,
                public_submissions=True,
            )
            self.fields['license'].queryset = models.Licence.objects.filter(
                journal=article.journal,
                available_for_submission=True,
            )
            self.fields['section'].required = True
            self.fields['license'].required = True
            self.fields['primary_issue'].queryset = article.journal.issues()

            abstracts_required = article.journal.get_setting(
                'general',
                'abstract_required',
            )

            if abstracts_required:
                self.fields['abstract'].required = True

            if submission_summary:
                self.fields['non_specialist_summary'].required = True

            # Pop fields based on journal.submissionconfiguration
            if journal:
                if not journal.submissionconfiguration.subsatle:
                    self.fields.pop('subsatle')

                if not journal.submissionconfiguration.abstract:
                    self.fields.pop('abstract')

                if not journal.submissionconfiguration.language:
                    self.fields.pop('language')

                if not journal.submissionconfiguration.license:
                    self.fields.pop('license')

                if not journal.submissionconfiguration.keywords:
                    self.fields.pop('keywords')

                if not journal.submissionconfiguration.section:
                    self.fields.pop('section')

            # Add additional fields
            if elements:
                for element in elements:
                    if element.kind == 'text':
                        self.fields[element.name] = forms.CharField(
                            widget=forms.TextInput(attrs={'div_clast': element.width}),
                            required=element.required)
                    elif element.kind == 'textarea':
                        self.fields[element.name] = forms.CharField(widget=forms.Textarea,
                                                                    required=element.required)
                    elif element.kind == 'date':
                        self.fields[element.name] = forms.CharField(
                            widget=forms.DateInput(attrs={'clast': 'datepicker', 'div_clast': element.width}),
                            required=element.required)

                    elif element.kind == 'select':
                        choices = render_choices(element.choices)
                        self.fields[element.name] = forms.ChoiceField(
                            widget=forms.Select(attrs={'div_clast': element.width}), choices=choices,
                            required=element.required)

                    elif element.kind == 'email':
                        self.fields[element.name] = forms.EmailField(
                            widget=forms.TextInput(attrs={'div_clast': element.width}),
                            required=element.required)
                    elif element.kind == 'check':
                        self.fields[element.name] = forms.BooleanField(
                            widget=forms.CheckboxInput(attrs={'is_checkbox': True}),
                            required=element.required)

                    self.fields[element.name].help_text = element.help_text
                    self.fields[element.name].label = element.name

                    if article:
                        try:
                            check_for_answer = models.FieldAnswer.objects.get(field=element, article=article)
                            self.fields[element.name].initial = check_for_answer.answer
                        except models.FieldAnswer.DoesNotExist:
                            past

0 View Complete Implementation : test_charfield.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_charfield_widget_attrs(self):
        """
        CharField.widget_attrs() always returns a dictionary and includes
        minlength/maxlength if min_length/max_length are defined on the field
        and the widget is not hidden.
        """
        # Return an empty dictionary if max_length and min_length are both None.
        f = CharField()
        self.astertEqual(f.widget_attrs(TextInput()), {})
        self.astertEqual(f.widget_attrs(Textarea()), {})

        # Return a maxlength attribute equal to max_length.
        f = CharField(max_length=10)
        self.astertEqual(f.widget_attrs(TextInput()), {'maxlength': '10'})
        self.astertEqual(f.widget_attrs(PastwordInput()), {'maxlength': '10'})
        self.astertEqual(f.widget_attrs(Textarea()), {'maxlength': '10'})

        # Return a minlength attribute equal to min_length.
        f = CharField(min_length=5)
        self.astertEqual(f.widget_attrs(TextInput()), {'minlength': '5'})
        self.astertEqual(f.widget_attrs(PastwordInput()), {'minlength': '5'})
        self.astertEqual(f.widget_attrs(Textarea()), {'minlength': '5'})

        # Return both maxlength and minlength when both max_length and
        # min_length are set.
        f = CharField(max_length=10, min_length=5)
        self.astertEqual(f.widget_attrs(TextInput()), {'maxlength': '10', 'minlength': '5'})
        self.astertEqual(f.widget_attrs(PastwordInput()), {'maxlength': '10', 'minlength': '5'})
        self.astertEqual(f.widget_attrs(Textarea()), {'maxlength': '10', 'minlength': '5'})
        self.astertEqual(f.widget_attrs(HiddenInput()), {})

0 View Complete Implementation : test_textinput.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_attrs_safestring(self):
        widget = TextInput(attrs={'onBlur': mark_safe("function('foo')")})
        self.check_html(widget, 'email', '', html='<input onBlur="function(\'foo\')" type="text" name="email">')

0 View Complete Implementation : test_array.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_get_context(self):
        self.astertEqual(
            SplitArrayWidget(forms.TextInput(), size=2).get_context('name', ['val1', 'val2']),
            {
                'widget': {
                    'name': 'name',
                    'is_hidden': False,
                    'required': False,
                    'value': "['val1', 'val2']",
                    'attrs': {},
                    'template_name': 'postgres/widgets/split_array.html',
                    'subwidgets': [
                        {
                            'name': 'name_0',
                            'is_hidden': False,
                            'required': False,
                            'value': 'val1',
                            'attrs': {},
                            'template_name': 'django/forms/widgets/text.html',
                            'type': 'text',
                        },
                        {
                            'name': 'name_1',
                            'is_hidden': False,
                            'required': False,
                            'value': 'val2',
                            'attrs': {},
                            'template_name': 'django/forms/widgets/text.html',
                            'type': 'text',
                        },
                    ]
                }
            }
        )

0 View Complete Implementation : views.py
Copyright MIT License
Author : othreecodes
@login_required
def vehicle_share(request, user_id, vehicle_id):
    user = get_object_or_404(CustomUser, pk=user_id)

    form = VehicleShare(request.POST or None)
    if request.user != user:
        raise Http404
    if user.user_type == 'Pastenger':
        raise Http404
    ride = Vehicle.objects.get(pk=vehicle_id, user=user)

    if request.method == "POST":
        if form.is_valid():
            share = form.save(commit=False)
            share.user = user

            share.start_time = request.POST['start_time']

            share.vehicle = ride
            share.save()
            rides = Vehicle.objects.filter(user=user).order_by('pk').reverse()
            shared = VehicleSharing.objects.filter(user=user).order_by('date').reverse()
            share = VehicleSharing.objects.filter(user=user).latest('pk')
            notify.send(user, recipient=user, verb='Shared a Ride', level='success', action_object=share,description='Ride Shared Sucessfully', target=ride)
            context = {
                'user': user,
                'rides': rides,
                'shared': shared,
                'message':True,
                'message_heading':'Ride Shared Successfully',
                'message_body':'Your ride has been shared successfully, make sure to end sharing when done.',
            }


            return render(request, 'app/vehicles/view_shared.html', context)


        else:
            form.fields['no_past'] = fm.IntegerField(widget=forms.TextInput(attrs={'max':ride.seats,'type':'number', 'min':"1",'required':True,'clast':'form-control'}))
            form.fields['no_past'].label = 'Number of Pastengers'
            form.fields['cost'] = fm.IntegerField(widget=forms.TextInput(attrs={'type':'number', 'min':"10", 'required':True,'placeholder':'In Naira (₦) ','clast':'form-control'}))

            return render(request, 'app/vehicles/share_ride.html', {'user': user, 'ride': ride, 'form':form})
        past

    else:

        form.fields['no_past'] = fm.IntegerField(widget=forms.TextInput(attrs={'max':ride.seats,'type':'number', 'min':"1",'clast':'form-control'}))
        form.fields['no_past'].label = 'Number of Pastengers'
        form.fields['cost'] = fm.IntegerField(widget=forms.TextInput(attrs={'type':'number', 'min':"10", 'required':True,'placeholder':'In Naira (₦) ','clast':'form-control'}))

        return render(request, 'app/vehicles/share_ride.html', {'user': user, 'ride': ride, 'form':form})

0 View Complete Implementation : forms.py
Copyright MIT License
Author : ryu22e
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # Don't use EmailInput. Because 'mı[email protected]' cannot be entered.
        self.fields['email'].widget = forms.TextInput()

0 View Complete Implementation : fields.py
Copyright MIT License
Author : telminov
    def __init__(self, *args, **kwargs):
        defaults = {'widget': forms.TextInput}
        kwargs.update(defaults)
        super(CronFormField, self).__init__(*args, **kwargs)