movies/models.py
from django.db import models

# Create your models here.
class Person(models.Model):
    name = models.CharField(max_length=200)

    def __unicode__(self):
        return '%s' % self.name

class Genre(models.Model):
    name = models.CharField(max_length=200)

class Movie(models.Model):
    title = models.CharField(max_length=200)
    year = models.DateField()
    genre = models.ManyToManyField(Genre,related_name='genre')
    poster = models.ImageField(upload_to='/tmp')
    imdb_url = models.URLField(blank=True)
    language = models.CharField(max_length=15)
    director = models.ManyToManyField(Person,related_name='directed')
    actor = models.ManyToManyField(Person,related_name='acted_in')
    writer = models.ManyToManyField(Person,related_name='wrote')

    def __unicode__(self):
        return '%s (%s)' % (self.title, self.year)

class Cut(models.Model):
    name = models.CharField(max_length=200)
    movie = models.ForeignKey(Movie)
    runtime = models.IntegerField()

    def __unicode__(self):
        return '%s' % self.name

class Edition(models.Model):
    name = models.CharField(max_length=200)
    cut = models.ForeignKey(Cut)

    def __unicode__(self):
        return '%s' % self.name

release/models.py
from django.db import models
from movie.models import Edition

# Create your models here.
class Hash(models.Model):
    size = models.IntegerField()
    filename = models.CharField(max_length=255)
    md5 = models.CharField(max_length=50)
    sha1 = models.CharField(max_length=50)
    sha256 = models.CharField(max_length=50)
    ed2k = models.CharField(max_length=50)

    def __unicode__(self):
        return self.id

class Release(models.Model):
    ripper = models.CharField(max_length=100)
    edition = models.ForeignKey(Edition)

    def __unicode__(self):
        return '%s %s - %s [%s]' % (self.ripper,
                                    self.edition.movie,
                                    self.edition.cut,
                                    self.edition)

class SceneTag(models.Model):
    release = models.ForeignKey(Release)
    tag = models.CharField(max_length=15)

class Video(models.Model):
    """
    A video is a video file within a 'Release', there can be many 'Video's
    within a 'Release' but there can not be the same 'Video' in multiple
    'Release's.  Retagging, reposting, etc. is not releasing you swine!
    """
    hash = models.ForeignKey(Hash)
    release = models.ForeignKey(Release)
    codec = models.CharField(max_length=10)
    container = models.CharField(max_length=10)
    bitrate = models.IntegerField()
    width = models.IntegerField()
    height = models.IntegerField()
    frames = models.IntegerField()
    frames_per_second = models.DecimalField(max_digits=3,decimal_places=3)
    aspect_ratio = models.DecimalField(max_digits=3,decimal_places=3)

    def get_runtime_seconds(self):
        """
        Calculate the runtime in seconds, as this is often important for
        horror fans.  Every second of boob... err violence... art even counts
        """
        return self.frames * self.frames_per_second

    def get_runtime(self):
        """
        Calculate the runtime in minutes, as this is the most common way of
        using runtime except for us horror nerds
        """
        return self.get_runtime_seconds() / 60

    def runtime_hours(self):
        """
        Calculate the runtime in hours
        """
        return ( self.get_runtime() ) / 60

    def is_cut_by(self):
        """
        Takes the runtime of the 'Edition' and takes the runtime of this
        'Video' to calculate the number of seconds they differ
        """
        return ( self.release.edition.runtime - self.get_runtime_seconds() )

    def is_cut(self):
        """
        Using the number of seconds difference, if there is a positive number
        difference this mean the rip is censored or has been 'chopped'.
        Generally we should expect a negative number here but we need a large
        dataset to find out how accurate using seconds is.
        """
        return (self.is_cut_by() >= 0)

    def __unicode__(self):
        return '%s %s %s' % (self.release, self.container, self.codec)

class Audio(models.Model):
    """
    This is an audio track that is associated with a 'Video'
    """
    video = models.ForeignKey(Video)
    language = models.CharField(max_length=20)
    codec = models.CharField(max_length=10)
    bitrate = models.IntegerField()

    def __unicode__(self):
        return '%s %s %s' % (self.video.release, self.language, self.codec)

class Subtitle(models.Model):
    """
    This is the subtitle track that is associated with a 'Video'.
    """
    video = models.ForeignKey(Video)
    language = models.CharField(max_length=20)

    def is_external(self):
        """
        Is the subtitle external to the container?
        """
        return False

    def __unicode__(self):
        return '%s (%s)' % (self.video.release, self.language)

class ExternalSubtitle(Subtitle):
    """
    This is the subtitle track that is associated with a 'Video'.
    In this case we have an external subtitle
    """
    hash = models.ForeignKey(Hash)
    extension = models.CharField(max_length=10)

    def is_external(self):
        """
        Is the subtitle external to the container?
        """
        return True

    def __unicode__(self):
        return '%s (%s) [%s]' % (self.video.release, self.language, self.extension)