ogddlmZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z ddlmZmZmZeGd d ZGd d ZGd deZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGdd eZGd!d"eZGd#d$eZGd%d&eZ Gd'd(Z!Gd)d*eZ"Gd+d,e"Z#y-).) dataclass)List)Template)render_to_string)conditional_escape) SafeString)slugify) TEMPLATE_PACKflatatt render_fieldc(eZdZUeeed<eed<y)Pointer positionsnameN)__name__ __module__ __qualname__rint__annotations__strL/var/www/medrc_site/venv/lib/python3.12/site-packages/crispy_forms/layout.pyrr sCy IrrceZdZdZy)TemplateNameMixinc\d|jvr|j|z}|S|j}|S)Nz%s)template)self template_packrs rget_template_namez#TemplateNameMixin.get_template_names3 4== }}}4H}}HrN)rrrr rrrrrsrrcLeZdZdZdZdZdZdZd dZddd d d Z e fd Z y) LayoutObjectc |j|SNfieldsrslices r __getitem__zLayoutObject.__getitem__s{{5!!rc"||j|<yr$r%)rr(values r __setitem__zLayoutObject.__setitem__!s" Erc|j|=yr$r%r's r __delitem__zLayoutObject.__delitem__$s KK rc,t|jSr$)lenr&)rs r__len__zLayoutObject.__len__'s4;;rcd|jvr,t|j|rt|j|Stj ||S)z This allows us to access self.fields list methods like append or insert, without having to declare them one by one r&)__dict__hasattrr&getattrobject__getattribute__)rrs r __getattr__zLayoutObject.__getattr__*sA t}} $d)C4;;- -**46 6rNc2|jtddS)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:s rget_field_nameszLayoutObject.get_field_names5s&&s$t&DDrrFr: max_levelr;cg}|t|ts|g}n|g}t|dk(xr |dtk(}t |j D]\}}t||rc|r |j t||gz|nA|j t||gz|jjjt|dst||ks|s||gz||d} ||j|i| z}|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. rr=r>) isinstancelistr0r enumerater&appendr __class__rlowerr4r<) rr:r?r; LayoutClassespointers str_classi layout_object new_kwargss rr<zLayoutObject.get_layout_objectsAs   Zt%<GE ]E &!+G a0@C0G )$++ 6 e A}-7OOGEQCK$GHOOGEQCK9P9P9Y9Y9_9_9a$bc}&78c%j9>TX^',s{V\] #&Fm&F&F &dYc&dd erc jtdjfd|jDS)Nc3>K|]}t|fdiyw)rN)r ).0fieldcontextformkwargsrs r z3LayoutObject.get_rendered_fields..is&wbgLg]]]V\]ws)rjoinr&rrTrSrrUs ````rget_rendered_fieldsz LayoutObject.get_rendered_fieldsgs) GGwkokvkvw w  rr$) rrrr)r,r.r1r8r=r<r rYrrrr"r"s="#  7 E8'), 'company' ), ButtonHolder( Submit('Save', 'Save', css_class='button white'), ), ) c$t||_yr$)rCr&)rr&s r__init__zLayout.__init__s 6l rc ,|j|||fi|Sr$)rYrXs rrenderz Layout.renders't''g}OOOrNrrr__doc__r]r r_rrrr[r[ms8#3@Prr[c.eZdZdZdZdddddZefdZy) 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.htmlNcss_id css_classrcjt||_||_||_|xs |j|_yr$)rCr&rerfr)rrerfrr&s rr]zButtonHolder.__init__s+6l  " 1DMM rc |j|||fi|}|j|}|j||dt||j S)N) buttonholder fields_output)rYr updaterflatten)rrTrSrrUhtmlrs rr_zButtonHolder.rendersR't''g}OO))-8tDE'//*;<``. 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.htmlrONrdc ||_||_|r||_n+t|j}|jd||_i|_|r|xj d|z c_|xs |j|_t||_ y)Nz-id- ) rr+idr input_typeattrs field_classesrr flat_attrs)rrr+rerfrrUslugs rr]zBaseInput.__init__s{  DG499%D)dV4DG    Ai[/ 1  1DMM !&/rc tt|jj||_|j |}|j d|it ||jS)z Renders an `` if container is used as a Layout object. Input button value can be a variable in context. input)rrr+r_r rkrrl)rrTrSrrUrs rr_zBaseInput.rendersW c$**o.55g> ))-8''//*;<*HM.2dT* 3@ =rrpceZdZdZdZdZy)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')) submitzbtn btn-primaryNrrrrartrvrrrr|r|s9vJ%Mrr|ceZdZdZdZdZy)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!')) buttonbtnNr~rrrrrGs9vJMrrceZdZdZdZdZy)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")) hiddenNr~rrrrrs2hJMrrceZdZdZdZdZy)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-inverseNr~rrrrrs9vJ%Mrrc.eZdZdZdZdddddZefdZy)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 | LayoutObject | HTML 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)rfrerct||_||_||_||_|xs |j |_t ||_yr$)rCr&legendrfrerr rw)rrrfrerr&rUs rr]zFieldset.__init__:s=6l  "  1DMM !&/rc 6|j|||fi|}|jr.tt|jj |}n t d}|j |}|j|||dt||jS)NrO)fieldsetrr&) rYrrrr_rr rkrrl)rrTrSrrUr&rrs rr_zFieldset.renderBs)))$Q&Q ;;c$++./66w?F^F))-8DFfMN'//*;<. 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_textrfrerfield_templatect||_||_|xsd|_|xsd|_||_||_|xs |j|_|xs |j|_t| |_ y)N blockLabel ctrlHolder) rCr& label_htmlrrfrerrrr rw) rlabelrrrfrerrr&rUs rr]zMultiField.__init__zsk6l &6,"2l " 1DMM ,C0C0C!&/rc n|dr@d|jDD]&}||jvs|xjdz c_(|j|z}|j|||f||j |d|}|j |}|j||dt||jS)Nform_show_errorsc34K|]}|jywr$)r)rQpointers rrVz$MultiField.render..sM7',,Msz error)r labelclassrL) multifieldrj) r=errorsrfrrYrr rkrrl) rrTrSrrUrRrrjrs rr_zMultiField.renders % &Md6J6J6LM /DKK'NNh.N /,,}<000    $''   ))-8d]KL'//*;<``. 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.htmlNrdct||_|jr|r|xjd|z c_n |r||_||_|xs |j|_t ||_y)Nrr)rCr&rfrerr rw)rrerfrr&rUs rr]z Div.__init__sV6l >>i NN)o -N &DN  1DMM !&/rc l|j|||fi|}|j|}t|||dS)N)divr&)rYr r)rrTrSrrUr&rs rr_z Div.renders?)))$Q&Q))-8$&*IJJr) rrrrarrfr]r r_rrrrrs,1f$HI'+td *3@KrrceZdZdZdZy)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.htmlNrrrrarrrrrrs.`$HrrceZdZdZdZy)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.htmlNrrrrrr&s0d'Hrrc eZdZdZdZefdZy)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('') c||_yr$)rm)rrms rr]z HTML.__init__gs  rc \tt|jj|Sr$)rrrmr_rXs rr_z HTML.renderjs DII'..w77rNr`rrrrr\s3@8rrc4eZdZdZdZiZdddddZedfdZy)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 ``