def __init__(self, filetype, format): self.filetype = template.Variable(filetype) self.format = template.Variable(format)
def __init__(self, app_label, model_name, plural): self.app_label = template.Variable(app_label) self.model_name = template.Variable(model_name) self.plural = template.Variable(plural)
def __init__(self, context_name, starts_with=None): self.context_name = context_name if starts_with: self.starts_with = template.Variable(starts_with) else: self.starts_with = None
def __init__(self, group_name, context_name): self.group = template.Variable(group_name) self.context_name = context_name
def resolve(arg): try: return template.Variable(arg).resolve(context) except template.VariableDoesNotExist: return arg
def __init__(self, product_id): self.product_id = template.Variable(product_id)
def get_active_tabs(context): active_tabs = template.Variable(ACTIVE_TAB_NAME) try: return active_tabs.resolve(context) except template.VariableDoesNotExist: return {}
def __init__(self, table): self.table = template.Variable(table)
def render(self, context): iterable = template.Variable(self.iterable).resolve(context) num_cols = self.num_cols context[self.varname] = zip( *[chain(iterable, [None] * (num_cols - 1))] * num_cols) return ''
def __init__(self, image_var_name, filter_spec, output_var_name=None): self.image_var = template.Variable(image_var_name) self.filter, created = Filter.objects.get_or_create(spec=filter_spec) self.output_var_name = output_var_name
def __init__(self, nodelist, domain_var): self.nodelist = nodelist self.domain_var = template.Variable(domain_var)
def __init__(self, page_range, page): self.page_range = template.Variable(page_range) self.page = template.Variable(page)
def __init__(self, user, key): self.user = template.Variable(user) self.key = key
def __init__(self, instancia, etiqueta, nodelist): self.instancia = template.Variable(instancia) self.etiqueta = etiqueta self.etiqueta = self.etiqueta.replace("\"", "") self.etiqueta = self.etiqueta.replace("'", "") self.nodelist = nodelist
def __init__(self, object_data, object_show_fields, object_ex_fields): self.object = template.Variable(object_data) self.show_fields = template.Variable(object_show_fields) self.ex_fields = template.Variable(object_ex_fields)
def __init__(self, obj, varname): self.obj = template.Variable(obj) self.varname = varname
def __init__(self, object): self.object = template.Variable(object)
def render(self, context): # noqa: C901 # Nodes are not threadsafe so we must store and look up our instance # variables in the current rendering context first if self not in context.render_context: context.render_context[self] = ( template.Variable(self.field), self.attrs, template.Variable(self.html5_required), ) field, attrs, html5_required = context.render_context[self] field = field.resolve(context) try: html5_required = html5_required.resolve(context) except template.VariableDoesNotExist: html5_required = False # If template pack has been overridden in FormHelper we can pick it from context template_pack = context.get("template_pack", TEMPLATE_PACK) # There are special django widgets that wrap actual widgets, # such as forms.widgets.MultiWidget, admin.widgets.RelatedFieldWidgetWrapper widgets = getattr( field.field.widget, "widgets", [getattr(field.field.widget, "widget", field.field.widget)]) if isinstance(attrs, dict): attrs = [attrs] * len(widgets) converters = {} converters.update(getattr(settings, "CRISPY_CLASS_CONVERTERS", {})) for widget, attr in zip(widgets, attrs): class_name = widget.__class__.__name__.lower() class_name = converters.get(class_name, class_name) css_class = widget.attrs.get("class", "") if css_class: if css_class.find(class_name) == -1: css_class += " %s" % class_name else: css_class = class_name # Added additional code for Tailwind if template_pack == "tailwind": css_container = context.get("css_container", self.default_container) if css_container: css = " " + css_container.get_input_class(field) css_class += css if field.errors: error_border_class = css_container.error_border css_class = re.sub(r"border-\S+", error_border_class, css_class) widget.attrs["class"] = css_class # HTML5 required attribute if html5_required and field.field.required and "required" not in widget.attrs: if field.field.widget.__class__.__name__ != "RadioSelect": widget.attrs["required"] = "required" for attribute_name, attribute in attr.items(): attribute_name = template.Variable(attribute_name).resolve( context) if attribute_name in widget.attrs: widget.attrs[attribute_name] += " " + template.Variable( attribute).resolve(context) else: widget.attrs[attribute_name] = template.Variable( attribute).resolve(context) return str(field)
def __init__(self, name, namespace=None): if namespace is None: namespace = DEFAULT_NAMESPACE self.namespace = template.Variable(namespace) self.name = template.Variable(name)
def __init__(self, integration): self.integration = template.Variable(integration)
def __init__(self, nodelist_true, nodelist_false, obj_var): self.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false self.obj_var = template.Variable(obj_var)
def __init__(self, var_name): self.var_name = var_name self.username = template.Variable(var_name)
def __init__(self, object, varname): """ The class constructor """ self.object = template.Variable(object) self.varname = varname
def __init__(self, target, parser, expression, var_name): self.target = target self.expression = template.Variable(expression) self.var_name = var_name self.parser = parser
def __init__(self, time): self.time = template.Variable(time)
def __init__(self, user, var_name, rel): self.user = template.Variable(user) self.var_name = var_name self.rel = rel
def __init__(self): self.for_first = template.Variable('forloop.first') self.for_last = template.Variable('forloop.last')
def __init__(self, email): self.email = template.Variable(email)
def __init__(self, vobj, vadditional=None): self.vobj = template.Variable(vobj) self.vadditional = vadditional
def get_render(self, context): """ Returns a `Context` object with all the necessary stuff for rendering the form :param context: `django.template.Context` variable holding the context for the node `self.form` and `self.helper` are resolved into real Python objects resolving them from the `context`. The `actual_form` can be a form or a formset. If it's a formset `is_formset` is set to True. If the helper has a layout we use it, for rendering the form or the formset's forms. """ # Nodes are not thread safe in multithreaded environments # https://docs.djangoproject.com/en/dev/howto/custom-template-tags/#thread-safety-considerations if self not in context.render_context: context.render_context[self] = ( template.Variable(self.form), template.Variable(self.helper) if self.helper else None ) form, helper = context.render_context[self] actual_form = form.resolve(context) if self.helper is not None: helper = helper.resolve(context) else: # If the user names the helper within the form `helper` (standard), we use it # This allows us to have simplified tag syntax: {% crispy form %} helper = FormHelper() if not hasattr(actual_form, 'helper') else actual_form.helper # use template_pack from helper, if defined try: if helper.template_pack: self.template_pack = helper.template_pack except AttributeError: pass self.actual_helper = helper # We get the response dictionary is_formset = isinstance(actual_form, BaseFormSet) response_dict = self.get_response_dict(helper, context, is_formset) node_context = context.__copy__() node_context.update(response_dict) final_context = node_context.__copy__() # If we have a helper's layout we use it, for the form or the formset's forms if helper and helper.layout: if not is_formset: actual_form.form_html = helper.render_layout(actual_form, node_context, template_pack=self.template_pack) else: forloop = ForLoopSimulator(actual_form) helper.render_hidden_fields = True for form in actual_form: node_context.update({'forloop': forloop}) node_context.update({'formset_form': form}) form.form_html = helper.render_layout(form, node_context, template_pack=self.template_pack) forloop.iterate() if is_formset: final_context['formset'] = actual_form else: final_context['form'] = actual_form return final_context