B CVvgW@sddlmZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z ddlmZmZmZeGd d d ZGd d d ZGd ddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdd d eZGd!d"d"eZGd#d$d$eZGd%d&d&eZ Gd'd(d(Z!Gd)d*d*eZ"Gd+d,d,e"Z#d-S).) dataclass)List)Template)render_to_string)conditional_escape) SafeString)slugify) TEMPLATE_PACKflatatt render_fieldc@s"eZdZUeeed<eed<dS)PointerZ positionsnameN)__name__ __module__ __qualname__rint__annotations__strrrD/tmp/pip-install-o3oxmrkh/django-crispy-forms/crispy_forms/layout.pyr s  r c@seZdZddZdS)TemplateNameMixincCs d|jkr|j|}n|j}|S)Nz%s)template)self template_packrrrrget_template_names  z#TemplateNameMixin.get_template_nameN)rrrrrrrrrsrc@s\eZdZddZddZddZddZd d Zdd d Zd dddddZ e fddZ d S) LayoutObjectcCs |j|S)N)fields)rslicerrr __getitem__szLayoutObject.__getitem__cCs||j|<dS)N)r)rrvaluerrr __setitem__!szLayoutObject.__setitem__cCs |j|=dS)N)r)rrrrr __delitem__$szLayoutObject.__delitem__cCs t|jS)N)lenr)rrrr__len__'szLayoutObject.__len__cCs2d|jkr"t|j|r"t|j|St||SdS)z This allows us to access self.fields list methods like append or insert, without having to declare them one by one rN)__dict__hasattrrgetattrobject__getattribute__)rr rrr __getattr__*s zLayoutObject.__getattr__NcCs|jtdddS)a  Returns a list of Pointers. First parameter is the location of the field, second one the name of the field. Example:: [ Pointer([0,1,2], 'field_name1'), Pointer([0,3], 'field_name2'), ] NT)indexgreedy)get_layout_objectsr)rr*rrrget_field_names5s zLayoutObject.get_field_namesrF)r* max_levelr+c Gsg}|dk rt|ts|g}n |dkr*g}t|dko@|dtk}xt|jD]\}}t||r|r||t||g|n|t||g|jj t |drNt||ks|rN||g||d} ||j || }qNW|S)a Returns a list of Pointers pointing to layout objects of any type matching `LayoutClasses`:: [ Pointer([0,1,2], 'div']), Pointer([0,3], 'field_name'), ] :param max_level: An integer that indicates max level depth to reach when traversing a layout. :param greedy: Boolean that indicates whether to be greedy. If set, max_level is skipped. Nrr-)r*r.r+) isinstancelistr"r enumeraterappendr __class__rlowerr%r,) rr*r.r+Z LayoutClassesZpointersZ str_classi layout_objectZ new_kwargsrrrr,As zLayoutObject.get_layout_objectsc s$tdfdd|jDS)Nc3s&|]}t|fdiVqdS)rN)r ).0field)contextformkwargsrrr isz3LayoutObject.get_rendered_fields..)rjoinr)rr<r;rr=r)r;r<r=rrget_rendered_fieldsgsz LayoutObject.get_rendered_fields)N) rrrrr r!r#r)r-r,r r@rrrrrs &rc@s$eZdZdZddZefddZdS)Layouta Form Layout. It is conformed by Layout objects: `Fieldset`, `Row`, `Column`, `MultiField`, `HTML`, `ButtonHolder`, `Button`, `Hidden`, `Reset`, `Submit` and fields. Form fields have to be strings. Layout objects `Fieldset`, `Row`, `Column`, `MultiField` and `ButtonHolder` can hold other Layout objects within. Though `ButtonHolder` should only hold `HTML` and BaseInput inherited classes: `Button`, `Hidden`, `Reset` and `Submit`. Example:: helper.layout = Layout( Fieldset('Company data', 'is_company' ), Fieldset(_('Contact details'), 'email', Row('password1', 'password2'), 'first_name', 'last_name', HTML(''), 'company' ), ButtonHolder( Submit('Save', 'Save', css_class='button white'), ), ) cGst||_dS)N)r1r)rrrrr__init__szLayout.__init__cKs|j|||f|S)N)r@)rr<r;rr=rrrrendersz Layout.renderN)rrr__doc__rBr rCrrrrrAmsrAc@s2eZdZdZdZddddddZefddZdS) ButtonHolderag Layout object. It wraps fields in a
This is where you should put Layout objects that render to form buttons Attributes ---------- template: str The default template which this Layout Object will be rendered with. Parameters ---------- *fields : HTML or BaseInput The layout objects to render within the ``ButtonHolder``. It should only hold `HTML` and `BaseInput` inherited objects. css_id : str, optional A custom DOM id for the layout object. If not provided the name argument is slugified and turned into the id for the submit button. By default None. css_class : str, optional Additional CSS classes to be applied to the ````. By default None. template : str, optional Overrides the default template, if provided. By default None. Examples -------- An example using ``ButtonHolder`` in your layout:: ButtonHolder( HTML(Information Saved), Submit('Save', 'Save') ) z%s/layout/buttonholder.htmlN)css_id css_classrcGs&t||_||_||_|p|j|_dS)N)r1rrFrGr)rrFrGrrrrrrBs zButtonHolder.__init__cKs:|j|||f|}||}|||dt||S)N)Z buttonholder fields_output)r@rupdaterflatten)rr<r;rr=htmlrrrrrCs zButtonHolder.render)rrrrDrrBr rCrrrrrEs$rEc@s6eZdZdZdZdZddddddZefdd ZdS) BaseInputa A base class to reduce the amount of code in the Input classes. Attributes ---------- template: str The default template which this Layout Object will be rendered with. field_classes: str CSS classes to be applied to the ````. Parameters ---------- name : str The name attribute of the button. value : str The value attribute of the button. css_id : str, optional A custom DOM id for the layout object. If not provided the name argument is slugified and turned into the id for the submit button. By default None. css_class : str, optional Additional CSS classes to be applied to the ````. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to `flatatt` and converted into key="value", pairs. These attributes are added to the ````. z%s/layout/baseinput.htmlr8N)rFrGrcKsl||_||_|r||_nt|j}|jd||_i|_|rR|jd|7_|pZ|j|_t||_ dS)Nz-id- ) r ridr input_typeattrs field_classesrr flat_attrs)rr rrFrGrr=ZslugrrrrBs  zBaseInput.__init__cKs<tt|j||_||}|d|it||S)z Renders an `` if container is used as a Layout object. Input button value can be a variable in context. input)rrrrCrrIrrJ)rr<r;rr=rrrrrCs zBaseInput.render) rrrrDrrQrBr rCrrrrrLs rLc@seZdZdZdZdZdS)Submita Used to create a Submit button descriptor for the {% crispy %} template tag. Attributes ---------- template: str The default template which this Layout Object will be rendered with. field_classes: str CSS classes to be applied to the ````. input_type: str The ``type`` attribute of the ````. Parameters ---------- name : str The name attribute of the button. value : str The value attribute of the button. css_id : str, optional A custom DOM id for the layout object. If not provided the name argument is slugified and turned into the id for the submit button. By default None. css_class : str, optional Additional CSS classes to be applied to the ````. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to `flatatt` and converted into key="value", pairs. These attributes are added to the ````. Examples -------- Note: ``form`` arg to ``render()`` is not required for ``BaseInput`` inherited objects. >>> submit = Submit('Search the Site', 'search this site') >>> submit.render("", "", Context()) '' >>> submit = Submit('Search the Site', 'search this site', css_id="custom-id", css_class="custom class", my_attr=True, data="my-data") >>> submit.render("", "", Context()) '' Usually you will not call the render method on the object directly. Instead add it to your ``Layout`` manually or use the `add_input` method:: class ExampleForm(forms.Form): [...] def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.helper = FormHelper() self.helper.add_input(Submit('submit', 'Submit')) Zsubmitzbtn btn-primaryN)rrrrDrOrQrrrrrTs:rTc@seZdZdZdZdZdS)Buttonai Used to create a button descriptor for the {% crispy %} template tag. Attributes ---------- template: str The default template which this Layout Object will be rendered with. field_classes: str CSS classes to be applied to the ````. input_type: str The ``type`` attribute of the ````. Parameters ---------- name : str The name attribute of the button. value : str The value attribute of the button. css_id : str, optional A custom DOM id for the layout object. If not provided the name argument is slugified and turned into the id for the submit button. By default None. css_class : str, optional Additional CSS classes to be applied to the ````. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to `flatatt` and converted into key="value", pairs. These attributes are added to the ````. Examples -------- Note: ``form`` arg to ``render()`` is not required for ``BaseInput`` inherited objects. >>> button = Button('Button 1', 'Press Me!') >>> button.render("", "", Context()) '' >>> button = Button('Button 1', 'Press Me!', css_id="custom-id", css_class="custom class", my_attr=True, data="my-data") >>> button.render("", "", Context()) '' Usually you will not call the render method on the object directly. Instead add it to your ``Layout`` manually or use the `add_input` method:: class ExampleForm(forms.Form): [...] def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.helper = FormHelper() self.helper.add_input(Button('Button 1', 'Press Me!')) buttonZbtnN)rrrrDrOrQrrrrrUGs:rUc@seZdZdZdZdZdS)Hiddena Used to create a Hidden input descriptor for the {% crispy %} template tag. Attributes ---------- template: str The default template which this Layout Object will be rendered with. field_classes: str CSS classes to be applied to the ````. input_type: str The ``type`` attribute of the ````. Parameters ---------- name : str The name attribute of the button. value : str The value attribute of the button. css_id : str, optional A custom DOM id for the layout object. If not provided the name argument is slugified and turned into the id for the submit button. By default None. css_class : str, optional Additional CSS classes to be applied to the ````. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to `flatatt` and converted into key="value", pairs. These attributes are added to the ````. Examples -------- Note: ``form`` arg to ``render()`` is not required for ``BaseInput`` inherited objects. >>> hidden = Hidden("hidden", "hide-me") >>> hidden.render("", "", Context()) '' Usually you will not call the render method on the object directly. Instead add it to your ``Layout`` manually or use the `add_input` method:: class ExampleForm(forms.Form): [...] def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.helper = FormHelper() self.helper.add_input(Hidden("hidden", "hide-me")) hiddenN)rrrrDrOrQrrrrrWs3rWc@seZdZdZdZdZdS)Reseta Used to create a reset button descriptor for the {% crispy %} template tag. Attributes ---------- template: str The default template which this Layout Object will be rendered with. field_classes: str CSS classes to be applied to the ````. input_type: str The ``type`` attribute of the ````. Parameters ---------- name : str The name attribute of the button. value : str The value attribute of the button. css_id : str, optional A custom DOM id for the layout object. If not provided the name argument is slugified and turned into the id for the submit button. By default None. css_class : str, optional Additional CSS classes to be applied to the ````. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to `flatatt` and converted into key="value", pairs. These attributes are added to the ````. Examples -------- Note: ``form`` arg to ``render()`` is not required for ``BaseInput`` inherited objects. >>> reset = Reset('Reset This Form', 'Revert Me!') >>> reset.render("", "", Context()) '' >>> reset = Reset('Reset This Form', 'Revert Me!', css_id="custom-id", css_class="custom class", my_attr=True, data="my-data") >>> reset.render("", "", Context()) '' Usually you will not call the render method on the object directly. Instead add it to your ``Layout`` manually manually or use the `add_input` method:: class ExampleForm(forms.Form): [...] def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.helper = FormHelper() self.helper.add_input(Reset('Reset This Form', 'Revert Me!')) resetzbtn btn-inverseN)rrrrDrOrQrrrrrYs:rYc@s2eZdZdZdZddddddZefddZdS) Fieldseta A layout object which wraps fields in a ``
`` Parameters ---------- legend : str The content of the fieldset's ````. This text is context aware, to bring this to life see the examples section. *fields : str Any number of fields as positional arguments to be rendered within the ``
`` css_class : str, optional Additional CSS classes to be applied to the ````. By default None. css_id : str, optional A custom DOM id for the layout object. If not provided the name argument is slugified and turned into the id for the submit button. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the ``
``. Examples -------- The Fieldset Layout object is added to your ``Layout`` for example:: Fieldset("Text for the legend", "form_field_1", "form_field_2", css_id="my-fieldset-id", css_class="my-fieldset-class", data="my-data" ) The above layout will be rendered as:: '''
Text for the legend # form fields render here
''' The first parameter is the text for the fieldset legend. This text is context aware, so you can do things like:: Fieldset("Data for {{ user.username }}", 'form_field_1', 'form_field_2' ) z%s/layout/fieldset.htmlN)rGrFrcOs6t||_||_||_||_|p$|j|_t||_dS)N)r1rlegendrGrFrr rR)rr\rGrFrrr=rrrrB:s   zFieldset.__init__cKsR|j|||f|}|jr.tt|j|}ntd}||}t||||dS)Nr8)fieldsetr\r)r@r\rrrCrrr)rr<r;rr=rr\rrrrrCBs  zFieldset.render)rrrrDrrBr rCrrrrr[s6r[c@s<eZdZdZdZdZdddddddddZefdd ZdS) MultiFielda MultiField container for Bootstrap3. Renders to a MultiField
. Attributes ---------- template: str The default template which this Layout Object will be rendered with. field_template: str The template which fields will be rendered with. Parameters ---------- label: str The label for the multifield. *fields: str The fields to be rendered within the multifield. label_class: str, optional CSS classes to be added to the multifield label. By default None. help_text: str, optional Help text will be available in the context of the multifield template. This is unused in the bootstrap3 template provided. By default None. css_class : str, optional Additional CSS classes to be applied to the ````. By default None. css_id : str, optional A DOM id for the layout object which will be added to the wrapping ``
`` if provided. By default None. template : str, optional Overrides the default template, if provided. By default None. field_template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the wrapping ``
``. z%s/layout/multifield.htmlz%s/multifield.htmlN) label_class help_textrGrFrfield_templatec OsVt||_||_|pd|_|p d|_||_||_|p8|j|_|pD|j|_t | |_ dS)NZ blockLabelZ ctrlHolder) r1rZ label_htmlr_rGrFr`rrar rR) rlabelr_r`rGrFrrarr=rrrrBys     zMultiField.__init__c Ks|drsz$MultiField.render..z error)rZ labelclassr7)Z multifieldrH) r-errorsrGrar@r_rrIrrJ) rr<r;rr=r:rarHrrrrrCs    zMultiField.render) rrrrDrrarBr rCrrrrr^Ns& r^c@s6eZdZdZdZdZddddddZefddZdS) Diva Layout object. It wraps fields in a ``
``. Attributes ---------- template : str The default template which this Layout Object will be rendered with. css_class : str, optional CSS classes to be applied to the ``
``. By default None. Parameters ---------- *fields : str, LayoutObject Any number of fields as positional arguments to be rendered within the ``
``. css_id : str, optional A DOM id for the layout object which will be added to the ``
`` if provided. By default None. css_class : str, optional Additional CSS classes to be applied in addition to those declared by the class itself. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the ``
``. Examples -------- In your ``Layout`` you can:: Div( 'form_field_1', 'form_field_2', css_id='div-example', css_class='divs', ) It is also possible to nest Layout Objects within a Div:: Div( Div( Field('form_field', css_class='field-class'), css_class='div-class', ), Div('form_field_2', css_class='div-class'), ) z%s/layout/div.htmlN)rFrGrcOsTt||_|jr*|r*|jd|7_n |r4||_||_|pB|j|_t||_dS)NrM)r1rrGrFrr rR)rrFrGrrr=rrrrBs   z Div.__init__cKs,|j|||f|}||}t|||dS)N)divr)r@rr)rr<r;rr=rrrrrrCs z Div.render) rrrrDrrGrBr rCrrrrres 2 rec@seZdZdZdZdS)Rowa Layout object. It wraps fields in a ``
`` and the template adds the appropriate class to render the contents in a row. e.g. ``form-row`` when using the Bootstrap4 template pack. Attributes ---------- template : str The default template which this Layout Object will be rendered with. css_class : str, optional CSS classes to be applied to the ``
``. By default None. Parameters ---------- *fields : str, LayoutObject Any number of fields as positional arguments to be rendered within the ``
``. css_id : str, optional A DOM id for the layout object which will be added to the ``
`` if provided. By default None. css_class : str, optional Additional CSS classes to be applied in addition to those declared by the class itself. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the ``
``. Examples -------- In your ``Layout`` you can:: Row('form_field_1', 'form_field_2', css_id='row-example') It is also possible to nest Layout Objects within a Row:: Row( Div( Field('form_field', css_class='field-class'), css_class='div-class', ), Div('form_field_2', css_class='div-class'), ) z%s/layout/row.htmlN)rrrrDrrrrrrgs/rgc@seZdZdZdZdS)Columna Layout object. It wraps fields in a ``
`` and the template adds the appropriate class to render the contents in a column. e.g. ``col-md`` when using the Bootstrap4 template pack. Attributes ---------- template : str The default template which this Layout Object will be rendered with. css_class : str, optional CSS classes to be applied to the ``
``. By default None. Parameters ---------- *fields : str, LayoutObject Any number of fields as positional arguments to be rendered within the ``
``. css_id : str, optional A DOM id for the layout object which will be added to the ``
`` if provided. By default None. css_class : str, optional Additional CSS classes to be applied in addition to those declared by the class itself. If using the Bootstrap4 template pack the default ``col-md`` is removed if this string contins another ``col-`` class. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the ``
``. Examples -------- In your ``Layout`` you can:: Column('form_field_1', 'form_field_2', css_id='col-example') It is also possible to nest Layout Objects within a Row:: Div( Column( Field('form_field', css_class='field-class'), css_class='col-sm, ), Column('form_field_2', css_class='col-sm'), ) z%s/layout/column.htmlN)rrrrDrrrrrrh%s1rhc@s$eZdZdZddZefddZdS)HTMLa# Layout object. It can contain pure HTML and it has access to the whole context of the page where the form is being rendered. Examples:: HTML("{% if saved %}Data saved{% endif %}") HTML('') cCs ||_dS)N)rK)rrKrrrrBfsz HTML.__init__cKstt|j|S)N)rrrKrC)rr<r;rr=rrrrCisz HTML.renderN)rrrrDrBr rCrrrrri[s ric@s8eZdZdZdZiZddddddZedfddZdS) Fielda A Layout object, usually containing one field name, where you can add attributes to it easily. Attributes ---------- template : str The default template which this Layout Object will be rendered with. attrs : dict Attributes to be applied to the field. These are converted into html attributes. e.g. ``data_id: 'test'`` in the attrs dict will become ``data-id='test'`` on the field's ````. Parameters ---------- *fields : str Usually a single field, but can be any number of fields, to be rendered with the same attributes applied. css_class : str, optional CSS classes to be applied to the field. These are added to any classes included in the ``attrs`` dict. By default ``None``. wrapper_class: str, optional CSS classes to be used when rendering the Field. This class is usually applied to the ``
`` which wraps the Field's ``