# Django Crispy Forms

***

**1. Basic Form Rendering**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit

class SimpleForm(forms.Form):
    name = forms.CharField(max_length=50)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.add_input(Submit('submit', 'Submit'))
```

**2. Form with HTML5 Attributes**

```python
from crispy_forms.bootstrap import FormActions

class HTML5Form(forms.Form):
    name = forms.CharField(max_length=50)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.form_tag = True
        self.helper.form_class = 'form-horizontal'
        self.helper.layout = Layout(
            'name',
            FormActions(
                Submit('submit', 'Submit', css_class='btn-primary'),
            ),
        )
```

**3. Fieldset Grouping**

```python
from crispy_forms.layout import Div, Fieldset

class GroupedForm(forms.Form):
    name = forms.CharField(max_length=50)
    email = forms.EmailField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            Fieldset('Personal Details', 'name', 'email'),
            Submit('submit', 'Submit'),
        )
```

**4. Inline Field Grouping**

```python
from crispy_forms.layout import Div, Field

class InlineForm(forms.Form):
    name = forms.CharField(max_length=50)
    email = forms.EmailField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            Div(
                Field('name', css_class='input-inline'),
                Field('email', css_class='input-inline'),
                css_class='form-inline',
            ),
            Submit('submit', 'Submit'),
        )
```

**5. Row and Column Grids**

```python
from crispy_forms.layout import Row, Column

class GridForm(forms.Form):
    name = forms.CharField(max_length=50)
    email = forms.EmailField()
    phone = forms.CharField(max_length=20)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            Row(
                Column('name', css_class='form-group col-md-6'),
                Column('email', css_class='form-group col-md-6'),
                css_class='form-row',
            ),
            Row(
                Column('phone', css_class='form-group col-md-12'),
                css_class='form-row',
            ),
            Submit('submit', 'Submit'),
        )
```

**6. Nested Layouts**

```python
from crispy_forms.layout import Column, Div, Field

class NestedForm(forms.Form):
    name = forms.CharField(max_length=50)
    email = forms.EmailField()
    phone = forms.CharField(max_length=20)
    address = forms.CharField(max_length=100)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            Column(
                Div(
                    Field('name', css_class='input-inline'),
                    Field('email', css_class='input-inline'),
                    css_class='form-inline',
                ),
                Field('phone', css_class='input-group'),
                Field('address', css_class='input-large'),
                css_class='form-group col-md-6',
            ),
            Submit('submit', 'Submit'),
        )
```

**7. Dynamic Form**

```python
from crispy_forms.layout import Field
from django.forms.util import flatatt

class DynamicForm(forms.Form):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        if 'fields' in kwargs:
            for field_name in kwargs['fields']:
                field = Field(field_name, css_class=f'{field_name}-class')
                attrs = {'id': field_name}
                field.wrap(attrs, flatatt(attrs))
                self.helper.add_input(field)
        else:
            self.helper.add_input(Field('name', css_class='name-class'))
```

**8. Fieldset with Legend and HTML**

```python
from crispy_forms.layout import Fieldset, HTML

class LegendForm(forms.Form):
    name = forms.CharField(max_length=50)
    email = forms.EmailField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            Fieldset(
                'Personal Details',
                'name', 'email',
                legend_html='<h2>Legend</h2>',
                css_class='fieldset-class',
            ),
            Submit('submit', 'Submit'),
        )
```

**9. Form with Hidden Fields**

```python
from crispy_forms.layout import Hidden

class HiddenFieldForm(forms.Form):
    hidden_field = forms.CharField(max_length=50, widget=forms.HiddenInput)
    name = forms.CharField(max_length=50)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            Hidden('hidden_field'),
            'name',
            Submit('submit', 'Submit'),
        )
```

**10. Form with Readonly Fields**

```python
from crispy_forms.layout import Field
from django.forms.utils import flatatt

class ReadonlyForm(forms.Form):
    name = forms.CharField(max_length=50)
    readonly_field = forms.CharField(max_length=50, widget=forms.TextInput(attrs={'readonly': True}))

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            'name',
            Field('readonly_field', readonly=True, css_class='readonly-class'),
            Submit('submit', 'Submit'),
        )
```

**11. Bootstrap Autocomplete Field**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit, Field
from crispy_forms.bootstrap import AppendedText, PrependedText

class BootstrapAutocompleteForm(forms.Form):
    name = forms.CharField(max_length=50)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            AppendedText('name', '@example.com'),
            Submit('submit', 'Submit'),
        )
```

**12. Bootstrap Datepicker Field**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit, Field
from crispy_forms.bootstrap import InlineField

class BootstrapDatepickerForm(forms.Form):
    date = forms.DateField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            InlineField('date'),
            Submit('submit', 'Submit'),
        )
```

**13. MultiSelect Field**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import MultipleChoiceField

class MultiSelectForm(forms.Form):
    choices = [('option1', 'Option 1'), ('option2', 'Option 2')]
    multi_select = forms.MultipleChoiceField(choices=choices, widget=forms.CheckboxSelectMultiple)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            MultipleChoiceField('multi_select', css_class='multiple-class'),
            Submit('submit', 'Submit'),
        )
```

**14. Select Widget with Size**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import Select

class SelectSizeForm(forms.Form):
    choices = [('option1', 'Option 1'), ('option2', 'Option 2')]
    select_size = forms.ChoiceField(choices=choices, widget=forms.Select(attrs={'size': 5}))

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            Select('select_size', css_class='select-class'),
            Submit('submit', 'Submit'),
        )
```

**15. Inline Radio Buttons**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit, Field
from crispy_forms.bootstrap import InlineRadioField

class InlineRadioForm(forms.Form):
    choices = [('option1', 'Option 1'), ('option2', 'Option 2')]
    inline_radio = forms.ChoiceField(choices=choices, widget=forms.RadioSelect)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            InlineRadioField('inline_radio', css_class='inline-radio-class'),
            Submit('submit', 'Submit'),
        )
```

**16. Inline Checkboxes**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit, Field
from crispy_forms.bootstrap import InlineCheckboxes

class InlineCheckboxForm(forms.Form):
    choices = [('option1', 'Option 1'), ('option2', 'Option 2')]
    inline_checkbox = forms.MultipleChoiceField(choices=choices, widget=forms.CheckboxSelectMultiple)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            InlineCheckboxes('inline_checkbox', css_class='inline-checkbox-class'),
            Submit('submit', 'Submit'),
        )
```

**17. Disabled Field**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit, Field
from django.forms.utils import flatatt

class DisabledFieldForm(forms.Form):
    name = forms.CharField(max_length=50)
    disabled_field = forms.CharField(max_length=50, widget=forms.TextInput(attrs={'disabled': True}))

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            'name',
            Field('disabled_field', disabled=True, css_class='disabled-class'),
            Submit('submit', 'Submit'),
        )
```

**18. HTML and CSS in Form Layout**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit, HTML, CSS
from django.utils.safestring import mark_safe

class HTMLCSSForm(forms.Form):
    name = forms.CharField(max_length=50)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            'name',
            HTML('<p>This is some HTML.</p>'),
            CSS(mark_safe('.form-control { background-color: #f8f8f8; }')),
            Submit('submit', 'Submit'),
        )
```

**19. Form with Custom CSS Classes**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit

class CustomCSSForm(forms.Form):
    name = forms.CharField(max_length=50)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.form_class = 'my-custom-form'
        self.helper.field_class = 'my-custom-field'
        self.helper.layout = Layout(
            'name',
            Submit('submit', 'Submit'),
        )
```

**20. Horizontal Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit

class HorizontalForm(forms.Form):
    name = forms.CharField(max_length=50)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.form_tag = True
        self.helper.form_class = 'form-horizontal'
        self.helper.label_class = 'col-sm-2'
        self.helper.field_class = 'col-sm-10'
        self.helper.layout = Layout(
            'name',
            Submit('submit', 'Submit'),
        )
```

**21. Inline Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit

class InlineForm(forms.Form):
    name = forms.CharField(max_length=50)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.form_tag = True
        self.helper.form_class = 'form-inline'
        self.helper.field_template = 'bootstrap4/inline_field.html'
        self.helper.layout = Layout(
            'name',
            Submit('submit', 'Submit'),
        )
```

**22. Search Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import PrependedText

class SearchForm(forms.Form):
    query = forms.CharField(max_length=50)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.form_class = 'form-inline'
        self.helper.layout = Layout(
            PrependedText('query', '<span class="glyphicon glyphicon-search"></span>'),
            Submit('submit', 'Search'),
        )
```

**23. File Upload Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import FileInput

class FileUploadForm(forms.Form):
    file = forms.FileField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            FileInput('file', css_class='input-file'),
            Submit('submit', 'Upload'),
        )
```

**24. Multi-File Upload Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import MultipleFileInput

class MultiFileUploadForm(forms.Form):
    files = forms.FileField(widget=forms.ClearableFileInput(attrs={'multiple': True}))

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            MultipleFileInput('files', css_class='input-files'),
            Submit('submit', 'Upload'),
        )
```

**25. Date Range Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import DateRangeField

class DateRangeForm(forms.Form):
    start_date = forms.DateField()
    end_date = forms.DateField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            DateRangeField('start_date', 'end_date', css_class='date-range'),
            Submit('submit', 'Submit'),
        )
```

**26. Time Input Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import TimeInput

class TimeInputForm(forms.Form):
    time = forms.TimeField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            TimeInput('time', css_class='time-input'),
            Submit('submit', 'Submit'),
        )
```

**27. URL Input Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import URLInput

class URLInputForm(forms.Form):
    url = forms.URLField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            URLInput('url', css_class='url-input'),
            Submit('submit', 'Submit'),
        )
```

**28. Email Input Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import EmailInput

class EmailInputForm(forms.Form):
    email = forms.EmailField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            EmailInput('email', css_class='email-input'),
            Submit('submit', 'Submit'),
        )
```

**29. Tel Input Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import TelInput

class TelInputForm(forms.Form):
    phone_number = forms.CharField(max_length=20)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            TelInput('phone_number', css_class='tel-input'),
            Submit('submit', 'Submit'),
        )
```

**30. Password Input Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import PasswordInput

class PasswordInputForm(forms.Form):
    password = forms.CharField(widget=forms.PasswordInput())

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            PasswordInput('password', css_class='password-input'),
            Submit('submit', 'Submit'),
        )
```

**31. Checkbox Input Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import CheckboxInput

class CheckboxInputForm(forms.Form):
    agree = forms.BooleanField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            CheckboxInput('agree', css_class='checkbox-input'),
            Submit('submit', 'Submit'),
        )
```

**32. Radio Input Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import RadioInput

class RadioInputForm(forms.Form):
    gender = forms.ChoiceField(choices=[('male', 'Male'), ('female', 'Female')])

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            RadioInput('gender', css_class='radio-input'),
            Submit('submit', 'Submit'),
        )
```

**33. Select Input Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import Select

class SelectInputForm(forms.Form):
    choices = [('option1', 'Option 1'), ('option2', 'Option 2')]
    select_field = forms.ChoiceField(choices=choices)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            Select('select_field', css_class='select-input'),
            Submit('submit', 'Submit'),
        )
```

**34. Text Input Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import TextInput

class TextInputForm(forms.Form):
    name = forms.CharField(max_length=50)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            TextInput('name', css_class='text-input'),
            Submit('submit', 'Submit'),
        )
```

**35. Textarea Input Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import Textarea

class TextareaInputForm(forms.Form):
    comment = forms.CharField(widget=forms.Textarea)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            Textarea('comment', css_class='textarea-input'),
            Submit('submit', 'Submit'),
        )
```

**36. Hidden Input Form**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit
from crispy_forms.bootstrap import Hidden

class HiddenInputForm(forms.Form):
    hidden_field = forms.CharField(max_length=50, widget=forms.HiddenInput())
    name = forms.CharField(max_length=50)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.layout = Layout(
            Hidden('hidden_field'),
            'name',
            Submit('submit', 'Submit'),
        )
```