def handle(self, *args, **options):
# Check that we can run
if not settings.CENTRAL_SERVER:
raise CommandError("This must only be run on the central server.")
supported_langs = get_supported_languages()
if not options["lang_codes"]:
lang_codes = supported_langs
else:
requested_codes = set(options["lang_codes"].split(","))
lang_codes = [lcode_to_ietf(lc) for lc in requested_codes if lc in supported_langs]
unsupported_codes = requested_codes - set(lang_codes)
if unsupported_codes:
raise CommandError("Requested unsupported languages: %s" % sorted(list(unsupported_codes)))
# Scrub options
for key in options:
# If no_update is set, then disable all update options.
if key.startswith("update_"):
options[key] = options[key] and not options["no_update"]
if version_diff(options["version"], "0.10.3") < 0:
raise CommandError("This command cannot be used for versions before 0.10.3")
if options['low_mem']:
logging.info('Making the GC more aggressive...')
gc.set_threshold(36, 2, 2)
# For dealing with central server changes across versions
upgrade_old_schema()
# Now, we're going to build the language packs, collecting metadata long the way.
package_metadata = update_language_packs(lang_codes, options)
def generate_test_files():
"""Insert asterisks as translations in po files"""
# Open them up and insert asterisks for all empty msgstrs
logging.info("Generating test po files")
en_po_dir = os.path.join(settings.LOCALE_PATHS[0], "en/LC_MESSAGES/")
for po_file in glob.glob(os.path.join(en_po_dir, "*.po")):
msgid_pattern = re.compile(r'msgid \"(.*)\"\nmsgstr', re.S | re.M)
content = open(os.path.join(en_po_dir, po_file), 'r').read()
results = content.split("\n\n")
with open(os.path.join(en_po_dir, "tmp.po"), 'w') as temp_file:
# We know the first block is static, so just dump that.
temp_file.write(results[0])
# Now work through actual translations
for result in results[1:]:
try:
msgid = re.findall(msgid_pattern, result)[0]
temp_file.write("\n\n")
temp_file.write(result.replace("msgstr \"\"", "msgstr \"***%s***\"" % msgid))
except Exception as e:
logging.error("Failed to insert test string: %s\n\n%s\n\n" % (e, result))
# Once done replacing, rename temp file to overwrite original
os.rename(os.path.join(en_po_dir, "tmp.po"), os.path.join(en_po_dir, po_file))
(out, err, rc) = compile_po_files("en")
if err:
logging.debug("Error executing compilemessages: %s" % err)
def update_metadata(package_metadata, version=VERSION):
"""
We've zipped the packages, and now have unzipped & zipped sizes.
Update this info in the local metadata (but not inside the zip)
"""
master_filepath = get_language_pack_availability_filepath(version=version)
master_metadata = softload_json(master_filepath, logger=logging.warn, errmsg="Error opening master language pack metadata")
for lc, updated_meta in package_metadata.iteritems():
lang_code_ietf = lcode_to_ietf(lc)
# Gather existing metadata
metadata_filepath = get_language_pack_metadata_filepath(lang_code_ietf, version=version)
stored_meta = softload_json(metadata_filepath, logger=logging.warn, errmsg="Error opening %s language pack metadata" % lc)
stored_meta.update(updated_meta)
# Write locally (this is used on download by distributed server to update it's database)
with open(metadata_filepath, 'w') as output:
json.dump(stored_meta, output)
# Update master (this is used for central server to handle API requests for data)
master_metadata[lang_code_ietf] = stored_meta
# Save updated master
ensure_dir(os.path.dirname(master_filepath))
with open(master_filepath, 'w') as output:
json.dump(master_metadata, output)
logging.info("Local record of translations updated")
def handle(self, *args, **options):
if len(args)==1 and args[0]== "test":
# Callback for "weak" test--checks at least that the django project compiles (local_settings is OK)
sys.stdout.write("Success!\n")
exit(0)
try:
if options.get("branch", None):
# Specified a repo
self.update_via_git(**options)
elif options.get("zip_file", None):
# Specified a file
if not os.path.exists(options.get("zip_file")):
raise CommandError("Specified zip file does not exist: %s" % options.get("zip_file"))
self.update_via_zip(**options)
elif options.get("url", None):
self.update_via_zip(**options)
elif os.path.exists(settings.PROJECT_PATH + "/../.git"):
# If we detect a git repo, try git
if len(args) == 1 and not options["branch"]:
options["branch"] = args[0]
elif len(args) != 0:
raise CommandError("Specified too many command-line arguments")
self.update_via_git(**options)
elif len(args) > 1:
raise CommandError("Too many command-line arguments.")
elif len(args) == 1:
# Specify zip via first command-line arg
if options['zip_file'] is not None:
raise CommandError("Cannot specify a zipfile as unnamed and named command-line arguments at the same time.")
options['zip_file'] = args[0]
self.update_via_zip(**options)
else:
# No params, no git repo: try to get a file online.
zip_file = tempfile.mkstemp()[1]
for url in ["http://%s/api/download/kalite/latest/%s/%s/" % (settings.CENTRAL_SERVER_HOST, platform.system().lower(), "en")]:
logging.info("Downloading repo snapshot from %s to %s" % (url, zip_file))
try:
urllib.urlretrieve(url, zip_file)
sys.stdout.write("success @ %s\n" % url)
break;
except Exception as e:
logging.debug("Failed to get zipfile from %s: %s" % (url, e))
continue
options["zip_file"] = zip_file
self.update_via_zip(**options)
except Exception as e:
if self.started() and not not self.ended():
self.cancel(stage_status="error", notes=unicode(e))
raise
assert self.ended(), "Subroutines should complete() if they start()!"
def generate_fake_coachreport_logs(password="******"):
t,_ = FacilityUser.objects.get_or_create(
facility=Facility.objects.all()[0],
username=random.choice(firstnames)
)
t.set_password(password)
# TODO: create flags later
num_logs = 20
logs = []
for _ in xrange(num_logs):
date_logged_in = datetime.datetime.now() - datetime.timedelta(days=random.randint(1,10))
date_viewed_coachreport = date_logged_in + datetime.timedelta(minutes=random.randint(0, 30))
date_logged_out = date_viewed_coachreport + datetime.timedelta(minutes=random.randint(0, 30))
login_log = UserLog.objects.create(
user=t,
activity_type=UserLog.get_activity_int("login"),
start_datetime=date_logged_in,
last_active_datetime=date_viewed_coachreport,
end_datetime=date_logged_out,
)
logging.info("created login log for teacher %s" % t.username)
coachreport_log = UserLog.objects.create(
user=t,
activity_type=UserLog.get_activity_int("coachreport"),
start_datetime=date_viewed_coachreport,
last_active_datetime=date_viewed_coachreport,
end_datetime=date_viewed_coachreport,
)
logs.append((login_log, coachreport_log))
logging.info("created coachreport log for teacher %s" % t.username)
return logs
def handle(self, *args, **options):
# Get the CSV data, either from a recent cache_file
# or from the internet
cache_dir = settings.MEDIA_ROOT
cache_file = os.path.join(cache_dir, "dubbed_videos.csv")
if not options["force"] and os.path.exists(cache_file) and datediff(datetime.datetime.now(), datetime.datetime.fromtimestamp(os.path.getctime(cache_file)), units="days") <= 14.0:
# Use cached data to generate the video map
csv_data = open(cache_file, "r").read()
(video_map, _) = generate_dubbed_video_mappings(csv_data=csv_data)
else:
# Use cached data to generate the video map
(video_map, csv_data) = generate_dubbed_video_mappings()
try:
ensure_dir(cache_dir)
with open(cache_file, "w") as fp:
fp.write(csv_data)
except Exception as e:
logging.error("Failed to make a local cache of the CSV data: %s" % e)
# Now we've built the map. Save it.
out_file = DUBBED_VIDEOS_MAPPING_FILEPATH
ensure_dir(os.path.dirname(out_file))
logging.info("Saving data to %s" % out_file)
with open(out_file, "w") as fp:
json.dump(video_map, fp)
logging.info("Done.")
def handle_po_compile_errors(lang_codes=None, out=None, err=None, rc=None):
"""
Return list of languages to not rezip due to errors in compile process.
Then email admins errors.
"""
broken_codes = re.findall(r'(?<=ka-lite/locale/)\w+(?=/LC_MESSAGES)', err) or []
if lang_codes:
# Only show the errors relevant to the list of language codes passed in.
lang_codes = set([lcode_to_django_dir(lc) for lc in lang_codes])
broken_codes = list(set(broken_codes).intersection(lang_codes))
if broken_codes:
logging.warning("Found %d errors while compiling in codes %s. Mailing admins report now." % (len(broken_codes), ', '.join(broken_codes)))
subject = "Error while compiling po files"
commands = "\n".join(["python manage.py compilemessages -l %s" % lc for lc in broken_codes])
message = """The following codes had errors when compiling their po files: %s.
Please rerun the following commands to see specific line numbers
that need to be corrected on CrowdIn, before we can update the language packs.
%s""" % (
', '.join([lcode_to_ietf(lc) for lc in broken_codes]),
commands,
)
if not settings.DEBUG:
mail_admins(subject=subject, message=message)
logging.info("Report sent.")
else:
logging.info("DEBUG is True so not sending email, but would have sent the following: SUBJECT: %s; MESSAGE: %s" % (subject, message))
return broken_codes
def get_language_pack(lang_code, software_version, callback):
"""Download language pack for specified language"""
lang_code = lcode_to_ietf(lang_code)
logging.info("Retrieving language pack: %s" % lang_code)
request_url = get_language_pack_url(lang_code, software_version)
path, response = download_file(request_url, callback=callback_percent_proxy(callback))
return path
def run_makemessages():
"""Run makemessages command for english po files"""
logging.info("Executing makemessages command")
# Generate english po file
ignore_pattern = ['python-packages/*'] + ['kalite/%s/*' % dirname for dirname in ['central', 'contact', 'faq', 'registration', 'tests', 'stats']]
call_command('makemessages', locale='en', ignore_patterns=ignore_pattern, no_obsolete=True)
# Generate english po file for javascript
ignore_pattern = ['kalite/static/admin/js/*', 'python-packages/*', 'kalite/static/js/i18n/*', 'kalite/static/js/khan-exercises/*']
call_command('makemessages', domain='djangojs', locale='en', ignore_patterns=ignore_pattern, no_obsolete=True)
def update_templates():
"""Update template po files"""
pot_path = os.path.join(settings.DATA_PATH, "i18n", "pot")
logging.info("Copying english po files to %s" % pot_path)
# post them to exposed URL
ensure_dir(pot_path)
shutil.copy(os.path.join(settings.LOCALE_PATHS[0], "en/LC_MESSAGES/django.po"), os.path.join(pot_path, "kalite.pot"))
shutil.copy(os.path.join(settings.LOCALE_PATHS[0], "en/LC_MESSAGES/djangojs.po"), os.path.join(pot_path, "kalitejs.pot"))
def unpack_language(lang_code, zip_filepath=None, zip_fp=None, zip_data=None):
"""Unpack zipped language pack into locale directory"""
lang_code = lcode_to_django_dir(lang_code)
logging.info("Unpacking new translations")
ensure_dir(os.path.join(LOCALE_ROOT, lang_code, "LC_MESSAGES"))
## Unpack into temp dir
z = zipfile.ZipFile(zip_fp or (StringIO(zip_data) if zip_data else open(zip_filepath, "rb")))
z.extractall(os.path.join(LOCALE_ROOT, lang_code))
def cancel_progress(self, stage_status=None, notes=None):
"""
Stamps end time.
"""
logging.info("Cancelling process %s" % (self.process_name))
self.stage_status = stage_status or "cancelled"
self.end_time = datetime.datetime.now()
self.completed=False
self.notes = notes
self.save()
def scrub_locale_paths():
for locale_root in settings.LOCALE_PATHS:
if not os.path.exists(locale_root):
continue
for lang in os.listdir(locale_root):
# Skips if not a directory
if not os.path.isdir(os.path.join(locale_root, lang)):
continue
# If it isn't crowdin/django format, keeeeeeellllllll
if lang != lcode_to_django_dir(lang):
logging.info("Deleting %s directory because it does not fit our language code format standards" % lang)
shutil.rmtree(os.path.join(locale_root, lang))
def cancel_current_stage(self, stage_status=None, notes=None):
"""
Delete the current stage--it's reported progress, and contribution to the total # of stages
"""
logging.info("Cancelling stage %s of process %s" % (self.stage_name, self.process_name))
self.stage_percent = 0.
self.update_total_stages(self.total_stages - 1)
self.stage_name = None
self.stage_status = stage_status or "cancelled"
self.notes = notes
self.save()
def run(self):
jobs = Job.objects.due()
prof_string = "" if not self.do_profile else "[%8.2f MB] " % memory_profiler.memory_usage()[0]
if jobs:
logger.info("%sRunning %d due jobs... (%s)" % (prof_string, jobs.count(), ", ".join(['"%s"' % job.name for job in jobs])))
call_command('cron')
else:
logger.debug("%sNo jobs due to run." % prof_string)
if self.do_gc:
gc.collect()
def update_srts(since_date, lang_codes):
"""
Run the commands to update subtitles that haven't been updated in the number of days provided.
Default is to update all srt files that haven't been requested in 30 days
"""
date_as_str = '{0.month}/{0.day}/{0.year}'.format(since_date)
logging.info("Updating subtitles that haven't been refreshed since %s" % date_as_str)
call_command("generate_subtitle_map", date_since_attempt=date_as_str)
if lang_codes:
for lang_code in lang_codes:
call_command("cache_subtitles", date_since_attempt=date_as_str, lang_code=lang_code)
else:
call_command("cache_subtitles", date_since_attempt=date_as_str)
def build_translations(project_id=None, project_key=None):
"""Build latest translations into zip archive on CrowdIn."""
if not project_id:
project_id = settings.CROWDIN_PROJECT_ID
if not project_key:
project_key = settings.CROWDIN_PROJECT_KEY
logging.info("Requesting that CrowdIn build a fresh zip of our translations")
request_url = "http://api.crowdin.net/api/project/%s/export?key=%s" % (project_id, project_key)
try:
resp = requests.get(request_url)
resp.raise_for_status()
except Exception as e:
logging.error(e)
def generate_fake_facility_users(nusers=20, facilities=None, facility_groups=None, password="******"):
"""Add the given fake facility users to each of the given fake facilities.
If no facilities are given, they are created."""
if not facility_groups:
(facility_groups, facilities) = generate_fake_facility_groups(facilities=facilities)
facility_users = []
cur_usernum = 0
users_per_group = nusers / len(facility_groups)
for facility in facilities:
for facility_group in facility_groups:
for i in range(0, users_per_group):
user_data = {
"first_name": random.choice(firstnames),
"last_name": random.choice(lastnames),
}
user_data["username"] = username_from_name(user_data["first_name"], user_data["last_name"])
try:
facility_user = FacilityUser.objects.get(facility=facility, username=user_data["username"])
facility_user.group = facility_group
facility_user.save()
logging.info("Retrieved facility user '%s/%s'" % (facility.name, user_data["username"]))
except FacilityUser.DoesNotExist as e:
notes = json.dumps(sample_user_settings())
facility_user = FacilityUser(
facility=facility,
username=user_data["username"],
first_name=user_data["first_name"],
last_name=user_data["last_name"],
notes=notes,
group=facility_group,
)
facility_user.set_password(password) # set same password for every user
facility_user.save()
logging.info("Created facility user '%s/%s'" % (facility.name, user_data["username"]))
facility_users.append(facility_user)
cur_usernum += 1 # this is messy and could be done more intelligently;
# could also randomize to add more users, as this function
# seems to be generic, but really is not.
return (facility_users, facility_groups, facilities)
def get_api_resource(request, resource_url):
"""
Step 3 of the api process:
Get the data.
"""
logging.info("Getting data from khan academy (%s)." % resource_url)
client = TestOAuthClient(KHAN_SERVER_URL, settings.KHAN_API_CONSUMER_KEY, settings.KHAN_API_CONSUMER_SECRET)
start = time.time()
response = client.access_resource(resource_url, request.session["ACCESS_TOKEN"])
end = time.time()
logging.debug("API (%s) time: %s" % (resource_url, end - start))
data = json.loads(response)
logging.info("Got %d items from khan academy (%s)." % (len(data), resource_url))
return data
def generate_fake_facilities(names=("Wilson Elementary",)):
"""Add the given fake facilities"""
facilities = []
for name in names:
found_facilities = Facility.objects.filter(name=name)
if found_facilities:
facility = found_facilities[0]
logging.info("Retrieved facility '%s'" % name)
else:
facility = Facility(name=name)
facility.save()
logging.info("Created facility '%s'" % name)
facilities.append(facility)
return facilities
def run_tests(self, test_labels, extra_tests=None, **kwargs):
"""By default, only run relevant app tests. If you specify... you're on your own!"""
# Purge all .pyc files using the clean_pyc django extension.
# This prevents issues when py's have been renamed or moved but
# the orphan pyc's are discovered and run during testing
# pyc's are not tracked by git, so orphans can happen when an
# older branch has been checked out
logging.info("Purging pyc files")
management.call_command("clean_pyc", path=os.path.join(settings.PROJECT_PATH, ".."))
if not test_labels:
test_labels = set(['main', 'central', 'securesync'])
if settings.CENTRAL_SERVER:
test_labels -= set(['main',])
else:
test_labels -= set(['central',])
return super(KALiteTestRunner,self).run_tests(test_labels, extra_tests, **kwargs)
def remove_nonmetadata(pofilename, METADATA_MARKER):
'''Checks each message block in the po file given by pofilename, and
sees if the top comment of each one has the string '(of|for)
exercise'. If not, then it will be deleted from the po file.
'''
assert os.path.exists(pofilename), "%s does not exist!" % pofilename
logging.info('Removing nonmetadata msgblocks from %s' % pofilename)
pofile = polib.pofile(pofilename)
clean_pofile = polib.POFile(encoding='utf-8')
clean_pofile.append(pofile.metadata_as_entry())
for msgblock in pofile:
if re.match(METADATA_MARKER, msgblock.tcomment):
# is exercise metadata, preserve
clean_pofile.append(msgblock)
os.remove(pofilename)
clean_pofile.save(fpath=pofilename)
def get_dubbed_video_map(lang_code=None, force=False):
"""
Stores a key per language. Value is a dictionary between video_id and (dubbed) youtube_id
"""
global DUBBED_VIDEO_MAP, DUBBED_VIDEO_MAP_RAW, DUBBED_VIDEOS_MAPPING_FILEPATH
if DUBBED_VIDEO_MAP is None or force:
try:
if not os.path.exists(DUBBED_VIDEOS_MAPPING_FILEPATH) or force:
try:
if settings.CENTRAL_SERVER:
# Never call commands that could fail from the distributed server.
# Always create a central server API to abstract things (see below)
logging.debug("Generating dubbed video mappings.")
call_command("generate_dubbed_video_mappings", force=force)
else:
# Generate from the spreadsheet
response = requests.get("http://%s/api/i18n/videos/dubbed_video_map" % (settings.CENTRAL_SERVER_HOST))
response.raise_for_status()
with open(DUBBED_VIDEOS_MAPPING_FILEPATH, "wb") as fp:
fp.write(response.content.decode('utf-8')) # wait until content has been confirmed before opening file.
except Exception as e:
if not os.path.exists(DUBBED_VIDEOS_MAPPING_FILEPATH):
# Unrecoverable error, so raise
raise
elif DUBBED_VIDEO_MAP:
# No need to recover--allow the downstream dude to catch the error.
raise
else:
# We can recover by NOT forcing reload.
logging.warn("%s" % e)
DUBBED_VIDEO_MAP_RAW = softload_json(DUBBED_VIDEOS_MAPPING_FILEPATH, raises=True)
except Exception as e:
logging.info("Failed to get dubbed video mappings; defaulting to empty.")
DUBBED_VIDEO_MAP_RAW = {} # setting this will avoid triggering reload on every call
DUBBED_VIDEO_MAP = {}
for lang_name, video_map in DUBBED_VIDEO_MAP_RAW.iteritems():
logging.debug("Adding dubbed video map entry for %s (name=%s)" % (get_langcode_map(lang_name), lang_name))
DUBBED_VIDEO_MAP[get_langcode_map(lang_name)] = video_map
return DUBBED_VIDEO_MAP.get(lang_code, {}) if lang_code else DUBBED_VIDEO_MAP
def reinitialize_server(self):
"""Reset the server state."""
if not settings.CENTRAL_SERVER:
logging.info("Invalidating the web cache.")
from fle_utils.internet.webcache import invalidate_web_cache
invalidate_web_cache()
# Next, call videoscan.
logging.info("Running videoscan.")
call_command("videoscan")
# Finally, pre-load global data
def preload_global_data():
if not settings.CENTRAL_SERVER:
logging.info("Preloading topic data.")
from main.topic_tools import get_topic_tree
from updates import stamp_availability_on_topic
stamp_availability_on_topic(get_topic_tree(), force=True, stamp_urls=True)
preload_global_data()
def _get_installed_language_packs():
"""
On-disk method to show currently installed languages and meta data.
"""
# There's always English...
installed_language_packs = [{
'code': 'en',
'software_version': VERSION,
'language_pack_version': 0,
'percent_translated': 100,
'subtitle_count': 0,
'name': 'English',
'native_name': 'English',
}]
# Loop through locale folders
for locale_dir in settings.LOCALE_PATHS:
if not os.path.exists(locale_dir):
continue
# Loop through folders in each locale dir
for django_disk_code in os.listdir(locale_dir):
# Inside each folder, read from the JSON file - language name, % UI trans, version number
try:
# Get the metadata
metadata_filepath = os.path.join(locale_dir, django_disk_code, "%s_metadata.json" % lcode_to_ietf(django_disk_code))
lang_meta = softload_json(metadata_filepath, raises=True)
logging.debug("Found language pack %s" % (django_disk_code))
except Exception as e:
if isinstance(e, IOError) and e.errno == 2:
logging.info("Ignoring non-language pack %s in %s" % (django_disk_code, locale_dir))
else:
logging.error("Error reading %s metadata (%s): %s" % (django_disk_code, metadata_filepath, e))
continue
installed_language_packs.append(lang_meta)
sorted_list = sorted(installed_language_packs, key=lambda m: m['name'].lower())
return OrderedDict([(lcode_to_ietf(val["code"]), val) for val in sorted_list])
def handle(self, *args, **options):
if not options["lang_code"]:
raise CommandError("You must specify a language code.")
lang_code = lcode_to_ietf(options["lang_code"])
if lang_code not in AVAILABLE_EXERCISE_LANGUAGE_CODES:
logging.info("No exercises available for language %s" % lang_code)
else:
# Get list of exercises
exercise_ids = options["exercise_ids"].split(",") if options["exercise_ids"] else None
exercise_ids = exercise_ids or ([ex["id"] for ex in get_topic_exercises(topic_id=options["topic_id"])] if options["topic_id"] else None)
exercise_ids = exercise_ids or get_node_cache("Exercise").keys()
# Download the exercises
for exercise_id in exercise_ids:
scrape_exercise(exercise_id=exercise_id, lang_code=lang_code, force=options["force"])
logging.info("Process complete.")
def scrape_exercise(exercise_id, lang_code, force=False):
ietf_lang_code = lcode_to_ietf(lang_code)
exercise_dest_filepath = get_exercise_filepath(exercise_id, lang_code=lang_code)
exercise_localized_root = os.path.dirname(exercise_dest_filepath)
if os.path.exists(exercise_dest_filepath) and not force:
return
exercise_url = "https://es.khanacademy.org/khan-exercises/exercises/%s.html?lang=%s" % (exercise_id, ietf_lang_code)
logging.info("Retrieving exercise %s from %s" % (exercise_id, exercise_url))
try:
ensure_dir(exercise_localized_root)
resp = requests.get(exercise_url)
resp.raise_for_status()
with open(exercise_dest_filepath, "wb") as fp:
fp.write(resp.content)
except Exception as e:
logging.error("Failed to download %s: %s" % (exercise_url, e))
def generate_fake_facility_groups(names=("Class 4E", "Class 5B"), facilities=None):
"""Add the given fake facility groups to the given fake facilities"""
if not facilities:
facilities = generate_fake_facilities()
facility_groups = []
for facility in facilities:
for name in names:
found_facility_groups = FacilityGroup.objects.filter(facility=facility, name=name)
if found_facility_groups:
facility_group = found_facility_groups[0]
logging.info("Retrieved facility group '%s'" % name)
else:
facility_group = FacilityGroup(facility=facility, name=name)
facility_group.save()
logging.info("Created facility group '%s'" % name)
facility_groups.append(facility_group)
return (facility_groups, facilities)
def move_old_subtitles():
locale_root = settings.LOCALE_PATHS[0]
srt_root = os.path.join(settings.STATIC_ROOT, "srt")
if os.path.exists(srt_root):
logging.info("Outdated schema detected for storing srt files. Hang tight, the moving crew is on it.")
for lang in os.listdir(srt_root):
# Skips if not a directory
if not os.path.isdir(os.path.join(srt_root, lang)):
continue
lang_srt_path = os.path.join(srt_root, lang, "subtitles/")
lang_locale_path = os.path.join(locale_root, lang)
ensure_dir(lang_locale_path)
dst = os.path.join(lang_locale_path, "subtitles")
for srt_file_path in glob.glob(os.path.join(lang_srt_path, "*.srt")):
base_path, srt_filename = os.path.split(srt_file_path)
if not os.path.exists(os.path.join(dst, srt_filename)):
ensure_dir(dst)
shutil.move(srt_file_path, os.path.join(dst, srt_filename))
shutil.rmtree(srt_root)
logging.info("Move completed.")
def move_exercises(lang_code):
lang_pack_location = os.path.join(LOCALE_ROOT, lang_code)
src_exercise_dir = os.path.join(lang_pack_location, "exercises")
dest_exercise_dir = get_localized_exercise_dirpath(lang_code, is_central_server=False)
if not os.path.exists(src_exercise_dir):
logging.warn("Could not find downloaded exercises; skipping: %s" % src_exercise_dir)
else:
# Move over one at a time, to combine with any other resources that were there before.
ensure_dir(dest_exercise_dir)
all_exercise_files = glob.glob(os.path.join(src_exercise_dir, "*.html"))
logging.info("Moving %d downloaded exercises to %s" % (len(all_exercise_files), dest_exercise_dir))
for exercise_file in all_exercise_files:
shutil.move(exercise_file, os.path.join(dest_exercise_dir, os.path.basename(exercise_file)))
logging.debug("Removing emtpy directory")
try:
shutil.rmtree(src_exercise_dir)
except Exception as e:
logging.error("Error removing dubbed video directory (%s): %s" % (src_exercise_dir, e))
