Top

telemeta.models.fonds module

# -*- coding: utf-8 -*-
# Copyright (C) 2010 Samalyse SARL
# Copyright (C) 2010-2014 Parisson SARL

# This file is part of Telemeta.

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.

# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
# Authors: Olivier Guilyardi <olivier@samalyse.com>
#          David LIPSZYC <davidlipszyc@gmail.com>
#          Guillaume Pellerin <yomguy@parisson.com>

from __future__ import division
from django.utils.translation import ugettext_lazy as _
from telemeta.models.core import *
from telemeta.models.resource import *
from telemeta.models.corpus import *


class MediaFonds(MediaBaseResource):
    "Describe fonds"

    element_type = 'fonds'
    children_type = 'corpus'

    children = models.ManyToManyField(MediaCorpus, related_name="fonds",
                                      verbose_name=_('corpus'), blank=True, null=True)

    objects = MediaFondsManager()

    @property
    def public_id(self):
        return self.code

    @property
    def has_mediafile(self):
        for child in self.children.all():
            if child.has_mediafile:
                return True
        return False

    def computed_duration(self):
        duration = Duration()
        for child in self.children.all():
            duration += child.computed_duration()
        return duration
    computed_duration.verbose_name = _('total available duration')

    class Meta(MetaCore):
        db_table = 'media_fonds'
        verbose_name = _('fonds')
        verbose_name_plural = _('fonds')
        ordering = ['code']


class MediaFondsRelated(MediaRelated):
    "Fonds related media"

    resource = ForeignKey(MediaFonds, related_name="related", verbose_name=_('fonds'))

    class Meta(MetaCore):
        db_table = 'media_fonds_related'
        verbose_name = _('fonds related media')
        verbose_name_plural = _('fonds related media')

Module variables

var PUBLIC_ACCESS_CHOICES

var app_name

var code_linesep

var collection_code_regex

var collection_published_code_regex

var collection_unpublished_code_regex

var default_decoding

var default_encoding

var engine

var eol

var ext

var mime_type

var private_extra_types

var public_extra_types

var resource_code_regex

var strict_code

Classes

class MediaFonds

Describe fonds

class MediaFonds(MediaBaseResource):
    "Describe fonds"

    element_type = 'fonds'
    children_type = 'corpus'

    children = models.ManyToManyField(MediaCorpus, related_name="fonds",
                                      verbose_name=_('corpus'), blank=True, null=True)

    objects = MediaFondsManager()

    @property
    def public_id(self):
        return self.code

    @property
    def has_mediafile(self):
        for child in self.children.all():
            if child.has_mediafile:
                return True
        return False

    def computed_duration(self):
        duration = Duration()
        for child in self.children.all():
            duration += child.computed_duration()
        return duration
    computed_duration.verbose_name = _('total available duration')

    class Meta(MetaCore):
        db_table = 'media_fonds'
        verbose_name = _('fonds')
        verbose_name_plural = _('fonds')
        ordering = ['code']

Ancestors (in MRO)

  • MediaFonds
  • telemeta.models.resource.MediaBaseResource
  • telemeta.models.resource.MediaResource
  • telemeta.models.core.ModelCore
  • telemeta.models.core.EnhancedModel
  • django.db.models.base.Model
  • dirtyfields.dirtyfields.DirtyFieldsMixin
  • __builtin__.object

Class variables

var DoesNotExist

var ENABLE_M2M_CHECK

var Meta

var MultipleObjectsReturned

var children

var children_type

var compare_function

var element_type

var objects

var related

Static methods

def get_dom_field_name(

field_name)

Convert the class name to a DOM element name

@staticmethod
def get_dom_field_name(field_name):
    "Convert the class name to a DOM element name"
    tokens = field_name.split('_')
    name = tokens[0]
    for t in tokens[1:]:
        name += t[0].upper() + t[1:]
    return name

Instance variables

var has_mediafile

var pk

var public_id

Methods

def __init__(

self, *args, **kwargs)

def __init__(self, *args, **kwargs):
    signals.pre_init.send(sender=self.__class__, args=args, kwargs=kwargs)
    # Set up the storage for instance state
    self._state = ModelState()
    # There is a rather weird disparity here; if kwargs, it's set, then args
    # overrides it. It should be one or the other; don't duplicate the work
    # The reason for the kwargs check is that standard iterator passes in by
    # args, and instantiation for iteration is 33% faster.
    args_len = len(args)
    if args_len > len(self._meta.concrete_fields):
        # Daft, but matches old exception sans the err msg.
        raise IndexError("Number of args exceeds number of fields")
    if not kwargs:
        fields_iter = iter(self._meta.concrete_fields)
        # The ordering of the zip calls matter - zip throws StopIteration
        # when an iter throws it. So if the first iter throws it, the second
        # is *not* consumed. We rely on this, so don't change the order
        # without changing the logic.
        for val, field in zip(args, fields_iter):
            setattr(self, field.attname, val)
    else:
        # Slower, kwargs-ready version.
        fields_iter = iter(self._meta.fields)
        for val, field in zip(args, fields_iter):
            setattr(self, field.attname, val)
            kwargs.pop(field.name, None)
            # Maintain compatibility with existing calls.
            if isinstance(field.rel, ManyToOneRel):
                kwargs.pop(field.attname, None)
    # Now we're left with the unprocessed fields that *must* come from
    # keywords, or default.
    for field in fields_iter:
        is_related_object = False
        # This slightly odd construct is so that we can access any
        # data-descriptor object (DeferredAttribute) without triggering its
        # __get__ method.
        if (field.attname not in kwargs and
                (isinstance(self.__class__.__dict__.get(field.attname), DeferredAttribute)
                 or field.column is None)):
            # This field will be populated on request.
            continue
        if kwargs:
            if isinstance(field.rel, ForeignObjectRel):
                try:
                    # Assume object instance was passed in.
                    rel_obj = kwargs.pop(field.name)
                    is_related_object = True
                except KeyError:
                    try:
                        # Object instance wasn't passed in -- must be an ID.
                        val = kwargs.pop(field.attname)
                    except KeyError:
                        val = field.get_default()
                else:
                    # Object instance was passed in. Special case: You can
                    # pass in "None" for related objects if it's allowed.
                    if rel_obj is None and field.null:
                        val = None
            else:
                try:
                    val = kwargs.pop(field.attname)
                except KeyError:
                    # This is done with an exception rather than the
                    # default argument on pop because we don't want
                    # get_default() to be evaluated, and then not used.
                    # Refs #12057.
                    val = field.get_default()
        else:
            val = field.get_default()
        if is_related_object:
            # If we are passed a related instance, set it using the
            # field.name instead of field.attname (e.g. "user" instead of
            # "user_id") so that the object gets properly cached (and type
            # checked) by the RelatedObjectDescriptor.
            setattr(self, field.name, rel_obj)
        else:
            setattr(self, field.attname, val)
    if kwargs:
        for prop in list(kwargs):
            try:
                if isinstance(getattr(self.__class__, prop), property):
                    setattr(self, prop, kwargs.pop(prop))
            except AttributeError:
                pass
        if kwargs:
            raise TypeError("'%s' is an invalid keyword argument for this function" % list(kwargs)[0])
    super(Model, self).__init__()
    signals.post_init.send(sender=self.__class__, instance=self)

def clean(

self)

Hook for doing any extra model-wide validation after clean() has been called on every field by self.clean_fields. Any ValidationError raised by this method will not be associated with a particular field; it will have a special-case association with the field defined by NON_FIELD_ERRORS.

def clean(self):
    """
    Hook for doing any extra model-wide validation after clean() has been
    called on every field by self.clean_fields. Any ValidationError raised
    by this method will not be associated with a particular field; it will
    have a special-case association with the field defined by NON_FIELD_ERRORS.
    """
    pass

def clean_fields(

self, exclude=None)

Cleans all fields and raises a ValidationError containing message_dict of all validation errors if any occur.

def clean_fields(self, exclude=None):
    """
    Cleans all fields and raises a ValidationError containing message_dict
    of all validation errors if any occur.
    """
    if exclude is None:
        exclude = []
    errors = {}
    for f in self._meta.fields:
        if f.name in exclude:
            continue
        # Skip validation for empty fields with blank=True. The developer
        # is responsible for making sure they have a valid value.
        raw_value = getattr(self, f.attname)
        if f.blank and raw_value in f.empty_values:
            continue
        try:
            setattr(self, f.attname, f.clean(raw_value, self))
        except ValidationError as e:
            errors[f.name] = e.error_list
    if errors:
        raise ValidationError(errors)

def computed_duration(

self)

def computed_duration(self):
    duration = Duration()
    for child in self.children.all():
        duration += child.computed_duration()
    return duration

def date_error_message(

self, lookup_type, field, unique_for)

def date_error_message(self, lookup_type, field, unique_for):
    opts = self._meta
    return _("%(field_name)s must be unique for %(date_field)s %(lookup)s.") % {
        'field_name': six.text_type(capfirst(opts.get_field(field).verbose_name)),
        'date_field': six.text_type(capfirst(opts.get_field(unique_for).verbose_name)),
        'lookup': lookup_type,
    }

def delete(

self)

def delete(self):
    if not self.pk:
        raise Exception("Can't delete without a primary key")
    self.__class__.objects.filter(pk=self.pk).delete()

def field_label(

cls, field_name=None)

@classmethod
def field_label(cls, field_name=None):
    if field_name:
        try:
            return cls._meta.get_field(field_name).verbose_name
        except FieldDoesNotExist:
            try:
                return getattr(cls, field_name).verbose_name
            except AttributeError:
                return field_name
    else:
        return cls._meta.verbose_name

def full_clean(

self, exclude=None, validate_unique=True)

Calls clean_fields, clean, and validate_unique, on the model, and raises a ValidationError for any errors that occurred.

def full_clean(self, exclude=None, validate_unique=True):
    """
    Calls clean_fields, clean, and validate_unique, on the model,
    and raises a ``ValidationError`` for any errors that occurred.
    """
    errors = {}
    if exclude is None:
        exclude = []
    try:
        self.clean_fields(exclude=exclude)
    except ValidationError as e:
        errors = e.update_error_dict(errors)
    # Form.clean() is run even if other validation fails, so do the
    # same with Model.clean() for consistency.
    try:
        self.clean()
    except ValidationError as e:
        errors = e.update_error_dict(errors)
    # Run unique checks, but only for fields that passed validation.
    if validate_unique:
        for name in errors.keys():
            if name != NON_FIELD_ERRORS and name not in exclude:
                exclude.append(name)
        try:
            self.validate_unique(exclude=exclude)
        except ValidationError as e:
            errors = e.update_error_dict(errors)
    if errors:
        raise ValidationError(errors)

def get_dirty_fields(

self, check_relationship=False, check_m2m=None, verbose=False)

def get_dirty_fields(self, check_relationship=False, check_m2m=None, verbose=False):
    if self._state.adding:
        # If the object has not yet been saved in the database, all fields are considered dirty
        # for consistency (see https://github.com/romgar/django-dirtyfields/issues/65 for more details)
        pk_specified = self.pk is not None
        initial_dict = self._as_dict(check_relationship, include_primary_key=pk_specified)
        return initial_dict
    if check_m2m is not None and not self.ENABLE_M2M_CHECK:
        raise ValueError("You can't check m2m fields if ENABLE_M2M_CHECK is set to False")
    modified_fields = compare_states(self._as_dict(check_relationship),
                                     self._original_state,
                                     self.compare_function)
    if check_m2m:
        modified_m2m_fields = compare_states(check_m2m,
                                             self._original_m2m_state,
                                             self.compare_function)
        modified_fields.update(modified_m2m_fields)
    if not verbose:
        # Keeps backward compatibility with previous function return
        modified_fields = {key: value['saved'] for key, value in modified_fields.items()}
    return modified_fields

def get_dom_name(

cls)

Convert the class name to a DOM element name

@classmethod
def get_dom_name(cls):
    "Convert the class name to a DOM element name"
    clsname = cls.__name__
    return clsname[0].lower() + clsname[1:]

def get_fields(

self)

def get_fields(self):
    return self._meta.fields

def get_public_access_display(

*moreargs, **morekwargs)

def _curried(*moreargs, **morekwargs):
    return _curried_func(*(args + moreargs), **dict(kwargs, **morekwargs))

def get_revision(

self)

def get_revision(self):
    revisions = Revision.objects.filter(element_type=self.element_type, element_id=self.id).order_by('-time')
    if revisions:
        return revisions[0]
    else:
        return None

def is_dirty(

self, check_relationship=False, check_m2m=None)

def is_dirty(self, check_relationship=False, check_m2m=None):
    return {} != self.get_dirty_fields(check_relationship=check_relationship,
                                       check_m2m=check_m2m)

def prepare_database_save(

self, unused)

def prepare_database_save(self, unused):
    if self.pk is None:
        raise ValueError("Unsaved model instance %r cannot be used in an ORM query." % self)
    return self.pk

def public_access_label(

self)

def public_access_label(self):
    if self.public_access == 'metadata':
        return _('Metadata only')
    elif self.public_access == 'full':
        return _('Sound and metadata')
    return _('Private data')

def required_fields(

cls)

@classmethod
def required_fields(cls):
    required = []
    for field in cls._meta.fields:
        if not field.blank:
            required.append(field)
    return required

def save(

self, *args, **kwargs)

def save(self, *args, **kwargs):
    super(MediaBaseResource, self).save(*args, **kwargs)

def save_base(

self, raw=False, force_insert=False, force_update=False, using=None, update_fields=None)

Handles the parts of saving which should be done only once per save, yet need to be done in raw saves, too. This includes some sanity checks and signal sending.

The 'raw' argument is telling save_base not to save any parent models and not to do any changes to the values before save. This is used by fixture loading.

def save_base(self, raw=False, force_insert=False,
              force_update=False, using=None, update_fields=None):
    """
    Handles the parts of saving which should be done only once per save,
    yet need to be done in raw saves, too. This includes some sanity
    checks and signal sending.
    The 'raw' argument is telling save_base not to save any parent
    models and not to do any changes to the values before save. This
    is used by fixture loading.
    """
    using = using or router.db_for_write(self.__class__, instance=self)
    assert not (force_insert and (force_update or update_fields))
    assert update_fields is None or len(update_fields) > 0
    cls = origin = self.__class__
    # Skip proxies, but keep the origin as the proxy model.
    if cls._meta.proxy:
        cls = cls._meta.concrete_model
    meta = cls._meta
    if not meta.auto_created:
        signals.pre_save.send(sender=origin, instance=self, raw=raw, using=using,
                              update_fields=update_fields)
    with transaction.commit_on_success_unless_managed(using=using, savepoint=False):
        if not raw:
            self._save_parents(cls, using, update_fields)
        updated = self._save_table(raw, cls, force_insert, force_update, using, update_fields)
    # Store the database on which the object was saved
    self._state.db = using
    # Once saved, this is no longer a to-be-added instance.
    self._state.adding = False
    # Signal that the save is complete
    if not meta.auto_created:
        signals.post_save.send(sender=origin, instance=self, created=(not updated),
                               update_fields=update_fields, raw=raw, using=using)

def save_dirty_fields(

self)

def save_dirty_fields(self):
    dirty_fields = self.get_dirty_fields(check_relationship=True)
    save_specific_fields(self, dirty_fields)

def serializable_value(

self, field_name)

Returns the value of the field name for this instance. If the field is a foreign key, returns the id value, instead of the object. If there's no Field object with this name on the model, the model attribute's value is returned directly.

Used to serialize a field's value (in the serializer, or form output, for example). Normally, you would just access the attribute directly and not use this method.

def serializable_value(self, field_name):
    """
    Returns the value of the field name for this instance. If the field is
    a foreign key, returns the id value, instead of the object. If there's
    no Field object with this name on the model, the model attribute's
    value is returned directly.
    Used to serialize a field's value (in the serializer, or form output,
    for example). Normally, you would just access the attribute directly
    and not use this method.
    """
    try:
        field = self._meta.get_field_by_name(field_name)[0]
    except FieldDoesNotExist:
        return getattr(self, field_name)
    return getattr(self, field.attname)

def set_revision(

self, user)

Save a media object and add a revision

def set_revision(self, user):
    "Save a media object and add a revision"
    Revision.touch(self, user)

def to_dict(

self)

Return model fields as a dict of name/value pairs

def to_dict(self):
    "Return model fields as a dict of name/value pairs"
    fields_dict = {}
    for field in self._meta.fields:
        fields_dict[field.name] = getattr(self, field.name)
    return fields_dict

def to_dom(

self)

Return the DOM representation of this media object

def to_dom(self):
    "Return the DOM representation of this media object"
    impl = getDOMImplementation()
    root = self.get_dom_name()
    doc = impl.createDocument(None, root, None)
    top = doc.documentElement
    top.setAttribute("id", str(self.pk))
    fields = self.to_dict()
    for name, value in fields.iteritems():
        element = doc.createElement(self.get_dom_field_name(name))
        if isinstance(value, EnhancedModel):
            element.setAttribute('key', str(value.pk))
        value = unicode(value)
        element.appendChild(doc.createTextNode(value))
        top.appendChild(element)
    return doc

def to_list(

self)

Return model fields as a list

def to_list(self):
    "Return model fields as a list"
    fields_list = []
    for field in self._meta.fields:
        fields_list.append({'name': field.name, 'value': unicode(getattr(self, field.name))})
    return fields_list

def unique_error_message(

self, model_class, unique_check)

def unique_error_message(self, model_class, unique_check):
    opts = model_class._meta
    model_name = capfirst(opts.verbose_name)
    # A unique field
    if len(unique_check) == 1:
        field_name = unique_check[0]
        field = opts.get_field(field_name)
        field_label = capfirst(field.verbose_name)
        # Insert the error into the error dict, very sneaky
        return field.error_messages['unique'] % {
            'model_name': six.text_type(model_name),
            'field_label': six.text_type(field_label)
        }
    # unique_together
    else:
        field_labels = [capfirst(opts.get_field(f).verbose_name) for f in unique_check]
        field_labels = get_text_list(field_labels, _('and'))
        return _("%(model_name)s with this %(field_label)s already exists.") % {
            'model_name': six.text_type(model_name),
            'field_label': six.text_type(field_labels)
        }

def validate_unique(

self, exclude=None)

Checks unique constraints on the model and raises ValidationError if any failed.

def validate_unique(self, exclude=None):
    """
    Checks unique constraints on the model and raises ``ValidationError``
    if any failed.
    """
    unique_checks, date_checks = self._get_unique_checks(exclude=exclude)
    errors = self._perform_unique_checks(unique_checks)
    date_errors = self._perform_date_checks(date_checks)
    for k, v in date_errors.items():
        errors.setdefault(k, []).extend(v)
    if errors:
        raise ValidationError(errors)

class MediaFondsRelated

Fonds related media

class MediaFondsRelated(MediaRelated):
    "Fonds related media"

    resource = ForeignKey(MediaFonds, related_name="related", verbose_name=_('fonds'))

    class Meta(MetaCore):
        db_table = 'media_fonds_related'
        verbose_name = _('fonds related media')
        verbose_name_plural = _('fonds related media')

Ancestors (in MRO)

  • MediaFondsRelated
  • telemeta.models.resource.MediaRelated
  • telemeta.models.resource.MediaResource
  • telemeta.models.core.ModelCore
  • telemeta.models.core.EnhancedModel
  • django.db.models.base.Model
  • dirtyfields.dirtyfields.DirtyFieldsMixin
  • __builtin__.object

Class variables

var DoesNotExist

var ENABLE_M2M_CHECK

var Meta

var MultipleObjectsReturned

var compare_function

var element_type

var objects

var resource

Static methods

def get_dom_field_name(

field_name)

Convert the class name to a DOM element name

@staticmethod
def get_dom_field_name(field_name):
    "Convert the class name to a DOM element name"
    tokens = field_name.split('_')
    name = tokens[0]
    for t in tokens[1:]:
        name += t[0].upper() + t[1:]
    return name

Instance variables

var pk

Methods

def __init__(

self, *args, **kwargs)

def __init__(self, *args, **kwargs):
    signals.pre_init.send(sender=self.__class__, args=args, kwargs=kwargs)
    # Set up the storage for instance state
    self._state = ModelState()
    # There is a rather weird disparity here; if kwargs, it's set, then args
    # overrides it. It should be one or the other; don't duplicate the work
    # The reason for the kwargs check is that standard iterator passes in by
    # args, and instantiation for iteration is 33% faster.
    args_len = len(args)
    if args_len > len(self._meta.concrete_fields):
        # Daft, but matches old exception sans the err msg.
        raise IndexError("Number of args exceeds number of fields")
    if not kwargs:
        fields_iter = iter(self._meta.concrete_fields)
        # The ordering of the zip calls matter - zip throws StopIteration
        # when an iter throws it. So if the first iter throws it, the second
        # is *not* consumed. We rely on this, so don't change the order
        # without changing the logic.
        for val, field in zip(args, fields_iter):
            setattr(self, field.attname, val)
    else:
        # Slower, kwargs-ready version.
        fields_iter = iter(self._meta.fields)
        for val, field in zip(args, fields_iter):
            setattr(self, field.attname, val)
            kwargs.pop(field.name, None)
            # Maintain compatibility with existing calls.
            if isinstance(field.rel, ManyToOneRel):
                kwargs.pop(field.attname, None)
    # Now we're left with the unprocessed fields that *must* come from
    # keywords, or default.
    for field in fields_iter:
        is_related_object = False
        # This slightly odd construct is so that we can access any
        # data-descriptor object (DeferredAttribute) without triggering its
        # __get__ method.
        if (field.attname not in kwargs and
                (isinstance(self.__class__.__dict__.get(field.attname), DeferredAttribute)
                 or field.column is None)):
            # This field will be populated on request.
            continue
        if kwargs:
            if isinstance(field.rel, ForeignObjectRel):
                try:
                    # Assume object instance was passed in.
                    rel_obj = kwargs.pop(field.name)
                    is_related_object = True
                except KeyError:
                    try:
                        # Object instance wasn't passed in -- must be an ID.
                        val = kwargs.pop(field.attname)
                    except KeyError:
                        val = field.get_default()
                else:
                    # Object instance was passed in. Special case: You can
                    # pass in "None" for related objects if it's allowed.
                    if rel_obj is None and field.null:
                        val = None
            else:
                try:
                    val = kwargs.pop(field.attname)
                except KeyError:
                    # This is done with an exception rather than the
                    # default argument on pop because we don't want
                    # get_default() to be evaluated, and then not used.
                    # Refs #12057.
                    val = field.get_default()
        else:
            val = field.get_default()
        if is_related_object:
            # If we are passed a related instance, set it using the
            # field.name instead of field.attname (e.g. "user" instead of
            # "user_id") so that the object gets properly cached (and type
            # checked) by the RelatedObjectDescriptor.
            setattr(self, field.name, rel_obj)
        else:
            setattr(self, field.attname, val)
    if kwargs:
        for prop in list(kwargs):
            try:
                if isinstance(getattr(self.__class__, prop), property):
                    setattr(self, prop, kwargs.pop(prop))
            except AttributeError:
                pass
        if kwargs:
            raise TypeError("'%s' is an invalid keyword argument for this function" % list(kwargs)[0])
    super(Model, self).__init__()
    signals.post_init.send(sender=self.__class__, instance=self)

def clean(

self)

Hook for doing any extra model-wide validation after clean() has been called on every field by self.clean_fields. Any ValidationError raised by this method will not be associated with a particular field; it will have a special-case association with the field defined by NON_FIELD_ERRORS.

def clean(self):
    """
    Hook for doing any extra model-wide validation after clean() has been
    called on every field by self.clean_fields. Any ValidationError raised
    by this method will not be associated with a particular field; it will
    have a special-case association with the field defined by NON_FIELD_ERRORS.
    """
    pass

def clean_fields(

self, exclude=None)

Cleans all fields and raises a ValidationError containing message_dict of all validation errors if any occur.

def clean_fields(self, exclude=None):
    """
    Cleans all fields and raises a ValidationError containing message_dict
    of all validation errors if any occur.
    """
    if exclude is None:
        exclude = []
    errors = {}
    for f in self._meta.fields:
        if f.name in exclude:
            continue
        # Skip validation for empty fields with blank=True. The developer
        # is responsible for making sure they have a valid value.
        raw_value = getattr(self, f.attname)
        if f.blank and raw_value in f.empty_values:
            continue
        try:
            setattr(self, f.attname, f.clean(raw_value, self))
        except ValidationError as e:
            errors[f.name] = e.error_list
    if errors:
        raise ValidationError(errors)

def date_error_message(

self, lookup_type, field, unique_for)

def date_error_message(self, lookup_type, field, unique_for):
    opts = self._meta
    return _("%(field_name)s must be unique for %(date_field)s %(lookup)s.") % {
        'field_name': six.text_type(capfirst(opts.get_field(field).verbose_name)),
        'date_field': six.text_type(capfirst(opts.get_field(unique_for).verbose_name)),
        'lookup': lookup_type,
    }

def delete(

self)

def delete(self):
    if not self.pk:
        raise Exception("Can't delete without a primary key")
    self.__class__.objects.filter(pk=self.pk).delete()

def field_label(

cls, field_name=None)

@classmethod
def field_label(cls, field_name=None):
    if field_name:
        try:
            return cls._meta.get_field(field_name).verbose_name
        except FieldDoesNotExist:
            try:
                return getattr(cls, field_name).verbose_name
            except AttributeError:
                return field_name
    else:
        return cls._meta.verbose_name

def full_clean(

self, exclude=None, validate_unique=True)

Calls clean_fields, clean, and validate_unique, on the model, and raises a ValidationError for any errors that occurred.

def full_clean(self, exclude=None, validate_unique=True):
    """
    Calls clean_fields, clean, and validate_unique, on the model,
    and raises a ``ValidationError`` for any errors that occurred.
    """
    errors = {}
    if exclude is None:
        exclude = []
    try:
        self.clean_fields(exclude=exclude)
    except ValidationError as e:
        errors = e.update_error_dict(errors)
    # Form.clean() is run even if other validation fails, so do the
    # same with Model.clean() for consistency.
    try:
        self.clean()
    except ValidationError as e:
        errors = e.update_error_dict(errors)
    # Run unique checks, but only for fields that passed validation.
    if validate_unique:
        for name in errors.keys():
            if name != NON_FIELD_ERRORS and name not in exclude:
                exclude.append(name)
        try:
            self.validate_unique(exclude=exclude)
        except ValidationError as e:
            errors = e.update_error_dict(errors)
    if errors:
        raise ValidationError(errors)

def get_dirty_fields(

self, check_relationship=False, check_m2m=None, verbose=False)

def get_dirty_fields(self, check_relationship=False, check_m2m=None, verbose=False):
    if self._state.adding:
        # If the object has not yet been saved in the database, all fields are considered dirty
        # for consistency (see https://github.com/romgar/django-dirtyfields/issues/65 for more details)
        pk_specified = self.pk is not None
        initial_dict = self._as_dict(check_relationship, include_primary_key=pk_specified)
        return initial_dict
    if check_m2m is not None and not self.ENABLE_M2M_CHECK:
        raise ValueError("You can't check m2m fields if ENABLE_M2M_CHECK is set to False")
    modified_fields = compare_states(self._as_dict(check_relationship),
                                     self._original_state,
                                     self.compare_function)
    if check_m2m:
        modified_m2m_fields = compare_states(check_m2m,
                                             self._original_m2m_state,
                                             self.compare_function)
        modified_fields.update(modified_m2m_fields)
    if not verbose:
        # Keeps backward compatibility with previous function return
        modified_fields = {key: value['saved'] for key, value in modified_fields.items()}
    return modified_fields

def get_dom_name(

cls)

Convert the class name to a DOM element name

@classmethod
def get_dom_name(cls):
    "Convert the class name to a DOM element name"
    clsname = cls.__name__
    return clsname[0].lower() + clsname[1:]

def get_revision(

self)

def get_revision(self):
    revisions = Revision.objects.filter(element_type=self.element_type, element_id=self.id).order_by('-time')
    if revisions:
        return revisions[0]
    else:
        return None

def is_dirty(

self, check_relationship=False, check_m2m=None)

def is_dirty(self, check_relationship=False, check_m2m=None):
    return {} != self.get_dirty_fields(check_relationship=check_relationship,
                                       check_m2m=check_m2m)

def is_image(

self)

def is_image(self):
    is_url_image = False
    if self.url:
        url_types = ['.png', '.jpg', '.gif', '.jpeg']
        for type in url_types:
            if type in self.url or type.upper() in self.url:
                is_url_image = True
    return 'image' in self.mime_type or is_url_image

def is_kdenlive_session(

self)

def is_kdenlive_session(self):
    if self.file:
        return '.kdenlive' in self.file.path
    else:
        return False

def prepare_database_save(

self, unused)

def prepare_database_save(self, unused):
    if self.pk is None:
        raise ValueError("Unsaved model instance %r cannot be used in an ORM query." % self)
    return self.pk

def public_access_label(

self)

def public_access_label(self):
    if self.public_access == 'metadata':
        return _('Metadata only')
    elif self.public_access == 'full':
        return _('Sound and metadata')
    return _('Private data')

def required_fields(

cls)

@classmethod
def required_fields(cls):
    required = []
    for field in cls._meta.fields:
        if not field.blank:
            required.append(field)
    return required

def save(

self, *args, **kwargs)

def save(self, *args, **kwargs):
    super(MediaRelated, self).save(*args, **kwargs)

def save_base(

self, raw=False, force_insert=False, force_update=False, using=None, update_fields=None)

Handles the parts of saving which should be done only once per save, yet need to be done in raw saves, too. This includes some sanity checks and signal sending.

The 'raw' argument is telling save_base not to save any parent models and not to do any changes to the values before save. This is used by fixture loading.

def save_base(self, raw=False, force_insert=False,
              force_update=False, using=None, update_fields=None):
    """
    Handles the parts of saving which should be done only once per save,
    yet need to be done in raw saves, too. This includes some sanity
    checks and signal sending.
    The 'raw' argument is telling save_base not to save any parent
    models and not to do any changes to the values before save. This
    is used by fixture loading.
    """
    using = using or router.db_for_write(self.__class__, instance=self)
    assert not (force_insert and (force_update or update_fields))
    assert update_fields is None or len(update_fields) > 0
    cls = origin = self.__class__
    # Skip proxies, but keep the origin as the proxy model.
    if cls._meta.proxy:
        cls = cls._meta.concrete_model
    meta = cls._meta
    if not meta.auto_created:
        signals.pre_save.send(sender=origin, instance=self, raw=raw, using=using,
                              update_fields=update_fields)
    with transaction.commit_on_success_unless_managed(using=using, savepoint=False):
        if not raw:
            self._save_parents(cls, using, update_fields)
        updated = self._save_table(raw, cls, force_insert, force_update, using, update_fields)
    # Store the database on which the object was saved
    self._state.db = using
    # Once saved, this is no longer a to-be-added instance.
    self._state.adding = False
    # Signal that the save is complete
    if not meta.auto_created:
        signals.post_save.send(sender=origin, instance=self, created=(not updated),
                               update_fields=update_fields, raw=raw, using=using)

def save_dirty_fields(

self)

def save_dirty_fields(self):
    dirty_fields = self.get_dirty_fields(check_relationship=True)
    save_specific_fields(self, dirty_fields)

def serializable_value(

self, field_name)

Returns the value of the field name for this instance. If the field is a foreign key, returns the id value, instead of the object. If there's no Field object with this name on the model, the model attribute's value is returned directly.

Used to serialize a field's value (in the serializer, or form output, for example). Normally, you would just access the attribute directly and not use this method.

def serializable_value(self, field_name):
    """
    Returns the value of the field name for this instance. If the field is
    a foreign key, returns the id value, instead of the object. If there's
    no Field object with this name on the model, the model attribute's
    value is returned directly.
    Used to serialize a field's value (in the serializer, or form output,
    for example). Normally, you would just access the attribute directly
    and not use this method.
    """
    try:
        field = self._meta.get_field_by_name(field_name)[0]
    except FieldDoesNotExist:
        return getattr(self, field_name)
    return getattr(self, field.attname)

def set_mime_type(

self)

def set_mime_type(self):
    if self.file:
        self.mime_type = mimetypes.guess_type(self.file.path)[0]

def set_revision(

self, user)

Save a media object and add a revision

def set_revision(self, user):
    "Save a media object and add a revision"
    Revision.touch(self, user)

def to_dict(

self)

Return model fields as a dict of name/value pairs

def to_dict(self):
    "Return model fields as a dict of name/value pairs"
    fields_dict = {}
    for field in self._meta.fields:
        fields_dict[field.name] = getattr(self, field.name)
    return fields_dict

def to_dom(

self)

Return the DOM representation of this media object

def to_dom(self):
    "Return the DOM representation of this media object"
    impl = getDOMImplementation()
    root = self.get_dom_name()
    doc = impl.createDocument(None, root, None)
    top = doc.documentElement
    top.setAttribute("id", str(self.pk))
    fields = self.to_dict()
    for name, value in fields.iteritems():
        element = doc.createElement(self.get_dom_field_name(name))
        if isinstance(value, EnhancedModel):
            element.setAttribute('key', str(value.pk))
        value = unicode(value)
        element.appendChild(doc.createTextNode(value))
        top.appendChild(element)
    return doc

def to_list(

self)

Return model fields as a list

def to_list(self):
    "Return model fields as a list"
    fields_list = []
    for field in self._meta.fields:
        fields_list.append({'name': field.name, 'value': unicode(getattr(self, field.name))})
    return fields_list

def unique_error_message(

self, model_class, unique_check)

def unique_error_message(self, model_class, unique_check):
    opts = model_class._meta
    model_name = capfirst(opts.verbose_name)
    # A unique field
    if len(unique_check) == 1:
        field_name = unique_check[0]
        field = opts.get_field(field_name)
        field_label = capfirst(field.verbose_name)
        # Insert the error into the error dict, very sneaky
        return field.error_messages['unique'] % {
            'model_name': six.text_type(model_name),
            'field_label': six.text_type(field_label)
        }
    # unique_together
    else:
        field_labels = [capfirst(opts.get_field(f).verbose_name) for f in unique_check]
        field_labels = get_text_list(field_labels, _('and'))
        return _("%(model_name)s with this %(field_label)s already exists.") % {
            'model_name': six.text_type(model_name),
            'field_label': six.text_type(field_labels)
        }

def validate_unique(

self, exclude=None)

Checks unique constraints on the model and raises ValidationError if any failed.

def validate_unique(self, exclude=None):
    """
    Checks unique constraints on the model and raises ``ValidationError``
    if any failed.
    """
    unique_checks, date_checks = self._get_unique_checks(exclude=exclude)
    errors = self._perform_unique_checks(unique_checks)
    date_errors = self._perform_date_checks(date_checks)
    for k, v in date_errors.items():
        errors.setdefault(k, []).extend(v)
    if errors:
        raise ValidationError(errors)