def test_job_add_task(self):
job = Job()
self.assertEqual(len(job), 0)
task1 = Task()
job.add_task(task1)
self.assertEqual(len(job), 1)
task2 = Task()
job.add_task(task2)
self.assertEqual(len(job), 2)
task3 = Task()
job.add_task(task3)
self.assertEqual(len(job), 3)
def total_FA(soundfile, mylines, myhead, mytail, config=None):
"""Runs Aeneas as a library. This function isn't in use, currently,
as we haven't managed to get reliable results in this way."""
# create Task object
if config is None:
config_string = (
u"task_language=nor|is_text_type=plain|os_task_file_format=json|is_audio_file_head_length=%s|is_audio_file_tail_length=%s"
% (myhead, mytail))
print(config_string)
else:
config_string = (
u"task_language=nor|is_text_type=plain|os_task_file_format=json|is_audio_file_head_length=%s|is_audio_file_tail_length=%s|%s"
% (myhead, mytail, config))
print(config_string)
task = Task(config_string=config_string)
print(task)
task.audio_file_path_absolute = soundfile
textfile = TextFile()
print(textfile)
#task.sync_map_file_path_absolute = outfile
for identifier, frag_text in mylines:
textfile.add_fragment(
TextFragment(identifier, Language.NOR, frag_text, frag_text))
task.text_file = textfile
print(len(task.text_file))
ExecuteTask(task).execute()
syncmaplist = task.sync_map.fragments
return syncmaplist
def test_job_clear_tasks(self):
job = Job()
task1 = Task()
job.tasks.append(task1)
self.assertEqual(len(job), 1)
job.clear_tasks()
self.assertEqual(len(job), 0)
def force_align(audio_path,
text_path,
output_path,
min_length=1.0,
max_length=10.0,
logging=logging):
sentences = []
task = Task(
config_string=
u"task_language=eng|is_text_type=plain|os_task_file_format=json")
task.audio_file_path_absolute = audio_path
task.text_file_path_absolute = text_path
task.sync_map_file_path_absolute = output_path
logging.info("Aligning audio and text...")
ExecuteTask(task).execute()
logging.info("Aligned audio and text")
for fragment in task.sync_map_leaves():
if fragment.length > min_length and fragment.length < max_length and fragment.text:
sentences.append({
"start": float(fragment.begin),
"end": float(fragment.end),
"length": float(fragment.length),
"text": fragment.text,
})
with open(output_path, "w") as f:
json.dump(sentences, f, indent=4)
def align_audio(
language: LanguageEnum = Form(...),
text_file_format: TextFileFormatEnum = Form(...),
transcript: UploadFile = File(...),
audio: UploadFile = File(...),
):
try:
# prepare config
aeneas_config = TaskConfiguration()
aeneas_config[gc.PPN_TASK_IS_TEXT_FILE_FORMAT] = text_file_format
aeneas_config[gc.PPN_TASK_LANGUAGE] = language
# get named temporary files
tmp_audio = convert_to_tempfile(audio)
tmp_transcript = convert_to_tempfile(transcript)
# create task
task = Task()
task.configuration = aeneas_config
task.audio_file_path_absolute = Path(tmp_audio.name)
task.text_file_path_absolute = Path(tmp_transcript.name)
# process Task
ExecuteTask(task).execute()
tmp_audio.close()
tmp_transcript.close()
return [(str(fragment.begin), str(fragment.end), fragment.text)
for fragment in task.sync_map_leaves() if fragment.is_regular]
except Exception as e:
raise HTTPException(status_code=500,
detail="Error during processing: " + str(e)) from e
def align(text_path, audio_path, align_out_path, word_align=True):
# create Task object
config_string = u"task_language=hi"
config_string += "|os_task_file_format=json"
rconf = None
if word_align:
config_string += "|os_task_file_levels=3"
config_string += "|is_text_type=mplain"
rconf = RuntimeConfiguration()
rconf[RuntimeConfiguration.MFCC_MASK_NONSPEECH] = True
rconf[RuntimeConfiguration.MFCC_MASK_NONSPEECH_L3] = True
else:
config_string += "|is_text_type=plain"
task = Task(config_string=config_string)
task.text_file_path_absolute = text_path
task.audio_file_path_absolute = audio_path
task.sync_map_file_path_absolute = align_out_path
# process Task
ExecuteTask(task, rconf=rconf).execute()
# output sync map to file
task.output_sync_map_file()
# Remove annoying unicode characters
with open(align_out_path, 'r', encoding='utf8') as f:
alignment = json.load(f)
with open(align_out_path, 'w', encoding='utf8') as f:
json.dump(alignment, f, ensure_ascii=False, indent=2)
def test_task_sync_map_leaves(self):
task = Task()
task.configuration = TaskConfiguration()
task.configuration["language"] = Language.ENG
task.configuration["o_format"] = SyncMapFormat.TXT
task.sync_map = self.dummy_sync_map()
self.assertEqual(len(task.sync_map_leaves()), 3)
def align_files_in_place(data: InputDataFiles):
try:
# prepare config
aeneas_config = TaskConfiguration()
aeneas_config[gc.PPN_TASK_IS_TEXT_FILE_FORMAT] = data.text_file_format
aeneas_config[gc.PPN_TASK_LANGUAGE] = data.language
# create task
task = Task()
task.configuration = aeneas_config
task.audio_file_path_absolute = Path(data.audio_filename)
task.text_file_path_absolute = Path(data.transcript_filename)
# process Task
ExecuteTask(task).execute()
with open(data.alignment_filename, "w") as f:
f.write(
orjson.dumps([(str(fragment.begin), str(fragment.end),
fragment.text)
for fragment in task.sync_map_leaves()
if fragment.is_regular]).decode())
except Exception as e:
raise HTTPException(status_code=500,
detail="Error during processing: " + str(e)) from e
def createSyncedLyricsFile(lyrics, file):
global lyricsSynced, errors
f = open("tempSync.txt", "w+")
f.write(lyrics)
f.close()
config = TaskConfiguration()
config[gc.PPN_TASK_LANGUAGE] = Language.FRA
config[gc.PPN_TASK_IS_TEXT_FILE_FORMAT] = TextFileFormat.PLAIN
config[gc.PPN_TASK_OS_FILE_FORMAT] = SyncMapFormat.AUDH
task = Task()
task.configuration = config
try:
task.audio_file_path_absolute = file
task.text_file_path_absolute = "tempSync.txt"
ExecuteTask(task).execute()
syncedLyricsFile = open(file[:-4] + ".lrc", "w+")
for fragment in task.sync_map_leaves():
syncedLyricsFile.write(
str('[' + gf.time_to_hhmmssmmm(fragment.interval.begin, '.')[3:-1] + ']' + fragment.text + '\n'))
syncedLyricsFile.close()
print(" Sync Added", sep=' ', end='', flush=True)
lyricsSynced += 1
except Exception as e :
errors += 1
print(" Sync error", sep=' ', end='',flush=True)
def align_aeneas():
for PID in config.PIDs:
audio_wc = os.path.join(PID, config.narrations_subfolder, "*.m4a")
audio_file_list = glob(audio_wc)
if len(audio_file_list) == 0:
audio_wc = os.path.join(PID, config.narrations_subfolder, "*.mp3")
audio_file_list = glob(audio_wc)
audio_file_list.sort()
for a in audio_file_list:
file_id = os.path.split(a)[1][0:6]
t = os.path.join(config.aeneas_transcript_dir, file_id + ".txt")
out_file = os.path.join(config.aeneas_output_dir, file_id + ".sbv")
print "aligning " + a, t
if not os.path.isfile(t):
print t + " not available so will not be processed. Was it a missed ground truth file?"
continue
# create Task object
config_string = u"task_language=eng|is_text_type=plain|os_task_file_format=sbv"
task = Task(config_string=config_string)
task.audio_file_path_absolute = a
task.text_file_path_absolute = t
task.sync_map_file_path_absolute = out_file
# process Task
ExecuteTask(task).execute()
# output sync map to file
task.output_sync_map_file()
def test_set_audio_file_path_absolute(self):
task = Task()
task.audio_file_path_absolute = get_abs_path(
"res/container/job/assets/p001.mp3")
self.assertNotEqual(task.audio_file, None)
self.assertEqual(task.audio_file.file_size, 426735)
self.assertAlmostEqual(task.audio_file.audio_length, 53.3, places=1)
def test_set_audio_file_path_absolute(self):
task = Task()
task.audio_file_path_absolute = gf.absolute_path(
"res/container/job/assets/p001.mp3", __file__)
self.assertIsNotNone(task.audio_file)
self.assertEqual(task.audio_file.file_size, 426735)
self.assertAlmostEqual(task.audio_file.audio_length,
TimeValue("53.3"),
places=1)
def force_align():
WORK_DIR = os.path.abspath("data")
conf = "task_language=rus|is_text_type=plain|os_task_file_format=json"
task = Task(config_string=conf)
task.audio_file_path_absolute = f"{WORK_DIR}/audio.wav"
task.text_file_path_absolute = f"{WORK_DIR}/transcript.txt"
ExecuteTask(task).execute()
return json.loads(task.sync_map.json_string)["fragments"]
def test_output_sync_map(self):
task = Task()
task.configuration = TaskConfiguration()
task.configuration.language = Language.EN
task.configuration.os_file_format = SyncMapFormat.TXT
task.sync_map = self.dummy_sync_map()
handler, output_file_path = tempfile.mkstemp(suffix=".txt")
task.sync_map_file_path_absolute = output_file_path
path = task.output_sync_map_file()
self.assertNotEqual(path, None)
self.assertEqual(path, output_file_path)
delete_file(handler, output_file_path)
def test_execute(self):
config_string = "task_language=en|os_task_file_format=smil|os_task_file_name=p001.smil|os_task_file_smil_audio_ref=p001.mp3|os_task_file_smil_page_ref=p001.xhtml|is_text_type=unparsed|is_text_unparsed_id_regex=f[0-9]+|is_text_unparsed_id_sort=numeric"
task = Task(config_string)
task.audio_file_path_absolute = "../aeneas/tests/res/container/job/assets/p001.mp3"
task.text_file_path_absolute = "../aeneas/tests/res/container/job/assets/p001.xhtml"
logger = Logger(tee=True)
executor = ExecuteTask(task, logger=logger)
result = executor.execute()
self.assertTrue(result)
task.sync_map_file_path_absolute = "/tmp/p001.smil"
path = task.output_sync_map_file()
self.assertNotEqual(path, None)
def transcribe(self, audio, transcript, output):
config_string = u"task_language=eng|is_text_type=plain|os_task_file_format=json"
task = Task(config_string=config_string)
task.audio_file_path_absolute = audio #get_path(self.audio_folder, self.audio_prefix, filename, "mp3")
task.text_file_path_absolute = transcript #get_path(self.transcript_processed_folder, self.transcript_processed_prefix, filename, "txt")
task.sync_map_file_path_absolute = output #get_path(self.output_folder, self.output_prefix, filename, "json")
print("Processing task...\n")
# process Task
ExecuteTask(task).execute()
print(f"Taks processed. Writing output to {output}")
# output sync map to file
task.output_sync_map_file()
def test_execute(self):
config_string = "task_language=en|os_task_file_format=txt|os_task_file_name=output_head.txt|is_text_type=plain|is_audio_file_head_length=11.960|is_audio_file_process_length=31.640"
task = Task(config_string)
task.audio_file_path_absolute = "../aeneas/tests/res/container/job/assets/p001.mp3"
task.text_file_path_absolute = "../aeneas/tests/res/inputtext/sonnet_plain_head_length.txt"
logger = Logger(tee=True)
executor = ExecuteTask(task, logger=logger)
result = executor.execute()
self.assertTrue(result)
task.sync_map_file_path_absolute = "/tmp/output_head_length.txt"
path = task.output_sync_map_file()
self.assertNotEqual(path, None)
def test_output_sync_map(self):
task = Task()
task.configuration = TaskConfiguration()
task.configuration["language"] = Language.ENG
task.configuration["o_format"] = SyncMapFormat.TXT
task.sync_map = self.dummy_sync_map()
handler, output_file_path = gf.tmp_file(suffix=".txt")
task.sync_map_file_path_absolute = output_file_path
path = task.output_sync_map_file()
self.assertIsNotNone(path)
self.assertEqual(path, output_file_path)
gf.delete_file(handler, output_file_path)
def test_task_empty_on_creation(self):
task = Task()
self.assertEqual(task.configuration, None)
self.assertEqual(task.text_file, None)
self.assertEqual(task.audio_file, None)
self.assertEqual(task.sync_map, None)
self.assertEqual(task.audio_file_path, None)
self.assertEqual(task.audio_file_path_absolute, None)
self.assertEqual(task.text_file_path, None)
self.assertEqual(task.text_file_path_absolute, None)
self.assertEqual(task.sync_map_file_path, None)
self.assertEqual(task.sync_map_file_path_absolute, None)
def test_task_empty_on_creation(self):
task = Task()
self.assertIsNone(task.configuration)
self.assertIsNone(task.text_file)
self.assertIsNone(task.audio_file)
self.assertIsNone(task.sync_map)
self.assertIsNone(task.audio_file_path)
self.assertIsNone(task.audio_file_path_absolute)
self.assertIsNone(task.text_file_path)
self.assertIsNone(task.text_file_path_absolute)
self.assertIsNone(task.sync_map_file_path)
self.assertIsNone(task.sync_map_file_path_absolute)
def _create_task(self, task_info, config_string, sync_map_root_directory,
job_os_hierarchy_type):
"""
Create a task object from
1. the ``task_info`` found analyzing the container entries, and
2. the given ``config_string``.
:param task_info: the task information: ``[prefix, text_path, audio_path]``
:type task_info: list of strings
:param config_string: the configuration string
:type config_string: string
:param sync_map_root_directory: the root directory for the sync map files
:type sync_map_root_directory: string (path)
:param job_os_hierarchy_type: type of job output hierarchy
:type job_os_hierarchy_type: :class:`aeneas.hierarchytype.HierarchyType`
:rtype: :class:`aeneas.task.Task`
"""
self._log("Converting config string to config dict")
parameters = gf.config_string_to_dict(config_string)
self._log("Creating task")
task = Task(config_string)
task.configuration.description = "Task %s" % task_info[0]
self._log(["Task description: %s", task.configuration.description])
try:
task.configuration.language = parameters[gc.PPN_TASK_LANGUAGE]
self._log(
["Set language from task: '%s'", task.configuration.language])
except KeyError:
task.configuration.language = parameters[gc.PPN_JOB_LANGUAGE]
self._log(
["Set language from job: '%s'", task.configuration.language])
custom_id = task_info[0]
task.configuration.custom_id = custom_id
self._log(["Task custom_id: %s", task.configuration.custom_id])
task.text_file_path = task_info[1]
self._log(["Task text file path: %s", task.text_file_path])
task.audio_file_path = task_info[2]
self._log(["Task audio file path: %s", task.audio_file_path])
task.sync_map_file_path = self._compute_sync_map_file_path(
sync_map_root_directory, job_os_hierarchy_type, custom_id,
task.configuration.os_file_name)
self._log(["Task sync map file path: %s", task.sync_map_file_path])
self._log("Replacing placeholder in os_file_smil_audio_ref")
task.configuration.os_file_smil_audio_ref = self._replace_placeholder(
task.configuration.os_file_smil_audio_ref, custom_id)
self._log("Replacing placeholder in os_file_smil_page_ref")
task.configuration.os_file_smil_page_ref = self._replace_placeholder(
task.configuration.os_file_smil_page_ref, custom_id)
self._log("Returning task")
return task
def process_aeneas(txt_filename, wav_filename, csv_filename):
# create Task object
config_string = u"task_language=eng|is_text_type=plain|os_task_file_format=csv"
task = Task(config_string=config_string)
task.audio_file_path_absolute = wav_filename
task.text_file_path_absolute = txt_filename
task.sync_map_file_path_absolute = csv_filename
# process Task
ExecuteTask(task).execute()
# output sync map to file
task.output_sync_map_file()
def execute(self, config_string, audio_path, text_path):
handler, tmp_path = gf.tmp_file()
task = Task(config_string)
task.audio_file_path_absolute = gf.absolute_path(audio_path, __file__)
task.text_file_path_absolute = gf.absolute_path(text_path, __file__)
executor = ExecuteTask(task)
executor.execute()
task.sync_map_file_path_absolute = tmp_path
result_path = task.output_sync_map_file()
self.assertIsNotNone(result_path)
self.assertEqual(result_path, tmp_path)
self.assertGreater(len(gf.read_file_bytes(result_path)), 0)
gf.delete_file(handler, tmp_path)
def align_audio_and_text(self, file_path):
config = TaskConfiguration()
config[gc.PPN_TASK_LANGUAGE] = Language.PAN
config[gc.PPN_TASK_IS_TEXT_FILE_FORMAT] = TextFileFormat.PLAIN
config[gc.PPN_TASK_OS_FILE_FORMAT] = SyncMapFormat.JSON
task = Task()
task.configuration = config
task.audio_file_path_absolute = self.audio_file_path
task.text_file_path_absolute = self.txt_file_path
task.sync_map_file_path_absolute = file_path
ExecuteTask(task).execute()
task.output_sync_map_file()
def process_aeneas_map(filepath_, format_):
# create Task object
config_string = u"task_language=eng|is_text_type=plain|os_task_file_format=json"
task = Task(config_string=config_string)
task.audio_file_path_absolute = filepath_ + '.' + format_
task.text_file_path_absolute = filepath_ + ".txt"
task.sync_map_file_path_absolute = filepath_ + ".json"
# process Task
ExecuteTask(task).execute()
# output sync map to file
task.output_sync_map_file()
def run_aeneas_task(audio_filepath, lyrics_filepath, output_filepath):
config_string = "task_language=eng|os_task_file_format=json|is_text_type=plain"
task = Task(config_string=config_string)
task.audio_file_path_absolute = audio_filepath
task.text_file_path_absolute = lyrics_filepath
task.sync_map_file_path_absolute = output_filepath
# process Task
ExecuteTask(task).execute()
# output sync map to file
task.output_sync_map_file()
def align(audio_file_path, text_file_path, syncmap_file_path):
# create Task object
config_string = "task_language=zh|is_text_type=plain|os_task_file_format=txt"
task = Task(config_string=config_string)
task.audio_file_path_absolute = audio_file_path
task.text_file_path_absolute = text_file_path
task.sync_map_file_path_absolute = syncmap_file_path
# process Task
ExecuteTask(task).execute()
# output sync map to file
task.output_sync_map_file()
return True
def executeAeneas(text_path, audio_path):
audio_name, _ = os.path.splitext(audio_path)
# create Task object
config_string = u'task_language=tur|is_text_type=plain|os_task_file_format=json'
task = Task(config_string=config_string)
task.audio_file_path_absolute = audio_path
task.text_file_path_absolute = text_path
task.sync_map_file_path_absolute = audio_name + "_syncmap.json"
# process Task
ExecuteTask(task).execute()
# output sync map to file
task.output_sync_map_file()
def sync_map_generator(song_name):
# create Task object
print('Creating sync map file...')
config_string = u"task_language=eng|is_text_type=plain|os_task_file_format=json"
task = Task(config_string=config_string)
task.audio_file_path_absolute = "C:/Users/jaysh/Desktop/VandyHacks/Hack Prototype/Songs/" + song_name +".wav"
task.text_file_path_absolute = "C:/Users/jaysh/Desktop/VandyHacks/Hack Prototype/Lyrics/" + song_name +".txt"
task.sync_map_file_path_absolute = u"output/"+ song_name + ".json"
# process Task
ExecuteTask(task).execute()
# output sync map to file
task.output_sync_map_file()
print('Created sync map file')
def generate_epub(pub_id):
# create Task object
config_string = u"task_language=eng|is_text_type=plain|os_task_file_format=json"
task = Task(config_string=config_string)
task.audio_file_path_absolute = u"./test/audio.mp3"
task.text_file_path_absolute = u"./test/sonnet_plain.txt"
task.sync_map_file_path_absolute = u"./test/output.json"
# process Task
ExecuteTask(task).execute()
# output sync map to file
task.output_sync_map_file()
with open(task.sync_map_file_path_absolute, 'r') as f:
read_data = f.read()
return read_data #task.sync_map_file_path_absolute
