LocalizedFileField

Complexity

Total Complexity

24

Size/Duplication

Total Lines	75
Duplicated Lines	0 %

Test Coverage

Coverage

96.36%

Importance

Changes	4
Bugs	0	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	generate_filename()	0	9	2
A	value_to_string()	0	7	3
A	formfield()	0	6	2
A	get_prep_value()	0	14	4
A	__init__()	0	7	1
B	save_form_data()	0	6	5
A	deconstruct()	0	6	2
B	pre_save()	0	8	5

import json
import datetime
import posixpath

from django.core.files import File

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

from django.db.models.fields.files import FieldFile

The import django.db.models.fields.files could not be resolved.

from django.utils import six

The import django.utils could not be resolved.

from django.core.files.storage import default_storage

The import django.core.files.storage could not be resolved.

from django.utils.encoding import force_str, force_text

The import django.utils.encoding could not be resolved.

from localized_fields.fields import LocalizedField
from localized_fields.fields.field import LocalizedValueDescriptor
from localized_fields.value import LocalizedValue

from ..value import LocalizedFileValue
from ..forms import LocalizedFileFieldForm


class LocalizedFieldFile(FieldFile):

    def __init__(self, instance, field, name, lang):
        super().__init__(instance, field, name)
        self.lang = lang

    def save(self, name, content, save=True):
        name = self.field.generate_filename(self.instance, name, self.lang)

The Instance of LocalizedFieldFile does not seem to have a member named field.

The Instance of LocalizedFieldFile does not seem to have a member named instance.

        self.name = self.storage.save(name, content,

The Instance of LocalizedFieldFile does not seem to have a member named storage.

The attribute name was defined outside __init__.

                                      max_length=self.field.max_length)

The Instance of LocalizedFieldFile does not seem to have a member named field.

        self._committed = True

The attribute _committed was defined outside __init__.

        if save:
            self.instance.save()

The Instance of LocalizedFieldFile does not seem to have a member named instance.

    save.alters_data = True

    def delete(self, save=True):
        if not self:
            return

        if hasattr(self, '_file'):
            self.close()

The Instance of LocalizedFieldFile does not seem to have a member named close.

            del self.file

The Instance of LocalizedFieldFile does not seem to have a member named file.

        self.storage.delete(self.name)

The Instance of LocalizedFieldFile does not seem to have a member named storage.

        self.name = None

The attribute name was defined outside __init__.

        self._committed = False

The attribute _committed was defined outside __init__.

        if save:
            self.instance.save()

The Instance of LocalizedFieldFile does not seem to have a member named instance.

    delete.alters_data = True


class LocalizedFileValueDescriptor(LocalizedValueDescriptor):
    def __get__(self, instance, cls=None):
        value = super().__get__(instance, cls)
        for lang, file in value.__dict__.items():
            if isinstance(file, six.string_types) or file is None:
                file = self.field.value_class(instance, self.field, file, lang)
                value.set(lang, file)

            elif isinstance(file, File) and \
                    not isinstance(file, LocalizedFieldFile):
                file_copy = self.field.value_class(instance, self.field,
                                                   file.name, lang)
                file_copy.file = file
                file_copy._committed = False

It seems like _committed was declared protected and should not be accessed from this context.

                value.set(lang, file_copy)

            elif isinstance(file, LocalizedFieldFile) and \
                    not hasattr(file, 'field'):
                file.instance = instance
                file.field = self.field
                file.storage = self.field.storage
                file.lang = lang

            # Make sure that the instance is correct.
            elif isinstance(file, LocalizedFieldFile) \
                    and instance is not file.instance:
                file.instance = instance
                file.lang = lang
        return value


class LocalizedFileField(LocalizedField):
    descriptor_class = LocalizedFileValueDescriptor
    attr_class = LocalizedFileValue
    value_class = LocalizedFieldFile

    def __init__(self, verbose_name=None, name=None, upload_to='', storage=None,
                 **kwargs):

        self.storage = storage or default_storage
        self.upload_to = upload_to

        super().__init__(verbose_name, name, **kwargs)

    def deconstruct(self):
        name, path, args, kwargs = super().deconstruct()
        kwargs['upload_to'] = self.upload_to
        if self.storage is not default_storage:
            kwargs['storage'] = self.storage
        return name, path, args, kwargs

    def get_prep_value(self, value):
        """Returns field's value prepared for saving into a database."""

        if isinstance(value, LocalizedValue):
            prep_value = LocalizedValue()
            for k, v in value.__dict__.items():
                if v is None:
                    prep_value.set(k, '')
                else:
                    # Need to convert File objects provided via a form to
                    # unicode for database insertion
                    prep_value.set(k, six.text_type(v))
            return super().get_prep_value(prep_value)
        return super().get_prep_value(value)

    def pre_save(self, model_instance, add):

This method could be written as a function/class method.

        """Returns field's value just before saving."""
        value = super().pre_save(model_instance, add)
        if isinstance(value, LocalizedValue):
            for file in value.__dict__.values():
                if file and not file._committed:

It seems like _committed was declared protected and should not be accessed from this context.

                    file.save(file.name, file, save=False)
        return value

    def generate_filename(self, instance, filename, lang):
        if callable(self.upload_to):
            filename = self.upload_to(instance, filename, lang)
        else:
            now = datetime.datetime.now()
            dirname = force_text(now.strftime(force_str(self.upload_to)))
            dirname = dirname.format(lang=lang)
            filename = posixpath.join(dirname, filename)
        return self.storage.generate_filename(filename)

    def save_form_data(self, instance, data):
        if isinstance(data, LocalizedValue):
            for k, v in data.__dict__.items():
                if v is not None and not v:
                    data.set(k, '')
            setattr(instance, self.name, data)

The Instance of LocalizedFileField does not seem to have a member named name.

    def formfield(self, **kwargs):
        defaults = {'form_class': LocalizedFileFieldForm}
        if 'initial' in kwargs:
            defaults['required'] = False
        defaults.update(kwargs)
        return super().formfield(**defaults)

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

    def value_to_string(self, obj):
        value = self.value_from_object(obj)

The Instance of LocalizedFileField does not seem to have a member named value_from_object.

        if isinstance(value, LocalizedFileValue):
            return json.dumps({k: v.name for k, v
                               in value.__dict__.items()})
        else:
            return super().value_to_string(obj)