LocalizedFileFieldForm

Complexity

Total Complexity

34

Size/Duplication

Total Lines	86
Duplicated Lines	0 %

Test Coverage

Coverage

90.74%

Importance

Changes	1
Bugs	0	Features	1

2 Methods

Rating	Name	Duplication	Size	Complexity
B	bound_data()	0	13	6
F	clean()	0	64	28

from typing import List

The import typing could not be resolved.

from django import forms

The import django could not be resolved.

from django.conf import settings

The import django.conf could not be resolved.

from django.core.exceptions import ValidationError

The import django.core.exceptions could not be resolved.

from django.forms.widgets import FILE_INPUT_CONTRADICTION

The import django.forms.widgets could not be resolved.

from .value import LocalizedValue, LocalizedStringValue, \
    LocalizedFileValue
from .widgets import LocalizedFieldWidget, LocalizedCharFieldWidget, \
    LocalizedFileWidget


class LocalizedFieldForm(forms.MultiValueField):
    """Form for a localized field, allows editing
    the field in multiple languages."""

    widget = LocalizedFieldWidget
    field_class = forms.fields.CharField
    value_class = LocalizedValue

    def __init__(self, *args, **kwargs):
        """Initializes a new instance of :see:LocalizedFieldForm."""

        fields = []

        for lang_code, _ in settings.LANGUAGES:
            field_options = {'required': False}

            if lang_code == settings.LANGUAGE_CODE:
                field_options['required'] = kwargs.get('required', True)

            field_options['label'] = lang_code
            fields.append(self.field_class(**field_options))

Usage of * or ** arguments should usually be done with care.

        super(LocalizedFieldForm, self).__init__(
            fields,
            require_all_fields=False,
            *args, **kwargs
        )
        # set 'required' attribute for each widget separately
        for f, w in zip(self.fields, self.widget.widgets):

The Instance of LocalizedFieldForm does not seem to have a member named fields.

The Class LocalizedFieldWidget does not seem to have a member named widgets.

            w.is_required = f.required

    def compress(self, value: List[str]) -> value_class:

Undefined variable 'value_class'

        """Compresses the values from individual fields
        into a single :see:LocalizedValue instance.

        Arguments:
            value:
                The values from all the widgets.

        Returns:
            A :see:LocalizedValue containing all
            the value in several languages.
        """

        localized_value = self.value_class()

        for (lang_code, _), value in zip(settings.LANGUAGES, value):
            localized_value.set(lang_code, value)

        return localized_value


class LocalizedCharFieldForm(LocalizedFieldForm):
    """Form for a localized char field, allows editing
    the field in multiple languages."""

    widget = LocalizedCharFieldWidget
    value_class = LocalizedStringValue


class LocalizedTextFieldForm(LocalizedFieldForm):
    """Form for a localized text field, allows editing
    the field in multiple languages."""

    value_class = LocalizedStringValue


class LocalizedFileFieldForm(LocalizedFieldForm, forms.FileField):
    """Form for a localized file field, allows editing
    the field in multiple languages."""

    widget = LocalizedFileWidget
    field_class = forms.fields.FileField
    value_class = LocalizedFileValue

    def clean(self, value, initial=None):
        """
        Most part of this method is a copy of 

Trailing whitespace

        django.forms.MultiValueField.clean, with the exception of initial
        value handling (this need for correct processing FileField's).
        All original comments saved.
        """
        if initial is None:
            initial = [None for x in range(0, len(value))]
        else:
            if not isinstance(initial, list):
                initial = self.widget.decompress(initial)

        clean_data = []
        errors = []
        if not value or isinstance(value, (list, tuple)):
            if (not value or not [v for v in value if
                                  v not in self.empty_values]) \

The Instance of LocalizedFileFieldForm does not seem to have a member named empty_values.

                    and (not initial or not [v for v in initial if
                                             v not in self.empty_values]):

The Instance of LocalizedFileFieldForm does not seem to have a member named empty_values.

                if self.required:

The Instance of LocalizedFileFieldForm does not seem to have a member named required.

                    raise ValidationError(self.error_messages['required'],

The Instance of LocalizedFileFieldForm does not seem to have a member named error_messages.

                                          code='required')
        else:
            raise ValidationError(self.error_messages['invalid'],

The Instance of LocalizedFileFieldForm does not seem to have a member named error_messages.

                                  code='invalid')
        for i, field in enumerate(self.fields):

The Instance of LocalizedFileFieldForm does not seem to have a member named fields.

            try:
                field_value = value[i]
            except IndexError:
                field_value = None
            try:
                field_initial = initial[i]
            except IndexError:
                field_initial = None
            if field_value in self.empty_values and \

The Instance of LocalizedFileFieldForm does not seem to have a member named empty_values.

                            field_initial in self.empty_values:

The Instance of LocalizedFileFieldForm does not seem to have a member named empty_values.

                if self.require_all_fields:

The Instance of LocalizedFileFieldForm does not seem to have a member named require_all_fields.

                    # Raise a 'required' error if the MultiValueField is
                    # required and any field is empty.
                    if self.required:

The Instance of LocalizedFileFieldForm does not seem to have a member named required.

                        raise ValidationError(self.error_messages['required'],

The Instance of LocalizedFileFieldForm does not seem to have a member named error_messages.

                                              code='required')
                elif field.required:
                    # Otherwise, add an 'incomplete' error to the list of
                    # collected errors and skip field cleaning, if a required
                    # field is empty.
                    if field.error_messages['incomplete'] not in errors:
                        errors.append(field.error_messages['incomplete'])
                    continue
            try:
                clean_data.append(field.clean(field_value, field_initial))
            except ValidationError as e:
                # Collect all validation errors in a single list, which we'll
                # raise at the end of clean(), rather than raising a single
                # exception for the first error we encounter. Skip duplicates.
                errors.extend(m for m in e.error_list if m not in errors)
        if errors:
            raise ValidationError(errors)

        out = self.compress(clean_data)
        self.validate(out)

The Instance of LocalizedFileFieldForm does not seem to have a member named validate.

        self.run_validators(out)

The Instance of LocalizedFileFieldForm does not seem to have a member named run_validators.

        return out

    def bound_data(self, data, initial):
        bound_data = []
        if initial is None:
            initial = [None for x in range(0, len(data))]
        else:
            if not isinstance(initial, list):
                initial = self.widget.decompress(initial)
        for d, i in zip(data, initial):
            if d in (None, FILE_INPUT_CONTRADICTION):
                bound_data.append(i)
            else:
                bound_data.append(d)
        return bound_data