def _calc_sorted_language_choices():
qs = (Video.objects.order_by().values_list('primary_audio_language_code').
annotate(count=Count('primary_audio_language_code')))
language_counts = dict(qs)
choices = get_language_choices(flat=True)
choices.sort(key=lambda c: language_counts.get(c[0], 0), reverse=True)
return [('', _('All Languages'))] + choices
def __init__(self, *args, **kwargs):
if 'sqs' in kwargs:
sqs = kwargs['sqs']
del kwargs['sqs']
else:
sqs = None
super(SearchForm, self).__init__(*args, **kwargs)
if sqs:
facet_data = sqs.facet('video_language').facet(
'languages').facet_counts()
try:
video_langs_data = facet_data['fields']['video_language']
except KeyError:
video_langs_data = {}
self.fields[
'video_lang'].choices = self._make_choices_from_faceting(
video_langs_data)
langs_data = facet_data['fields']['languages']
self.fields['langs'].choices = self._make_choices_from_faceting(
langs_data)
else:
choices = list(get_language_choices())
choices.insert(0, ('', _('All Languages')))
self.fields['langs'].choices = choices
self.fields['video_lang'].choices = choices
def __init__(self, user, video, allow_transcription=True, *args, **kwargs):
self.video = video
self.user = user
self._sl_created = False
super(SubtitlesUploadForm, self).__init__(*args, **kwargs)
# This has to be set here. get_language_choices looks at the language
# of the current thread via the magical get_language() Django function,
# so if you just set it once at the beginning of the file it's not going
# to properly change for the user's UI language.
all_languages = get_language_choices(with_empty=True)
self.fields['language_code'].choices = all_languages
self.fields['primary_audio_language_code'].choices = all_languages
language_qs = (SubtitleLanguage.objects.having_public_versions()
.filter(video=video))
choices = [
(sl.language_code, sl.get_language_code_display())
for sl in language_qs
]
if allow_transcription:
choices.append(('', 'None (Direct from Video)'))
self.fields['from_language_code'].choices = choices
def language_choices_ordered(*langs_on_top):
choice_map = dict(
(code, label) for (code, label) in get_language_choices())
rv = []
for code in langs_on_top:
rv.append((code, choice_map.pop(code)))
rv.extend(sorted(choice_map.items(), key=lambda choice: choice[1]))
return rv
def test_subtitle_language_filter(self):
# test that we don't allow languages that already have subtitles
pipeline.add_subtitles(self.video, 'en', None)
pipeline.add_subtitles(self.video, 'fr', None)
self.assertEquals(
set(self.make_form()['subtitle_language_code'].field.choices),
set((code, label) for (code, label) in get_language_choices()
if code not in ('en', 'fr')))
def set_options(self, options):
self.set_select_data('language-options', options)
choices = translation.get_language_choices(flat=True)
option_list = options.split()
if 'dont-set' in option_list:
choices.append(('null', _('Don\'t set')))
elif 'unset' in option_list:
choices.append(('null', _('Unset')))
self.choices = choices
def __init__(self, author, *args, **kwargs):
super(NewMessageForm, self).__init__(*args, **kwargs)
self.author = author
self.message_type = 'M'
self.fields['user'].queryset = User.objects.all()
# This isn't the fastest way to do this, but it's the simplest, and
# performance probably won't be an issue here.
self.fields['team'].queryset = author.messageable_teams()
self.fields['language'].choices = get_language_choices(with_any=True)
def __init__(self, team, get_data):
super(OldActivityFiltersForm,
self).__init__(data=self.calc_data(get_data))
self.team = team
self.fields['type'].choices = self.calc_activity_choices()
language_choices = [
('', ('Any language')),
]
language_choices.extend(get_language_choices(flat=True))
self.fields['video_language'].choices = language_choices
self.fields['subtitle_language'].choices = language_choices
def test_subtitle_language_filter_top_section(self):
# We should use the user's languages as our top section (if set)
self.user.set_languages([
dict(language='en', priority=0),
dict(language='fr', priority=1),
])
self.check_language_choices(
get_language_choices(top_section=(('Your Languages', [
(u'en', 'English'),
(u'fr', 'French'),
]))))
def language_select(request):
url = request.META.get('HTTP_REFERER').split('/')
template_name = 'future/language_switcher.html'
response_renderer = AJAXResponseRenderer(request)
context = {}
context['languages'] = []
valid_options = [code for code, label in settings.LANGUAGES]
for code, name in get_language_choices(flat=True, limit_to=valid_options):
url[3] = code
context['languages'] += [('/'.join(url), code, name)]
response_renderer.show_modal(template_name, context)
return response_renderer.render()
def get_language_choices(self):
# remove languages that already have subtitles
current_langs = set(self.video.languages_with_versions())
if self.user.is_authenticated():
user_language_choices = self.user.get_language_codes_and_names()
else:
user_language_choices = []
if user_language_choices:
top_section = (_('Your Languages'), user_language_choices)
else:
top_section = None
return get_language_choices(top_section=top_section,
exclude=current_langs)
def __init__(self, *args, **kwargs):
options = kwargs.pop('options', "null my popular all")
null_label = kwargs.pop('null_label', None)
placeholder = kwargs.pop('placeholder', False)
allow_clear = kwargs.pop('allow_clear', False)
kwargs['choices'] = translation.get_language_choices()
super(LanguageFieldMixin, self).__init__(*args, **kwargs)
if options:
self.options = options
if null_label:
self.null_label = null_label
if placeholder:
self.placeholder = placeholder
if allow_clear:
self.allow_clear = allow_clear
def setup_subtitle_language_code(self):
if self.user.is_authenticated():
user_langs = [l.language for l in self.user.get_languages()]
else:
user_langs = get_user_languages_from_request(self.request)
if not user_langs:
user_langs = ['en']
def sort_key(choice):
code, label = choice
if code in user_langs:
return user_langs.index(code)
else:
return len(user_langs)
field = self.fields['subtitle_language_code']
field.choices = sorted(get_language_choices(), key=sort_key)
def _make_choices_from_faceting(self, data):
choices = []
ALL_LANGUAGES_NAMES = dict(get_language_choices())
for lang, val in data:
try:
choices.append((lang, u'%s (%s)' % (ALL_LANGUAGES_NAMES[lang], val), val))
except KeyError:
pass
choices.sort(key=lambda item: item[-1], reverse=True)
choices = list((item[0], item[1]) for item in choices)
choices.insert(0, ('', _('All Languages')))
return choices
def __init__(self, user, team, team_video, *args, **kwargs):
self.non_display_form = False
if kwargs.get('non_display_form'):
self.non_display_form = kwargs.pop('non_display_form')
super(TaskCreateForm, self).__init__(*args, **kwargs)
self.user = user
self.team_video = team_video
# TODO: This is bad for teams with 10k members.
team_user_ids = team.members.values_list('user', flat=True)
langs = [l for l in get_language_choices(with_empty=True)
if l[0] in team.get_writable_langs()]
self.fields['language'].choices = langs
self.fields['assignee'].queryset = User.objects.filter(pk__in=team_user_ids)
if self.non_display_form:
self.fields['type'].choices = Task.TYPE_CHOICES
def __init__(self, user, video, allow_transcription=True, *args, **kwargs):
allow_all_languages = kwargs.pop('allow_all_languages', False)
self.video = video
self.user = user
self._sl_created = False
super(SubtitlesUploadForm, self).__init__(*args, **kwargs)
if allow_all_languages:
all_languages = ALL_LANGUAGE_CHOICES
else:
all_languages = get_language_choices(with_empty=True)
self.fields['language_code'].choices = all_languages
self.fields['primary_audio_language_code'].choices = all_languages
choices = [(language_code, get_language_label(language_code))
for language_code in video.languages_with_versions()]
if allow_transcription:
choices.append(('', 'None (Direct from Video)'))
self.fields['from_language_code'].choices = choices
def __init__(self, team, user, *args, **kwargs):
self.team = team
self.user = user
super(AddTeamVideoForm, self).__init__(*args, **kwargs)
projects = self.team.project_set.all()
if len(projects) > 1:
projects = projects.exclude(slug='_root')
self.fields['project'].queryset = projects
ordered_projects = ([p for p in projects if p.is_default_project] +
[p for p in projects if not p.is_default_project])
ordered_projects = [p for p in ordered_projects if can_add_video(team, user, p)]
self.fields['project'].choices = [(p.pk, p) for p in ordered_projects]
writable_langs = team.get_writable_langs()
self.fields['language'].choices = [c for c in get_language_choices(True)
if c[0] in writable_langs]
def __init__(self, *args, **kwrags):
super(SelectLanguageForm, self).__init__(*args, **kwrags)
lc = get_language_choices(True)
for i in xrange(1, 10):
self.fields['language%s' % i].choices = lc
def __init__(self, *args, **kwrags):
super(UserLanguageForm, self).__init__(*args, **kwrags)
self.fields['language'].choices = get_language_choices(True)
def activity(request, team, tab):
try:
page = int(request.GET['page'])
except (ValueError, KeyError):
page = 1
activity_list = fetch_actions_for_activity_page(team, tab, page,
request.GET)
language_choices = None
if tab == 'videos':
readable_langs = TeamLanguagePreference.objects.get_readable(team)
language_choices = [(code, name)
for code, name in get_language_choices()
if code in readable_langs]
action_types = Action.TYPES_CATEGORIES[tab]
has_more = len(activity_list) >= ACTIONS_ON_PAGE
filtered = bool(
set(request.GET.keys()).intersection(
['action_type', 'language', 'sort']))
next_page_query = request.GET.copy()
next_page_query['page'] = page + 1
context = {
'activity_list':
activity_list,
'filtered':
filtered,
'action_types':
action_types,
'language_choices':
language_choices,
'team':
team,
'user':
request.user,
'next_page':
page + 1,
'next_page_query':
next_page_query.urlencode(),
'tab':
tab,
'has_more':
has_more,
'breadcrumbs': [
BreadCrumb(team, 'teams:dashboard', team.slug),
BreadCrumb(_('Activity')),
],
}
if team.is_old_style():
template_dir = 'teams/'
else:
template_dir = 'new-teams/'
if not request.is_ajax():
return render(request, template_dir + 'activity.html', context)
else:
# for ajax requests we only want to return the activity list, since
# that's all that the JS code needs.
return render(request, template_dir + '_activity-list.html', context)
def language_choices_with_empty():
choices = [('', _('--Select language--'))]
choices.extend(get_language_choices())
return choices
def __init__(self, team, *args, **kwargs):
super(LanguagesForm, self).__init__(*args, **kwargs)
self.team = team
self.fields['preferred'].choices = get_language_choices()
self.fields['blacklisted'].choices = get_language_choices()
from django.conf import settings
from django.contrib.sites.models import Site
from django.db.models import F
from django.utils.translation import ugettext_lazy as _
import requests
from utils import send_templated_email
from utils.panslugify import pan_slugify
from utils.translation import get_language_choices
from widget.video_cache import (invalidate_cache as invalidate_video_cache,
invalidate_video_moderation,
invalidate_video_visibility)
from utils.text import fmt
from videos.tasks import video_changed_tasks
LANGUAGE_CHOICES = [l[0] for l in get_language_choices(flat=True)]
@task()
def invalidate_video_caches(team_id):
"""Invalidate all TeamVideo caches for all the given team's videos."""
from teams.models import Team
team = Team.objects.get(pk=team_id)
for video_id in team.teamvideo_set.values_list('video__video_id',
flat=True):
invalidate_video_cache(video_id)
@task()
def invalidate_video_moderation_caches(team):
"""Invalidate the moderation status caches for all the given team's videos."""
def calc_language_choices(self):
return get_language_choices()
def test_subtitle_language_filter_top_section_no_languages_set(self):
self.user.set_languages([])
self.check_language_choices(get_language_choices())
def __init__(self, user, *args, **kwargs):
self.user = user
super(SubtitlesUploadBaseForm, self).__init__(*args, **kwargs)
self.fields['language'].choices = get_language_choices()
self.fields['video_language'].choices = get_language_choices()
# 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/agpl-3.0.html.
from django import forms
from django.utils.translation import ugettext_lazy as _
from utils.translation import get_language_choices
ALL_LANGUAGES = get_language_choices()
class SearchForm(forms.Form):
SORT_CHOICES = (
('score', _(u'Relevance')),
('languages_count', _(u'Most languages')),
('today_views', _(u'Views Today')),
('week_views', _(u'Views This Week')),
('month_views', _(u'Views This Month')),
('total_views', _(u'Total Views')),
)
q = forms.CharField(label=_(u'query'))
sort = forms.ChoiceField(choices=SORT_CHOICES,
required=False,
initial='score',
def __init__(self, *args, **kwargs):
self.with_any = kwargs.pop('with_any', None)
kwargs['choices'] = self.static_choices() + get_language_choices()
super(LanguageCodeField, self).__init__(*args, **kwargs)
def test_subtitle_language_filter_excludes_languages(self):
# test that we don't allow languages that already have subtitles
pipeline.add_subtitles(self.video, 'en', None)
pipeline.add_subtitles(self.video, 'fr', None)
self.check_language_choices(get_language_choices(exclude=['en', 'fr']))
def __init__(self, *args, **kwargs):
super(EditUserForm, self).__init__(*args, **kwargs)
self.fields['email'].required = True
self.fields['preferred_language'].choices = get_language_choices(True)
