def _get_percents(self):
     """Return percentages of translation status."""
     return (
         translation_percent(self.translated, self.total),
         translation_percent(self.fuzzy, self.total),
         translation_percent(self.failing_checks, self.total),
         translation_percent(self.translated_words, self.total_words),
     )

    def _get_percents(self):
        """Returns percentages of translation status."""
        # No units?
        if self.total == 0:
            return (100, 0, 0)

        return (
            translation_percent(self.translated, self.total),
            translation_percent(self.fuzzy, self.total),
            translation_percent(self.failing_checks, self.total),
        )

def get_project_stats(project):
    """Return stats for project"""
    return [
        {
            'language': force_text(tup[0]),
            'code': tup[0].code,
            'total': tup[2],
            'translated': tup[1],
            'translated_percent': translation_percent(tup[1], tup[2]),
            'total_words': tup[4],
            'translated_words': tup[3],
            'words_percent': translation_percent(tup[3], tup[4])
        }
        for tup in get_per_language_stats(project)
    ]

    def get_percents(self, project=None, subproject=None, language=None):
        """
        Returns tuple consting of status percents -
        (translated, fuzzy, failing checks)
        """
        # Filter translations
        translations = self
        if project is not None:
            translations = translations.filter(subproject__project=project)
        if subproject is not None:
            translations = translations.filter(subproject=subproject)
        if language is not None:
            translations = translations.filter(language=language)

        # Aggregate
        translations = translations.aggregate(Sum("translated"), Sum("fuzzy"), Sum("failing_checks"), Sum("total"))

        total = translations["total__sum"]

        # Catch no translations (division by zero)
        if total == 0 or total is None:
            return (0, 0, 0)

        # Fetch values
        result = [translations["translated__sum"], translations["fuzzy__sum"], translations["failing_checks__sum"]]
        # Calculate percent
        return tuple([translation_percent(value, total) for value in result])

    def get_percents(self, project=None, subproject=None, language=None):
        """Return tuple consting of status percents:

        (translated, fuzzy, failing checks)
        """
        # Filter translations
        translations = self
        if project is not None:
            translations = translations.filter(subproject__project=project)
        if subproject is not None:
            translations = translations.filter(subproject=subproject)
        if language is not None:
            translations = translations.filter(language=language)

        # Aggregate
        translations = translations.aggregate(
            Sum('translated'),
            Sum('fuzzy'),
            Sum('failing_checks'),
            Sum('total'),
            Sum('translated_words'),
            Sum('total_words'),
        )

        total = translations['total__sum']
        words = translations['total_words__sum']
        translated_words = translations['translated_words__sum']

        # Fetch values
        result = [
            translations['translated__sum'],
            translations['fuzzy__sum'],
            translations['failing_checks__sum'],
        ]
        # Calculate percent
        return tuple(
            [translation_percent(value, total) for value in result] +
            [translation_percent(translated_words, words)]
        )

 def calculate_percents(self, item):
     """Calculate percent value for given item."""
     base = item[:-8]
     if base.endswith('_words'):
         total = self.all_words
     else:
         total = self.all
     if self.has_review:
         completed = {'approved', 'approved_words'}
     else:
         completed = {'translated', 'translated_words'}
     self.store(
         item,
         translation_percent(getattr(self, base), total, base in completed)
     )

    def get_percents(self, project=None, subproject=None, language=None):
        '''
        Returns tuple consting of status percents -
        (translated, fuzzy, failing checks)
        '''
        # Filter translations
        translations = self
        if project is not None:
            translations = translations.filter(subproject__project=project)
        if subproject is not None:
            translations = translations.filter(subproject=subproject)
        if language is not None:
            translations = translations.filter(language=language)

        # Aggregate
        translations = translations.aggregate(
            Sum('translated'),
            Sum('fuzzy'),
            Sum('failing_checks'),
            Sum('total'),
        )

        total = translations['total__sum']

        # Catch no translations (division by zero)
        if total == 0 or total is None:
            return (100, 0, 0)

        # Fetch values
        result = [
            translations['translated__sum'],
            translations['fuzzy__sum'],
            translations['failing_checks__sum'],
        ]
        # Calculate percent
        return tuple([translation_percent(value, total) for value in result])

 def get_fuzzy_words_percent(self):
     if self.total_words == 0:
         return 0
     return translation_percent(self.fuzzy_words, self.total_words)

 def test_almost_translated_file(self):
     self.assertAlmostEqual(translation_percent(99999999, 100000000), 99.9)

 def test_translated_file(self):
     self.assertAlmostEqual(translation_percent(100, 100), 100.0)

 def test_almost_untranslated_file(self):
     self.assertAlmostEqual(translation_percent(1, 10000000000), 0.1)

 def test_none(self):
     self.assertAlmostEqual(translation_percent(0, None), 0.0)

 def test_empty(self):
     self.assertAlmostEqual(translation_percent(0, 0), 100.0)

 def get_failing_checks_words_percent(self):
     if self.total_words == 0:
         return 0
     return translation_percent(self.failing_checks_words, self.total_words)

 def test_common(self):
     self.assertAlmostEqual(translation_percent(2, 4), 50.0)

def show_project(request, project):
    obj = get_project(request, project)

    dict_langs = Language.objects.filter(
        dictionary__project=obj
    ).annotate(Count('dictionary'))

    if request.method == 'POST' and can_edit_project(request.user, obj):
        settings_form = ProjectSettingsForm(request.POST, instance=obj)
        if settings_form.is_valid():
            settings_form.save()
            messages.success(request, _('Settings saved'))
            return redirect(obj)
        else:
            messages.error(
                request,
                _('Invalid settings, please check the form for errors!')
            )
    else:
        settings_form = ProjectSettingsForm(instance=obj)

    last_changes = Change.objects.for_project(obj)[:10]

    language_stats = sort_unicode(
        get_per_language_stats(obj), lambda tup: force_text(tup[0])
    )

    language_stats = [
        (
            tup[0],
            translation_percent(tup[1], tup[2]),
            translation_percent(tup[3], tup[4])
        )
        for tup in language_stats
    ]

    if can_translate(request.user, project=obj):
        replace_form = ReplaceForm()
    else:
        replace_form = None

    return render(
        request,
        'project.html',
        {
            'allow_index': True,
            'object': obj,
            'project': obj,
            'dicts': dict_langs,
            'last_changes': last_changes,
            'last_changes_url': urlencode(
                {'project': obj.slug}
            ),
            'settings_form': settings_form,
            'language_stats': language_stats,
            'unit_count': Unit.objects.filter(
                translation__subproject__project=obj
            ).count(),
            'words_count': obj.get_total_words(),
            'language_count': Language.objects.filter(
                translation__subproject__project=obj
            ).distinct().count(),
            'strings_count': obj.get_total(),
            'source_words_count': obj.get_source_words(),
            'search_form': SearchForm(),
            'replace_form': replace_form,
        }
    )