id int32 0 252k | repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 51 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 |
|---|---|---|---|---|---|---|---|---|---|---|---|
245,900 | readbeyond/aeneas | aeneas/plotter.py | PlotTimeScale.draw_png | def draw_png(self, image, h_zoom, v_zoom, current_y):
"""
Draw this time scale to PNG.
:param image: the image to draw onto
:param int h_zoom: the horizontal zoom
:param int v_zoom: the vertical zoom
:param int current_y: the current y offset, in modules
:type image: :class:`PIL.Image`
"""
# PIL object
draw = ImageDraw.Draw(image)
mws = self.rconf.mws
pixels_per_second = int(h_zoom / mws)
current_y_px = current_y * v_zoom
# create font, as tall as possible
font_height_pt = 18
font = ImageFont.truetype(self.FONT_PATH, font_height_pt)
# draw a tick every self.time_step seconds
for i in range(0, 1 + int(self.max_time), self.time_step):
# base x position
begin_px = i * pixels_per_second
# tick
left_px = begin_px - self.TICK_WIDTH
right_px = begin_px + self.TICK_WIDTH
top_px = current_y_px
bottom_px = current_y_px + v_zoom
draw.rectangle((left_px, top_px, right_px, bottom_px), fill=PlotterColors.BLACK)
# text
time_text = self._time_string(i)
left_px = begin_px + self.TICK_WIDTH + self.TEXT_MARGIN
top_px = current_y_px + (v_zoom - self.text_bounding_box(font_height_pt, time_text)[1]) // 2
draw.text((left_px, top_px), time_text, PlotterColors.BLACK, font=font) | python | def draw_png(self, image, h_zoom, v_zoom, current_y):
# PIL object
draw = ImageDraw.Draw(image)
mws = self.rconf.mws
pixels_per_second = int(h_zoom / mws)
current_y_px = current_y * v_zoom
# create font, as tall as possible
font_height_pt = 18
font = ImageFont.truetype(self.FONT_PATH, font_height_pt)
# draw a tick every self.time_step seconds
for i in range(0, 1 + int(self.max_time), self.time_step):
# base x position
begin_px = i * pixels_per_second
# tick
left_px = begin_px - self.TICK_WIDTH
right_px = begin_px + self.TICK_WIDTH
top_px = current_y_px
bottom_px = current_y_px + v_zoom
draw.rectangle((left_px, top_px, right_px, bottom_px), fill=PlotterColors.BLACK)
# text
time_text = self._time_string(i)
left_px = begin_px + self.TICK_WIDTH + self.TEXT_MARGIN
top_px = current_y_px + (v_zoom - self.text_bounding_box(font_height_pt, time_text)[1]) // 2
draw.text((left_px, top_px), time_text, PlotterColors.BLACK, font=font) | [
"def",
"draw_png",
"(",
"self",
",",
"image",
",",
"h_zoom",
",",
"v_zoom",
",",
"current_y",
")",
":",
"# PIL object",
"draw",
"=",
"ImageDraw",
".",
"Draw",
"(",
"image",
")",
"mws",
"=",
"self",
".",
"rconf",
".",
"mws",
"pixels_per_second",
"=",
"i... | Draw this time scale to PNG.
:param image: the image to draw onto
:param int h_zoom: the horizontal zoom
:param int v_zoom: the vertical zoom
:param int current_y: the current y offset, in modules
:type image: :class:`PIL.Image` | [
"Draw",
"this",
"time",
"scale",
"to",
"PNG",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/plotter.py#L305-L341 |
245,901 | readbeyond/aeneas | aeneas/plotter.py | PlotWaveform.draw_png | def draw_png(self, image, h_zoom, v_zoom, current_y):
"""
Draw this waveform to PNG.
:param image: the image to draw onto
:param int h_zoom: the horizontal zoom
:param int v_zoom: the vertical zoom
:param int current_y: the current y offset, in modules
:type image: :class:`PIL.Image`
"""
draw = ImageDraw.Draw(image)
mws = self.rconf.mws
rate = self.audio_file.audio_sample_rate
samples = self.audio_file.audio_samples
duration = self.audio_file.audio_length
current_y_px = current_y * v_zoom
half_waveform_px = (self.height // 2) * v_zoom
zero_y_px = current_y_px + half_waveform_px
samples_per_pixel = int(rate * mws / h_zoom)
pixels_per_second = int(h_zoom / mws)
windows = len(samples) // samples_per_pixel
if self.label is not None:
font_height_pt = 18
font = ImageFont.truetype(self.FONT_PATH, font_height_pt)
draw.text((0, current_y_px), self.label, PlotterColors.BLACK, font=font)
for i in range(windows):
x = i * samples_per_pixel
pos = numpy.clip(samples[x:(x + samples_per_pixel)], 0.0, 1.0)
mpos = numpy.max(pos) * half_waveform_px
if self.fast:
# just draw a simple version, mirroring max positive samples
draw.line((i, zero_y_px + mpos, i, zero_y_px - mpos), fill=PlotterColors.AUDACITY_DARK_BLUE, width=1)
else:
# draw a better version, taking min and std of positive and negative samples
neg = numpy.clip(samples[x:(x + samples_per_pixel)], -1.0, 0.0)
spos = numpy.std(pos) * half_waveform_px
sneg = numpy.std(neg) * half_waveform_px
mneg = numpy.min(neg) * half_waveform_px
draw.line((i, zero_y_px - mneg, i, zero_y_px - mpos), fill=PlotterColors.AUDACITY_DARK_BLUE, width=1)
draw.line((i, zero_y_px + sneg, i, zero_y_px - spos), fill=PlotterColors.AUDACITY_LIGHT_BLUE, width=1) | python | def draw_png(self, image, h_zoom, v_zoom, current_y):
draw = ImageDraw.Draw(image)
mws = self.rconf.mws
rate = self.audio_file.audio_sample_rate
samples = self.audio_file.audio_samples
duration = self.audio_file.audio_length
current_y_px = current_y * v_zoom
half_waveform_px = (self.height // 2) * v_zoom
zero_y_px = current_y_px + half_waveform_px
samples_per_pixel = int(rate * mws / h_zoom)
pixels_per_second = int(h_zoom / mws)
windows = len(samples) // samples_per_pixel
if self.label is not None:
font_height_pt = 18
font = ImageFont.truetype(self.FONT_PATH, font_height_pt)
draw.text((0, current_y_px), self.label, PlotterColors.BLACK, font=font)
for i in range(windows):
x = i * samples_per_pixel
pos = numpy.clip(samples[x:(x + samples_per_pixel)], 0.0, 1.0)
mpos = numpy.max(pos) * half_waveform_px
if self.fast:
# just draw a simple version, mirroring max positive samples
draw.line((i, zero_y_px + mpos, i, zero_y_px - mpos), fill=PlotterColors.AUDACITY_DARK_BLUE, width=1)
else:
# draw a better version, taking min and std of positive and negative samples
neg = numpy.clip(samples[x:(x + samples_per_pixel)], -1.0, 0.0)
spos = numpy.std(pos) * half_waveform_px
sneg = numpy.std(neg) * half_waveform_px
mneg = numpy.min(neg) * half_waveform_px
draw.line((i, zero_y_px - mneg, i, zero_y_px - mpos), fill=PlotterColors.AUDACITY_DARK_BLUE, width=1)
draw.line((i, zero_y_px + sneg, i, zero_y_px - spos), fill=PlotterColors.AUDACITY_LIGHT_BLUE, width=1) | [
"def",
"draw_png",
"(",
"self",
",",
"image",
",",
"h_zoom",
",",
"v_zoom",
",",
"current_y",
")",
":",
"draw",
"=",
"ImageDraw",
".",
"Draw",
"(",
"image",
")",
"mws",
"=",
"self",
".",
"rconf",
".",
"mws",
"rate",
"=",
"self",
".",
"audio_file",
... | Draw this waveform to PNG.
:param image: the image to draw onto
:param int h_zoom: the horizontal zoom
:param int v_zoom: the vertical zoom
:param int current_y: the current y offset, in modules
:type image: :class:`PIL.Image` | [
"Draw",
"this",
"waveform",
"to",
"PNG",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/plotter.py#L524-L567 |
245,902 | readbeyond/aeneas | aeneas/tools/run_sd.py | RunSDCLI.print_result | def print_result(self, audio_len, start, end):
"""
Print result of SD.
:param audio_len: the length of the entire audio file, in seconds
:type audio_len: float
:param start: the start position of the spoken text
:type start: float
:param end: the end position of the spoken text
:type end: float
"""
msg = []
zero = 0
head_len = start
text_len = end - start
tail_len = audio_len - end
msg.append(u"")
msg.append(u"Head: %.3f %.3f (%.3f)" % (zero, start, head_len))
msg.append(u"Text: %.3f %.3f (%.3f)" % (start, end, text_len))
msg.append(u"Tail: %.3f %.3f (%.3f)" % (end, audio_len, tail_len))
msg.append(u"")
zero_h = gf.time_to_hhmmssmmm(0)
start_h = gf.time_to_hhmmssmmm(start)
end_h = gf.time_to_hhmmssmmm(end)
audio_len_h = gf.time_to_hhmmssmmm(audio_len)
head_len_h = gf.time_to_hhmmssmmm(head_len)
text_len_h = gf.time_to_hhmmssmmm(text_len)
tail_len_h = gf.time_to_hhmmssmmm(tail_len)
msg.append("Head: %s %s (%s)" % (zero_h, start_h, head_len_h))
msg.append("Text: %s %s (%s)" % (start_h, end_h, text_len_h))
msg.append("Tail: %s %s (%s)" % (end_h, audio_len_h, tail_len_h))
msg.append(u"")
self.print_info(u"\n".join(msg)) | python | def print_result(self, audio_len, start, end):
msg = []
zero = 0
head_len = start
text_len = end - start
tail_len = audio_len - end
msg.append(u"")
msg.append(u"Head: %.3f %.3f (%.3f)" % (zero, start, head_len))
msg.append(u"Text: %.3f %.3f (%.3f)" % (start, end, text_len))
msg.append(u"Tail: %.3f %.3f (%.3f)" % (end, audio_len, tail_len))
msg.append(u"")
zero_h = gf.time_to_hhmmssmmm(0)
start_h = gf.time_to_hhmmssmmm(start)
end_h = gf.time_to_hhmmssmmm(end)
audio_len_h = gf.time_to_hhmmssmmm(audio_len)
head_len_h = gf.time_to_hhmmssmmm(head_len)
text_len_h = gf.time_to_hhmmssmmm(text_len)
tail_len_h = gf.time_to_hhmmssmmm(tail_len)
msg.append("Head: %s %s (%s)" % (zero_h, start_h, head_len_h))
msg.append("Text: %s %s (%s)" % (start_h, end_h, text_len_h))
msg.append("Tail: %s %s (%s)" % (end_h, audio_len_h, tail_len_h))
msg.append(u"")
self.print_info(u"\n".join(msg)) | [
"def",
"print_result",
"(",
"self",
",",
"audio_len",
",",
"start",
",",
"end",
")",
":",
"msg",
"=",
"[",
"]",
"zero",
"=",
"0",
"head_len",
"=",
"start",
"text_len",
"=",
"end",
"-",
"start",
"tail_len",
"=",
"audio_len",
"-",
"end",
"msg",
".",
... | Print result of SD.
:param audio_len: the length of the entire audio file, in seconds
:type audio_len: float
:param start: the start position of the spoken text
:type start: float
:param end: the end position of the spoken text
:type end: float | [
"Print",
"result",
"of",
"SD",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/run_sd.py#L171-L203 |
245,903 | readbeyond/aeneas | aeneas/task.py | Task.sync_map_leaves | def sync_map_leaves(self, fragment_type=None):
"""
Return the list of non-empty leaves
in the sync map associated with the task.
If ``fragment_type`` has been specified,
return only leaves of that fragment type.
:param int fragment_type: type of fragment to return
:rtype: list
.. versionadded:: 1.7.0
"""
if (self.sync_map is None) or (self.sync_map.fragments_tree is None):
return []
return [f for f in self.sync_map.leaves(fragment_type)] | python | def sync_map_leaves(self, fragment_type=None):
if (self.sync_map is None) or (self.sync_map.fragments_tree is None):
return []
return [f for f in self.sync_map.leaves(fragment_type)] | [
"def",
"sync_map_leaves",
"(",
"self",
",",
"fragment_type",
"=",
"None",
")",
":",
"if",
"(",
"self",
".",
"sync_map",
"is",
"None",
")",
"or",
"(",
"self",
".",
"sync_map",
".",
"fragments_tree",
"is",
"None",
")",
":",
"return",
"[",
"]",
"return",
... | Return the list of non-empty leaves
in the sync map associated with the task.
If ``fragment_type`` has been specified,
return only leaves of that fragment type.
:param int fragment_type: type of fragment to return
:rtype: list
.. versionadded:: 1.7.0 | [
"Return",
"the",
"list",
"of",
"non",
"-",
"empty",
"leaves",
"in",
"the",
"sync",
"map",
"associated",
"with",
"the",
"task",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/task.py#L149-L164 |
245,904 | readbeyond/aeneas | aeneas/task.py | Task.output_sync_map_file | def output_sync_map_file(self, container_root_path=None):
"""
Output the sync map file for this task.
If ``container_root_path`` is specified,
the output sync map file will be created
at the path obtained by joining
the ``container_root_path`` and the relative path
of the sync map inside the container.
Otherwise, the sync map file will be created at the path
``self.sync_map_file_path_absolute``.
Return the the path of the sync map file created,
or ``None`` if an error occurred.
:param string container_root_path: the path to the root directory
for the output container
:rtype: string
"""
if self.sync_map is None:
self.log_exc(u"The sync_map object has not been set", None, True, TypeError)
if (container_root_path is not None) and (self.sync_map_file_path is None):
self.log_exc(u"The (internal) path of the sync map has been set", None, True, TypeError)
self.log([u"container_root_path is %s", container_root_path])
self.log([u"self.sync_map_file_path is %s", self.sync_map_file_path])
self.log([u"self.sync_map_file_path_absolute is %s", self.sync_map_file_path_absolute])
if (container_root_path is not None) and (self.sync_map_file_path is not None):
path = os.path.join(container_root_path, self.sync_map_file_path)
elif self.sync_map_file_path_absolute:
path = self.sync_map_file_path_absolute
gf.ensure_parent_directory(path)
self.log([u"Output sync map to %s", path])
eaf_audio_ref = self.configuration["o_eaf_audio_ref"]
head_tail_format = self.configuration["o_h_t_format"]
levels = self.configuration["o_levels"]
smil_audio_ref = self.configuration["o_smil_audio_ref"]
smil_page_ref = self.configuration["o_smil_page_ref"]
sync_map_format = self.configuration["o_format"]
self.log([u"eaf_audio_ref is %s", eaf_audio_ref])
self.log([u"head_tail_format is %s", head_tail_format])
self.log([u"levels is %s", levels])
self.log([u"smil_audio_ref is %s", smil_audio_ref])
self.log([u"smil_page_ref is %s", smil_page_ref])
self.log([u"sync_map_format is %s", sync_map_format])
self.log(u"Calling sync_map.write...")
parameters = {
gc.PPN_TASK_OS_FILE_EAF_AUDIO_REF: eaf_audio_ref,
gc.PPN_TASK_OS_FILE_HEAD_TAIL_FORMAT: head_tail_format,
gc.PPN_TASK_OS_FILE_LEVELS: levels,
gc.PPN_TASK_OS_FILE_SMIL_AUDIO_REF: smil_audio_ref,
gc.PPN_TASK_OS_FILE_SMIL_PAGE_REF: smil_page_ref,
}
self.sync_map.write(sync_map_format, path, parameters)
self.log(u"Calling sync_map.write... done")
return path | python | def output_sync_map_file(self, container_root_path=None):
if self.sync_map is None:
self.log_exc(u"The sync_map object has not been set", None, True, TypeError)
if (container_root_path is not None) and (self.sync_map_file_path is None):
self.log_exc(u"The (internal) path of the sync map has been set", None, True, TypeError)
self.log([u"container_root_path is %s", container_root_path])
self.log([u"self.sync_map_file_path is %s", self.sync_map_file_path])
self.log([u"self.sync_map_file_path_absolute is %s", self.sync_map_file_path_absolute])
if (container_root_path is not None) and (self.sync_map_file_path is not None):
path = os.path.join(container_root_path, self.sync_map_file_path)
elif self.sync_map_file_path_absolute:
path = self.sync_map_file_path_absolute
gf.ensure_parent_directory(path)
self.log([u"Output sync map to %s", path])
eaf_audio_ref = self.configuration["o_eaf_audio_ref"]
head_tail_format = self.configuration["o_h_t_format"]
levels = self.configuration["o_levels"]
smil_audio_ref = self.configuration["o_smil_audio_ref"]
smil_page_ref = self.configuration["o_smil_page_ref"]
sync_map_format = self.configuration["o_format"]
self.log([u"eaf_audio_ref is %s", eaf_audio_ref])
self.log([u"head_tail_format is %s", head_tail_format])
self.log([u"levels is %s", levels])
self.log([u"smil_audio_ref is %s", smil_audio_ref])
self.log([u"smil_page_ref is %s", smil_page_ref])
self.log([u"sync_map_format is %s", sync_map_format])
self.log(u"Calling sync_map.write...")
parameters = {
gc.PPN_TASK_OS_FILE_EAF_AUDIO_REF: eaf_audio_ref,
gc.PPN_TASK_OS_FILE_HEAD_TAIL_FORMAT: head_tail_format,
gc.PPN_TASK_OS_FILE_LEVELS: levels,
gc.PPN_TASK_OS_FILE_SMIL_AUDIO_REF: smil_audio_ref,
gc.PPN_TASK_OS_FILE_SMIL_PAGE_REF: smil_page_ref,
}
self.sync_map.write(sync_map_format, path, parameters)
self.log(u"Calling sync_map.write... done")
return path | [
"def",
"output_sync_map_file",
"(",
"self",
",",
"container_root_path",
"=",
"None",
")",
":",
"if",
"self",
".",
"sync_map",
"is",
"None",
":",
"self",
".",
"log_exc",
"(",
"u\"The sync_map object has not been set\"",
",",
"None",
",",
"True",
",",
"TypeError",... | Output the sync map file for this task.
If ``container_root_path`` is specified,
the output sync map file will be created
at the path obtained by joining
the ``container_root_path`` and the relative path
of the sync map inside the container.
Otherwise, the sync map file will be created at the path
``self.sync_map_file_path_absolute``.
Return the the path of the sync map file created,
or ``None`` if an error occurred.
:param string container_root_path: the path to the root directory
for the output container
:rtype: string | [
"Output",
"the",
"sync",
"map",
"file",
"for",
"this",
"task",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/task.py#L166-L227 |
245,905 | readbeyond/aeneas | aeneas/task.py | Task._populate_audio_file | def _populate_audio_file(self):
"""
Create the ``self.audio_file`` object by reading
the audio file at ``self.audio_file_path_absolute``.
"""
self.log(u"Populate audio file...")
if self.audio_file_path_absolute is not None:
self.log([u"audio_file_path_absolute is '%s'", self.audio_file_path_absolute])
self.audio_file = AudioFile(
file_path=self.audio_file_path_absolute,
logger=self.logger
)
self.audio_file.read_properties()
else:
self.log(u"audio_file_path_absolute is None")
self.log(u"Populate audio file... done") | python | def _populate_audio_file(self):
self.log(u"Populate audio file...")
if self.audio_file_path_absolute is not None:
self.log([u"audio_file_path_absolute is '%s'", self.audio_file_path_absolute])
self.audio_file = AudioFile(
file_path=self.audio_file_path_absolute,
logger=self.logger
)
self.audio_file.read_properties()
else:
self.log(u"audio_file_path_absolute is None")
self.log(u"Populate audio file... done") | [
"def",
"_populate_audio_file",
"(",
"self",
")",
":",
"self",
".",
"log",
"(",
"u\"Populate audio file...\"",
")",
"if",
"self",
".",
"audio_file_path_absolute",
"is",
"not",
"None",
":",
"self",
".",
"log",
"(",
"[",
"u\"audio_file_path_absolute is '%s'\"",
",",
... | Create the ``self.audio_file`` object by reading
the audio file at ``self.audio_file_path_absolute``. | [
"Create",
"the",
"self",
".",
"audio_file",
"object",
"by",
"reading",
"the",
"audio",
"file",
"at",
"self",
".",
"audio_file_path_absolute",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/task.py#L229-L244 |
245,906 | readbeyond/aeneas | aeneas/task.py | Task._populate_text_file | def _populate_text_file(self):
"""
Create the ``self.text_file`` object by reading
the text file at ``self.text_file_path_absolute``.
"""
self.log(u"Populate text file...")
if (
(self.text_file_path_absolute is not None) and
(self.configuration["language"] is not None)
):
# the following values might be None
parameters = {
gc.PPN_TASK_IS_TEXT_FILE_IGNORE_REGEX: self.configuration["i_t_ignore_regex"],
gc.PPN_TASK_IS_TEXT_FILE_TRANSLITERATE_MAP: self.configuration["i_t_transliterate_map"],
gc.PPN_TASK_IS_TEXT_MPLAIN_WORD_SEPARATOR: self.configuration["i_t_mplain_word_separator"],
gc.PPN_TASK_IS_TEXT_MUNPARSED_L1_ID_REGEX: self.configuration["i_t_munparsed_l1_id_regex"],
gc.PPN_TASK_IS_TEXT_MUNPARSED_L2_ID_REGEX: self.configuration["i_t_munparsed_l2_id_regex"],
gc.PPN_TASK_IS_TEXT_MUNPARSED_L3_ID_REGEX: self.configuration["i_t_munparsed_l3_id_regex"],
gc.PPN_TASK_IS_TEXT_UNPARSED_CLASS_REGEX: self.configuration["i_t_unparsed_class_regex"],
gc.PPN_TASK_IS_TEXT_UNPARSED_ID_REGEX: self.configuration["i_t_unparsed_id_regex"],
gc.PPN_TASK_IS_TEXT_UNPARSED_ID_SORT: self.configuration["i_t_unparsed_id_sort"],
gc.PPN_TASK_OS_FILE_ID_REGEX: self.configuration["o_id_regex"]
}
self.text_file = TextFile(
file_path=self.text_file_path_absolute,
file_format=self.configuration["i_t_format"],
parameters=parameters,
logger=self.logger
)
self.text_file.set_language(self.configuration["language"])
else:
self.log(u"text_file_path_absolute and/or language is None")
self.log(u"Populate text file... done") | python | def _populate_text_file(self):
self.log(u"Populate text file...")
if (
(self.text_file_path_absolute is not None) and
(self.configuration["language"] is not None)
):
# the following values might be None
parameters = {
gc.PPN_TASK_IS_TEXT_FILE_IGNORE_REGEX: self.configuration["i_t_ignore_regex"],
gc.PPN_TASK_IS_TEXT_FILE_TRANSLITERATE_MAP: self.configuration["i_t_transliterate_map"],
gc.PPN_TASK_IS_TEXT_MPLAIN_WORD_SEPARATOR: self.configuration["i_t_mplain_word_separator"],
gc.PPN_TASK_IS_TEXT_MUNPARSED_L1_ID_REGEX: self.configuration["i_t_munparsed_l1_id_regex"],
gc.PPN_TASK_IS_TEXT_MUNPARSED_L2_ID_REGEX: self.configuration["i_t_munparsed_l2_id_regex"],
gc.PPN_TASK_IS_TEXT_MUNPARSED_L3_ID_REGEX: self.configuration["i_t_munparsed_l3_id_regex"],
gc.PPN_TASK_IS_TEXT_UNPARSED_CLASS_REGEX: self.configuration["i_t_unparsed_class_regex"],
gc.PPN_TASK_IS_TEXT_UNPARSED_ID_REGEX: self.configuration["i_t_unparsed_id_regex"],
gc.PPN_TASK_IS_TEXT_UNPARSED_ID_SORT: self.configuration["i_t_unparsed_id_sort"],
gc.PPN_TASK_OS_FILE_ID_REGEX: self.configuration["o_id_regex"]
}
self.text_file = TextFile(
file_path=self.text_file_path_absolute,
file_format=self.configuration["i_t_format"],
parameters=parameters,
logger=self.logger
)
self.text_file.set_language(self.configuration["language"])
else:
self.log(u"text_file_path_absolute and/or language is None")
self.log(u"Populate text file... done") | [
"def",
"_populate_text_file",
"(",
"self",
")",
":",
"self",
".",
"log",
"(",
"u\"Populate text file...\"",
")",
"if",
"(",
"(",
"self",
".",
"text_file_path_absolute",
"is",
"not",
"None",
")",
"and",
"(",
"self",
".",
"configuration",
"[",
"\"language\"",
... | Create the ``self.text_file`` object by reading
the text file at ``self.text_file_path_absolute``. | [
"Create",
"the",
"self",
".",
"text_file",
"object",
"by",
"reading",
"the",
"text",
"file",
"at",
"self",
".",
"text_file_path_absolute",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/task.py#L246-L278 |
245,907 | readbeyond/aeneas | aeneas/syncmap/smfgxml.py | SyncMapFormatGenericXML._tree_to_string | def _tree_to_string(cls, root_element, xml_declaration=True, pretty_print=True):
"""
Return an ``lxml`` tree as a Unicode string.
"""
from lxml import etree
return gf.safe_unicode(etree.tostring(
root_element,
encoding="UTF-8",
method="xml",
xml_declaration=xml_declaration,
pretty_print=pretty_print
)) | python | def _tree_to_string(cls, root_element, xml_declaration=True, pretty_print=True):
from lxml import etree
return gf.safe_unicode(etree.tostring(
root_element,
encoding="UTF-8",
method="xml",
xml_declaration=xml_declaration,
pretty_print=pretty_print
)) | [
"def",
"_tree_to_string",
"(",
"cls",
",",
"root_element",
",",
"xml_declaration",
"=",
"True",
",",
"pretty_print",
"=",
"True",
")",
":",
"from",
"lxml",
"import",
"etree",
"return",
"gf",
".",
"safe_unicode",
"(",
"etree",
".",
"tostring",
"(",
"root_elem... | Return an ``lxml`` tree as a Unicode string. | [
"Return",
"an",
"lxml",
"tree",
"as",
"a",
"Unicode",
"string",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/syncmap/smfgxml.py#L63-L74 |
245,908 | readbeyond/aeneas | aeneas/tools/abstract_cli_program.py | AbstractCLIProgram.print_generic | def print_generic(self, msg, prefix=None):
"""
Print a message and log it.
:param msg: the message
:type msg: Unicode string
:param prefix: the (optional) prefix
:type prefix: Unicode string
"""
if prefix is None:
self._log(msg, Logger.INFO)
else:
self._log(msg, prefix)
if self.use_sys:
if (prefix is not None) and (prefix in self.PREFIX_TO_PRINT_FUNCTION):
self.PREFIX_TO_PRINT_FUNCTION[prefix](msg)
else:
gf.safe_print(msg) | python | def print_generic(self, msg, prefix=None):
if prefix is None:
self._log(msg, Logger.INFO)
else:
self._log(msg, prefix)
if self.use_sys:
if (prefix is not None) and (prefix in self.PREFIX_TO_PRINT_FUNCTION):
self.PREFIX_TO_PRINT_FUNCTION[prefix](msg)
else:
gf.safe_print(msg) | [
"def",
"print_generic",
"(",
"self",
",",
"msg",
",",
"prefix",
"=",
"None",
")",
":",
"if",
"prefix",
"is",
"None",
":",
"self",
".",
"_log",
"(",
"msg",
",",
"Logger",
".",
"INFO",
")",
"else",
":",
"self",
".",
"_log",
"(",
"msg",
",",
"prefix... | Print a message and log it.
:param msg: the message
:type msg: Unicode string
:param prefix: the (optional) prefix
:type prefix: Unicode string | [
"Print",
"a",
"message",
"and",
"log",
"it",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/abstract_cli_program.py#L109-L126 |
245,909 | readbeyond/aeneas | aeneas/tools/abstract_cli_program.py | AbstractCLIProgram.print_name_version | def print_name_version(self):
"""
Print program name and version and exit.
:rtype: int
"""
if self.use_sys:
self.print_generic(u"%s v%s" % (self.NAME, aeneas_version))
return self.exit(self.HELP_EXIT_CODE) | python | def print_name_version(self):
if self.use_sys:
self.print_generic(u"%s v%s" % (self.NAME, aeneas_version))
return self.exit(self.HELP_EXIT_CODE) | [
"def",
"print_name_version",
"(",
"self",
")",
":",
"if",
"self",
".",
"use_sys",
":",
"self",
".",
"print_generic",
"(",
"u\"%s v%s\"",
"%",
"(",
"self",
".",
"NAME",
",",
"aeneas_version",
")",
")",
"return",
"self",
".",
"exit",
"(",
"self",
".",
"H... | Print program name and version and exit.
:rtype: int | [
"Print",
"program",
"name",
"and",
"version",
"and",
"exit",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/abstract_cli_program.py#L260-L268 |
245,910 | readbeyond/aeneas | aeneas/tools/abstract_cli_program.py | AbstractCLIProgram.print_rconf_parameters | def print_rconf_parameters(self):
"""
Print the list of runtime configuration parameters and exit.
"""
if self.use_sys:
self.print_info(u"Available runtime configuration parameters:")
self.print_generic(u"\n" + u"\n".join(self.RCONF_PARAMETERS) + u"\n")
return self.exit(self.HELP_EXIT_CODE) | python | def print_rconf_parameters(self):
if self.use_sys:
self.print_info(u"Available runtime configuration parameters:")
self.print_generic(u"\n" + u"\n".join(self.RCONF_PARAMETERS) + u"\n")
return self.exit(self.HELP_EXIT_CODE) | [
"def",
"print_rconf_parameters",
"(",
"self",
")",
":",
"if",
"self",
".",
"use_sys",
":",
"self",
".",
"print_info",
"(",
"u\"Available runtime configuration parameters:\"",
")",
"self",
".",
"print_generic",
"(",
"u\"\\n\"",
"+",
"u\"\\n\"",
".",
"join",
"(",
... | Print the list of runtime configuration parameters and exit. | [
"Print",
"the",
"list",
"of",
"runtime",
"configuration",
"parameters",
"and",
"exit",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/abstract_cli_program.py#L270-L277 |
245,911 | readbeyond/aeneas | aeneas/tools/abstract_cli_program.py | AbstractCLIProgram.has_option | def has_option(self, target):
"""
Return ``True`` if the actual arguments include
the specified ``target`` option or,
if ``target`` is a list of options,
at least one of them.
:param target: the option or a list of options
:type target: Unicode string or list of Unicode strings
:rtype: bool
"""
if isinstance(target, list):
target_set = set(target)
else:
target_set = set([target])
return len(target_set & set(self.actual_arguments)) > 0 | python | def has_option(self, target):
if isinstance(target, list):
target_set = set(target)
else:
target_set = set([target])
return len(target_set & set(self.actual_arguments)) > 0 | [
"def",
"has_option",
"(",
"self",
",",
"target",
")",
":",
"if",
"isinstance",
"(",
"target",
",",
"list",
")",
":",
"target_set",
"=",
"set",
"(",
"target",
")",
"else",
":",
"target_set",
"=",
"set",
"(",
"[",
"target",
"]",
")",
"return",
"len",
... | Return ``True`` if the actual arguments include
the specified ``target`` option or,
if ``target`` is a list of options,
at least one of them.
:param target: the option or a list of options
:type target: Unicode string or list of Unicode strings
:rtype: bool | [
"Return",
"True",
"if",
"the",
"actual",
"arguments",
"include",
"the",
"specified",
"target",
"option",
"or",
"if",
"target",
"is",
"a",
"list",
"of",
"options",
"at",
"least",
"one",
"of",
"them",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/abstract_cli_program.py#L387-L402 |
245,912 | readbeyond/aeneas | aeneas/tools/abstract_cli_program.py | AbstractCLIProgram.check_c_extensions | def check_c_extensions(self, name=None):
"""
If C extensions cannot be run, emit a warning
and return ``False``. Otherwise return ``True``.
If ``name`` is not ``None``, check just
the C extension with that name.
:param name: the name of the Python C extension to test
:type name: string
:rtype: bool
"""
if not gf.can_run_c_extension(name=name):
if name is None:
self.print_warning(u"Unable to load Python C Extensions")
else:
self.print_warning(u"Unable to load Python C Extension %s" % (name))
self.print_warning(u"Running the slower pure Python code")
self.print_warning(u"See the documentation for directions to compile the Python C Extensions")
return False
return True | python | def check_c_extensions(self, name=None):
if not gf.can_run_c_extension(name=name):
if name is None:
self.print_warning(u"Unable to load Python C Extensions")
else:
self.print_warning(u"Unable to load Python C Extension %s" % (name))
self.print_warning(u"Running the slower pure Python code")
self.print_warning(u"See the documentation for directions to compile the Python C Extensions")
return False
return True | [
"def",
"check_c_extensions",
"(",
"self",
",",
"name",
"=",
"None",
")",
":",
"if",
"not",
"gf",
".",
"can_run_c_extension",
"(",
"name",
"=",
"name",
")",
":",
"if",
"name",
"is",
"None",
":",
"self",
".",
"print_warning",
"(",
"u\"Unable to load Python C... | If C extensions cannot be run, emit a warning
and return ``False``. Otherwise return ``True``.
If ``name`` is not ``None``, check just
the C extension with that name.
:param name: the name of the Python C extension to test
:type name: string
:rtype: bool | [
"If",
"C",
"extensions",
"cannot",
"be",
"run",
"emit",
"a",
"warning",
"and",
"return",
"False",
".",
"Otherwise",
"return",
"True",
".",
"If",
"name",
"is",
"not",
"None",
"check",
"just",
"the",
"C",
"extension",
"with",
"that",
"name",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/abstract_cli_program.py#L437-L456 |
245,913 | readbeyond/aeneas | aeneas/tools/abstract_cli_program.py | AbstractCLIProgram.check_output_file | def check_output_file(self, path):
"""
If the given path cannot be written, emit an error
and return ``False``. Otherwise return ``True``.
:param path: the path of the output file
:type path: string (path)
:rtype: bool
"""
if not gf.file_can_be_written(path):
self.print_error(u"Unable to create file '%s'" % (path))
self.print_error(u"Make sure the file path is written/escaped correctly and that you have write permission on it")
return False
return True | python | def check_output_file(self, path):
if not gf.file_can_be_written(path):
self.print_error(u"Unable to create file '%s'" % (path))
self.print_error(u"Make sure the file path is written/escaped correctly and that you have write permission on it")
return False
return True | [
"def",
"check_output_file",
"(",
"self",
",",
"path",
")",
":",
"if",
"not",
"gf",
".",
"file_can_be_written",
"(",
"path",
")",
":",
"self",
".",
"print_error",
"(",
"u\"Unable to create file '%s'\"",
"%",
"(",
"path",
")",
")",
"self",
".",
"print_error",
... | If the given path cannot be written, emit an error
and return ``False``. Otherwise return ``True``.
:param path: the path of the output file
:type path: string (path)
:rtype: bool | [
"If",
"the",
"given",
"path",
"cannot",
"be",
"written",
"emit",
"an",
"error",
"and",
"return",
"False",
".",
"Otherwise",
"return",
"True",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/abstract_cli_program.py#L488-L501 |
245,914 | readbeyond/aeneas | aeneas/tools/abstract_cli_program.py | AbstractCLIProgram.check_output_directory | def check_output_directory(self, path):
"""
If the given directory cannot be written, emit an error
and return ``False``. Otherwise return ``True``.
:param path: the path of the output directory
:type path: string (path)
:rtype: bool
"""
if not os.path.isdir(path):
self.print_error(u"Directory '%s' does not exist" % (path))
return False
test_file = os.path.join(path, u"file.test")
if not gf.file_can_be_written(test_file):
self.print_error(u"Unable to write inside directory '%s'" % (path))
self.print_error(u"Make sure the directory path is written/escaped correctly and that you have write permission on it")
return False
return True | python | def check_output_directory(self, path):
if not os.path.isdir(path):
self.print_error(u"Directory '%s' does not exist" % (path))
return False
test_file = os.path.join(path, u"file.test")
if not gf.file_can_be_written(test_file):
self.print_error(u"Unable to write inside directory '%s'" % (path))
self.print_error(u"Make sure the directory path is written/escaped correctly and that you have write permission on it")
return False
return True | [
"def",
"check_output_directory",
"(",
"self",
",",
"path",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"isdir",
"(",
"path",
")",
":",
"self",
".",
"print_error",
"(",
"u\"Directory '%s' does not exist\"",
"%",
"(",
"path",
")",
")",
"return",
"False",
... | If the given directory cannot be written, emit an error
and return ``False``. Otherwise return ``True``.
:param path: the path of the output directory
:type path: string (path)
:rtype: bool | [
"If",
"the",
"given",
"directory",
"cannot",
"be",
"written",
"emit",
"an",
"error",
"and",
"return",
"False",
".",
"Otherwise",
"return",
"True",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/abstract_cli_program.py#L503-L520 |
245,915 | readbeyond/aeneas | aeneas/container.py | Container.is_safe | def is_safe(self):
"""
Return ``True`` if the container can be safely extracted,
that is, if all its entries are safe, ``False`` otherwise.
:rtype: bool
:raises: same as :func:`~aeneas.container.Container.entries`
"""
self.log(u"Checking if this container is safe")
for entry in self.entries:
if not self.is_entry_safe(entry):
self.log([u"This container is not safe: found unsafe entry '%s'", entry])
return False
self.log(u"This container is safe")
return True | python | def is_safe(self):
self.log(u"Checking if this container is safe")
for entry in self.entries:
if not self.is_entry_safe(entry):
self.log([u"This container is not safe: found unsafe entry '%s'", entry])
return False
self.log(u"This container is safe")
return True | [
"def",
"is_safe",
"(",
"self",
")",
":",
"self",
".",
"log",
"(",
"u\"Checking if this container is safe\"",
")",
"for",
"entry",
"in",
"self",
".",
"entries",
":",
"if",
"not",
"self",
".",
"is_entry_safe",
"(",
"entry",
")",
":",
"self",
".",
"log",
"(... | Return ``True`` if the container can be safely extracted,
that is, if all its entries are safe, ``False`` otherwise.
:rtype: bool
:raises: same as :func:`~aeneas.container.Container.entries` | [
"Return",
"True",
"if",
"the",
"container",
"can",
"be",
"safely",
"extracted",
"that",
"is",
"if",
"all",
"its",
"entries",
"are",
"safe",
"False",
"otherwise",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/container.py#L186-L200 |
245,916 | readbeyond/aeneas | aeneas/container.py | Container.entries | def entries(self):
"""
Return the sorted list of entries in this container,
each represented by its full path inside the container.
:rtype: list of strings (path)
:raises: TypeError: if this container does not exist
:raises: OSError: if an error occurred reading the given container
(e.g., empty file, damaged file, etc.)
"""
self.log(u"Getting entries")
if not self.exists():
self.log_exc(u"This container does not exist. Wrong path?", None, True, TypeError)
if self.actual_container is None:
self.log_exc(u"The actual container object has not been set", None, True, TypeError)
return self.actual_container.entries | python | def entries(self):
self.log(u"Getting entries")
if not self.exists():
self.log_exc(u"This container does not exist. Wrong path?", None, True, TypeError)
if self.actual_container is None:
self.log_exc(u"The actual container object has not been set", None, True, TypeError)
return self.actual_container.entries | [
"def",
"entries",
"(",
"self",
")",
":",
"self",
".",
"log",
"(",
"u\"Getting entries\"",
")",
"if",
"not",
"self",
".",
"exists",
"(",
")",
":",
"self",
".",
"log_exc",
"(",
"u\"This container does not exist. Wrong path?\"",
",",
"None",
",",
"True",
",",
... | Return the sorted list of entries in this container,
each represented by its full path inside the container.
:rtype: list of strings (path)
:raises: TypeError: if this container does not exist
:raises: OSError: if an error occurred reading the given container
(e.g., empty file, damaged file, etc.) | [
"Return",
"the",
"sorted",
"list",
"of",
"entries",
"in",
"this",
"container",
"each",
"represented",
"by",
"its",
"full",
"path",
"inside",
"the",
"container",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/container.py#L218-L233 |
245,917 | readbeyond/aeneas | aeneas/container.py | Container.find_entry | def find_entry(self, entry, exact=True):
"""
Return the full path to the first entry whose file name equals
the given ``entry`` path.
Return ``None`` if the entry cannot be found.
If ``exact`` is ``True``, the path must be exact,
otherwise the comparison is done only on the file name.
Example: ::
entry = "config.txt"
matches: ::
config.txt (if exact == True or exact == False)
foo/config.txt (if exact == False)
foo/bar/config.txt (if exact == False)
:param string entry: the entry name to be searched for
:param bool exact: look for the exact entry path
:rtype: string
:raises: same as :func:`~aeneas.container.Container.entries`
"""
if exact:
self.log([u"Finding entry '%s' with exact=True", entry])
if entry in self.entries:
self.log([u"Found entry '%s'", entry])
return entry
else:
self.log([u"Finding entry '%s' with exact=False", entry])
for ent in self.entries:
if os.path.basename(ent) == entry:
self.log([u"Found entry '%s'", ent])
return ent
self.log([u"Entry '%s' not found", entry])
return None | python | def find_entry(self, entry, exact=True):
if exact:
self.log([u"Finding entry '%s' with exact=True", entry])
if entry in self.entries:
self.log([u"Found entry '%s'", entry])
return entry
else:
self.log([u"Finding entry '%s' with exact=False", entry])
for ent in self.entries:
if os.path.basename(ent) == entry:
self.log([u"Found entry '%s'", ent])
return ent
self.log([u"Entry '%s' not found", entry])
return None | [
"def",
"find_entry",
"(",
"self",
",",
"entry",
",",
"exact",
"=",
"True",
")",
":",
"if",
"exact",
":",
"self",
".",
"log",
"(",
"[",
"u\"Finding entry '%s' with exact=True\"",
",",
"entry",
"]",
")",
"if",
"entry",
"in",
"self",
".",
"entries",
":",
... | Return the full path to the first entry whose file name equals
the given ``entry`` path.
Return ``None`` if the entry cannot be found.
If ``exact`` is ``True``, the path must be exact,
otherwise the comparison is done only on the file name.
Example: ::
entry = "config.txt"
matches: ::
config.txt (if exact == True or exact == False)
foo/config.txt (if exact == False)
foo/bar/config.txt (if exact == False)
:param string entry: the entry name to be searched for
:param bool exact: look for the exact entry path
:rtype: string
:raises: same as :func:`~aeneas.container.Container.entries` | [
"Return",
"the",
"full",
"path",
"to",
"the",
"first",
"entry",
"whose",
"file",
"name",
"equals",
"the",
"given",
"entry",
"path",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/container.py#L235-L272 |
245,918 | readbeyond/aeneas | aeneas/container.py | Container.read_entry | def read_entry(self, entry):
"""
Read the contents of an entry in this container,
and return them as a byte string.
Return ``None`` if the entry is not safe
or it cannot be found.
:rtype: byte string
:raises: same as :func:`~aeneas.container.Container.entries`
"""
if not self.is_entry_safe(entry):
self.log([u"Accessing entry '%s' is not safe", entry])
return None
if entry not in self.entries:
self.log([u"Entry '%s' not found in this container", entry])
return None
self.log([u"Reading contents of entry '%s'", entry])
try:
return self.actual_container.read_entry(entry)
except:
self.log([u"An error occurred while reading the contents of '%s'", entry])
return None | python | def read_entry(self, entry):
if not self.is_entry_safe(entry):
self.log([u"Accessing entry '%s' is not safe", entry])
return None
if entry not in self.entries:
self.log([u"Entry '%s' not found in this container", entry])
return None
self.log([u"Reading contents of entry '%s'", entry])
try:
return self.actual_container.read_entry(entry)
except:
self.log([u"An error occurred while reading the contents of '%s'", entry])
return None | [
"def",
"read_entry",
"(",
"self",
",",
"entry",
")",
":",
"if",
"not",
"self",
".",
"is_entry_safe",
"(",
"entry",
")",
":",
"self",
".",
"log",
"(",
"[",
"u\"Accessing entry '%s' is not safe\"",
",",
"entry",
"]",
")",
"return",
"None",
"if",
"entry",
"... | Read the contents of an entry in this container,
and return them as a byte string.
Return ``None`` if the entry is not safe
or it cannot be found.
:rtype: byte string
:raises: same as :func:`~aeneas.container.Container.entries` | [
"Read",
"the",
"contents",
"of",
"an",
"entry",
"in",
"this",
"container",
"and",
"return",
"them",
"as",
"a",
"byte",
"string",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/container.py#L274-L298 |
245,919 | readbeyond/aeneas | aeneas/container.py | Container.decompress | def decompress(self, output_path):
"""
Decompress the entire container into the given directory.
:param string output_path: path of the destination directory
:raises: TypeError: if this container does not exist
:raises: ValueError: if this container contains unsafe entries,
or ``output_path`` is not an existing directory
:raises: OSError: if an error occurred decompressing the given container
(e.g., empty file, damaged file, etc.)
"""
self.log([u"Decompressing the container into '%s'", output_path])
if not self.exists():
self.log_exc(u"This container does not exist. Wrong path?", None, True, TypeError)
if self.actual_container is None:
self.log_exc(u"The actual container object has not been set", None, True, TypeError)
if not gf.directory_exists(output_path):
self.log_exc(u"The output path is not an existing directory", None, True, ValueError)
if not self.is_safe:
self.log_exc(u"This container contains unsafe entries", None, True, ValueError)
self.actual_container.decompress(output_path) | python | def decompress(self, output_path):
self.log([u"Decompressing the container into '%s'", output_path])
if not self.exists():
self.log_exc(u"This container does not exist. Wrong path?", None, True, TypeError)
if self.actual_container is None:
self.log_exc(u"The actual container object has not been set", None, True, TypeError)
if not gf.directory_exists(output_path):
self.log_exc(u"The output path is not an existing directory", None, True, ValueError)
if not self.is_safe:
self.log_exc(u"This container contains unsafe entries", None, True, ValueError)
self.actual_container.decompress(output_path) | [
"def",
"decompress",
"(",
"self",
",",
"output_path",
")",
":",
"self",
".",
"log",
"(",
"[",
"u\"Decompressing the container into '%s'\"",
",",
"output_path",
"]",
")",
"if",
"not",
"self",
".",
"exists",
"(",
")",
":",
"self",
".",
"log_exc",
"(",
"u\"Th... | Decompress the entire container into the given directory.
:param string output_path: path of the destination directory
:raises: TypeError: if this container does not exist
:raises: ValueError: if this container contains unsafe entries,
or ``output_path`` is not an existing directory
:raises: OSError: if an error occurred decompressing the given container
(e.g., empty file, damaged file, etc.) | [
"Decompress",
"the",
"entire",
"container",
"into",
"the",
"given",
"directory",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/container.py#L300-L320 |
245,920 | readbeyond/aeneas | aeneas/container.py | Container.compress | def compress(self, input_path):
"""
Compress the contents of the given directory.
:param string input_path: path of the input directory
:raises: TypeError: if the container path has not been set
:raises: ValueError: if ``input_path`` is not an existing directory
:raises: OSError: if an error occurred compressing the given container
(e.g., empty file, damaged file, etc.)
"""
self.log([u"Compressing '%s' into this container", input_path])
if self.file_path is None:
self.log_exc(u"The container path has not been set", None, True, TypeError)
if self.actual_container is None:
self.log_exc(u"The actual container object has not been set", None, True, TypeError)
if not gf.directory_exists(input_path):
self.log_exc(u"The input path is not an existing directory", None, True, ValueError)
gf.ensure_parent_directory(input_path)
self.actual_container.compress(input_path) | python | def compress(self, input_path):
self.log([u"Compressing '%s' into this container", input_path])
if self.file_path is None:
self.log_exc(u"The container path has not been set", None, True, TypeError)
if self.actual_container is None:
self.log_exc(u"The actual container object has not been set", None, True, TypeError)
if not gf.directory_exists(input_path):
self.log_exc(u"The input path is not an existing directory", None, True, ValueError)
gf.ensure_parent_directory(input_path)
self.actual_container.compress(input_path) | [
"def",
"compress",
"(",
"self",
",",
"input_path",
")",
":",
"self",
".",
"log",
"(",
"[",
"u\"Compressing '%s' into this container\"",
",",
"input_path",
"]",
")",
"if",
"self",
".",
"file_path",
"is",
"None",
":",
"self",
".",
"log_exc",
"(",
"u\"The conta... | Compress the contents of the given directory.
:param string input_path: path of the input directory
:raises: TypeError: if the container path has not been set
:raises: ValueError: if ``input_path`` is not an existing directory
:raises: OSError: if an error occurred compressing the given container
(e.g., empty file, damaged file, etc.) | [
"Compress",
"the",
"contents",
"of",
"the",
"given",
"directory",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/container.py#L322-L341 |
245,921 | readbeyond/aeneas | aeneas/container.py | Container.exists | def exists(self):
"""
Return ``True`` if the container has its path set and it exists,
``False`` otherwise.
:rtype: boolean
"""
return gf.file_exists(self.file_path) or gf.directory_exists(self.file_path) | python | def exists(self):
return gf.file_exists(self.file_path) or gf.directory_exists(self.file_path) | [
"def",
"exists",
"(",
"self",
")",
":",
"return",
"gf",
".",
"file_exists",
"(",
"self",
".",
"file_path",
")",
"or",
"gf",
".",
"directory_exists",
"(",
"self",
".",
"file_path",
")"
] | Return ``True`` if the container has its path set and it exists,
``False`` otherwise.
:rtype: boolean | [
"Return",
"True",
"if",
"the",
"container",
"has",
"its",
"path",
"set",
"and",
"it",
"exists",
"False",
"otherwise",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/container.py#L343-L350 |
245,922 | readbeyond/aeneas | aeneas/container.py | Container._set_actual_container | def _set_actual_container(self):
"""
Set the actual container, based on the specified container format.
If the container format is not specified,
infer it from the (lowercased) extension of the file path.
If the format cannot be inferred, it is assumed to be
of type :class:`~aeneas.container.ContainerFormat.UNPACKED`
(unpacked directory).
"""
# infer container format
if self.container_format is None:
self.log(u"Inferring actual container format...")
path_lowercased = self.file_path.lower()
self.log([u"Lowercased file path: '%s'", path_lowercased])
self.container_format = ContainerFormat.UNPACKED
for fmt in ContainerFormat.ALLOWED_FILE_VALUES:
if path_lowercased.endswith(fmt):
self.container_format = fmt
break
self.log(u"Inferring actual container format... done")
self.log([u"Inferred format: '%s'", self.container_format])
# set the actual container
self.log(u"Setting actual container...")
class_map = {
ContainerFormat.ZIP: (_ContainerZIP, None),
ContainerFormat.EPUB: (_ContainerZIP, None),
ContainerFormat.TAR: (_ContainerTAR, ""),
ContainerFormat.TAR_GZ: (_ContainerTAR, ":gz"),
ContainerFormat.TAR_BZ2: (_ContainerTAR, ":bz2"),
ContainerFormat.UNPACKED: (_ContainerUnpacked, None)
}
actual_class, variant = class_map[self.container_format]
self.actual_container = actual_class(
file_path=self.file_path,
variant=variant,
rconf=self.rconf,
logger=self.logger
)
self.log([u"Actual container format: '%s'", self.container_format])
self.log(u"Setting actual container... done") | python | def _set_actual_container(self):
# infer container format
if self.container_format is None:
self.log(u"Inferring actual container format...")
path_lowercased = self.file_path.lower()
self.log([u"Lowercased file path: '%s'", path_lowercased])
self.container_format = ContainerFormat.UNPACKED
for fmt in ContainerFormat.ALLOWED_FILE_VALUES:
if path_lowercased.endswith(fmt):
self.container_format = fmt
break
self.log(u"Inferring actual container format... done")
self.log([u"Inferred format: '%s'", self.container_format])
# set the actual container
self.log(u"Setting actual container...")
class_map = {
ContainerFormat.ZIP: (_ContainerZIP, None),
ContainerFormat.EPUB: (_ContainerZIP, None),
ContainerFormat.TAR: (_ContainerTAR, ""),
ContainerFormat.TAR_GZ: (_ContainerTAR, ":gz"),
ContainerFormat.TAR_BZ2: (_ContainerTAR, ":bz2"),
ContainerFormat.UNPACKED: (_ContainerUnpacked, None)
}
actual_class, variant = class_map[self.container_format]
self.actual_container = actual_class(
file_path=self.file_path,
variant=variant,
rconf=self.rconf,
logger=self.logger
)
self.log([u"Actual container format: '%s'", self.container_format])
self.log(u"Setting actual container... done") | [
"def",
"_set_actual_container",
"(",
"self",
")",
":",
"# infer container format",
"if",
"self",
".",
"container_format",
"is",
"None",
":",
"self",
".",
"log",
"(",
"u\"Inferring actual container format...\"",
")",
"path_lowercased",
"=",
"self",
".",
"file_path",
... | Set the actual container, based on the specified container format.
If the container format is not specified,
infer it from the (lowercased) extension of the file path.
If the format cannot be inferred, it is assumed to be
of type :class:`~aeneas.container.ContainerFormat.UNPACKED`
(unpacked directory). | [
"Set",
"the",
"actual",
"container",
"based",
"on",
"the",
"specified",
"container",
"format",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/container.py#L352-L393 |
245,923 | readbeyond/aeneas | aeneas/extra/ctw_speect.py | CustomTTSWrapper._synthesize_single_python_helper | def _synthesize_single_python_helper(
self,
text,
voice_code,
output_file_path=None,
return_audio_data=True
):
"""
This is an helper function to synthesize a single text fragment via a Python call.
If ``output_file_path`` is ``None``,
the audio data will not persist to file at the end of the method.
:rtype: tuple (result, (duration, sample_rate, encoding, data))
"""
# return zero if text is the empty string
if len(text) == 0:
#
# NOTE values of sample_rate, encoding, data
# do not matter if the duration is 0.000,
# so set them to None instead of the more precise:
# return (True, (TimeValue("0.000"), 16000, "pcm_s16le", numpy.array([])))
#
self.log(u"len(text) is zero: returning 0.000")
return (True, (TimeValue("0.000"), None, None, None))
#
# NOTE in this example, we assume that the Speect voice data files
# are located in the same directory of this .py source file
# and that the voice JSON file is called "voice.json"
#
# NOTE the voice_code value is ignored in this example,
# since we have only one TTS voice,
# but in general one might select a voice file to load,
# depending on voice_code;
# in fact, we could have created the ``voice`` object
# only once, in the constructor, instead of creating it
# each time this function is invoked,
# achieving slightly faster synthesis
#
voice_json_path = gf.safe_str(gf.absolute_path("voice.json", __file__))
voice = speect.SVoice(voice_json_path)
utt = voice.synth(text)
audio = utt.features["audio"]
if output_file_path is None:
self.log(u"output_file_path is None => not saving to file")
else:
self.log(u"output_file_path is not None => saving to file...")
# NOTE apparently, save_riff needs the path to be a byte string
audio.save_riff(gf.safe_str(output_file_path))
self.log(u"output_file_path is not None => saving to file... done")
# return immediately if returning audio data is not needed
if not return_audio_data:
self.log(u"return_audio_data is True => return immediately")
return (True, None)
# get length and data using speect Python API
self.log(u"return_audio_data is True => read and return audio data")
waveform = audio.get_audio_waveform()
audio_sample_rate = int(waveform["samplerate"])
audio_length = TimeValue(audio.num_samples() / audio_sample_rate)
audio_format = "pcm16"
audio_samples = numpy.fromstring(
waveform["samples"],
dtype=numpy.int16
).astype("float64") / 32768
return (True, (
audio_length,
audio_sample_rate,
audio_format,
audio_samples
)) | python | def _synthesize_single_python_helper(
self,
text,
voice_code,
output_file_path=None,
return_audio_data=True
):
# return zero if text is the empty string
if len(text) == 0:
#
# NOTE values of sample_rate, encoding, data
# do not matter if the duration is 0.000,
# so set them to None instead of the more precise:
# return (True, (TimeValue("0.000"), 16000, "pcm_s16le", numpy.array([])))
#
self.log(u"len(text) is zero: returning 0.000")
return (True, (TimeValue("0.000"), None, None, None))
#
# NOTE in this example, we assume that the Speect voice data files
# are located in the same directory of this .py source file
# and that the voice JSON file is called "voice.json"
#
# NOTE the voice_code value is ignored in this example,
# since we have only one TTS voice,
# but in general one might select a voice file to load,
# depending on voice_code;
# in fact, we could have created the ``voice`` object
# only once, in the constructor, instead of creating it
# each time this function is invoked,
# achieving slightly faster synthesis
#
voice_json_path = gf.safe_str(gf.absolute_path("voice.json", __file__))
voice = speect.SVoice(voice_json_path)
utt = voice.synth(text)
audio = utt.features["audio"]
if output_file_path is None:
self.log(u"output_file_path is None => not saving to file")
else:
self.log(u"output_file_path is not None => saving to file...")
# NOTE apparently, save_riff needs the path to be a byte string
audio.save_riff(gf.safe_str(output_file_path))
self.log(u"output_file_path is not None => saving to file... done")
# return immediately if returning audio data is not needed
if not return_audio_data:
self.log(u"return_audio_data is True => return immediately")
return (True, None)
# get length and data using speect Python API
self.log(u"return_audio_data is True => read and return audio data")
waveform = audio.get_audio_waveform()
audio_sample_rate = int(waveform["samplerate"])
audio_length = TimeValue(audio.num_samples() / audio_sample_rate)
audio_format = "pcm16"
audio_samples = numpy.fromstring(
waveform["samples"],
dtype=numpy.int16
).astype("float64") / 32768
return (True, (
audio_length,
audio_sample_rate,
audio_format,
audio_samples
)) | [
"def",
"_synthesize_single_python_helper",
"(",
"self",
",",
"text",
",",
"voice_code",
",",
"output_file_path",
"=",
"None",
",",
"return_audio_data",
"=",
"True",
")",
":",
"# return zero if text is the empty string",
"if",
"len",
"(",
"text",
")",
"==",
"0",
":... | This is an helper function to synthesize a single text fragment via a Python call.
If ``output_file_path`` is ``None``,
the audio data will not persist to file at the end of the method.
:rtype: tuple (result, (duration, sample_rate, encoding, data)) | [
"This",
"is",
"an",
"helper",
"function",
"to",
"synthesize",
"a",
"single",
"text",
"fragment",
"via",
"a",
"Python",
"call",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/extra/ctw_speect.py#L91-L163 |
245,924 | readbeyond/aeneas | aeneas/analyzecontainer.py | AnalyzeContainer.analyze | def analyze(self, config_string=None):
"""
Analyze the given container and
return the corresponding job object.
On error, it will return ``None``.
:param string config_string: the configuration string generated by wizard
:rtype: :class:`~aeneas.job.Job` or ``None``
"""
try:
if config_string is not None:
self.log(u"Analyzing container with the given config string")
return self._analyze_txt_config(config_string=config_string)
elif self.container.has_config_xml:
self.log(u"Analyzing container with XML config file")
return self._analyze_xml_config(config_contents=None)
elif self.container.has_config_txt:
self.log(u"Analyzing container with TXT config file")
return self._analyze_txt_config(config_string=None)
else:
self.log(u"No configuration file in this container, returning None")
except (OSError, KeyError, TypeError) as exc:
self.log_exc(u"An unexpected error occurred while analyzing", exc, True, None)
return None | python | def analyze(self, config_string=None):
try:
if config_string is not None:
self.log(u"Analyzing container with the given config string")
return self._analyze_txt_config(config_string=config_string)
elif self.container.has_config_xml:
self.log(u"Analyzing container with XML config file")
return self._analyze_xml_config(config_contents=None)
elif self.container.has_config_txt:
self.log(u"Analyzing container with TXT config file")
return self._analyze_txt_config(config_string=None)
else:
self.log(u"No configuration file in this container, returning None")
except (OSError, KeyError, TypeError) as exc:
self.log_exc(u"An unexpected error occurred while analyzing", exc, True, None)
return None | [
"def",
"analyze",
"(",
"self",
",",
"config_string",
"=",
"None",
")",
":",
"try",
":",
"if",
"config_string",
"is",
"not",
"None",
":",
"self",
".",
"log",
"(",
"u\"Analyzing container with the given config string\"",
")",
"return",
"self",
".",
"_analyze_txt_c... | Analyze the given container and
return the corresponding job object.
On error, it will return ``None``.
:param string config_string: the configuration string generated by wizard
:rtype: :class:`~aeneas.job.Job` or ``None`` | [
"Analyze",
"the",
"given",
"container",
"and",
"return",
"the",
"corresponding",
"job",
"object",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/analyzecontainer.py#L72-L96 |
245,925 | readbeyond/aeneas | aeneas/analyzecontainer.py | AnalyzeContainer._create_task | 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 list task_info: the task information: ``[prefix, text_path, audio_path]``
:param string config_string: the configuration string
:param string sync_map_root_directory: the root directory for the sync map files
: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(u"Converting config string to config dict")
parameters = gf.config_string_to_dict(config_string)
self.log(u"Creating task")
task = Task(config_string, logger=self.logger)
task.configuration["description"] = "Task %s" % task_info[0]
self.log([u"Task description: %s", task.configuration["description"]])
try:
task.configuration["language"] = parameters[gc.PPN_TASK_LANGUAGE]
self.log([u"Set language from task: '%s'", task.configuration["language"]])
except KeyError:
task.configuration["language"] = parameters[gc.PPN_JOB_LANGUAGE]
self.log([u"Set language from job: '%s'", task.configuration["language"]])
custom_id = task_info[0]
task.configuration["custom_id"] = custom_id
self.log([u"Task custom_id: %s", task.configuration["custom_id"]])
task.text_file_path = task_info[1]
self.log([u"Task text file path: %s", task.text_file_path])
task.audio_file_path = task_info[2]
self.log([u"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["o_name"]
)
self.log([u"Task sync map file path: %s", task.sync_map_file_path])
self.log(u"Replacing placeholder in os_file_smil_audio_ref")
task.configuration["o_smil_audio_ref"] = self._replace_placeholder(
task.configuration["o_smil_audio_ref"],
custom_id
)
self.log(u"Replacing placeholder in os_file_smil_page_ref")
task.configuration["o_smil_page_ref"] = self._replace_placeholder(
task.configuration["o_smil_page_ref"],
custom_id
)
self.log(u"Returning task")
return task | python | def _create_task(
self,
task_info,
config_string,
sync_map_root_directory,
job_os_hierarchy_type
):
self.log(u"Converting config string to config dict")
parameters = gf.config_string_to_dict(config_string)
self.log(u"Creating task")
task = Task(config_string, logger=self.logger)
task.configuration["description"] = "Task %s" % task_info[0]
self.log([u"Task description: %s", task.configuration["description"]])
try:
task.configuration["language"] = parameters[gc.PPN_TASK_LANGUAGE]
self.log([u"Set language from task: '%s'", task.configuration["language"]])
except KeyError:
task.configuration["language"] = parameters[gc.PPN_JOB_LANGUAGE]
self.log([u"Set language from job: '%s'", task.configuration["language"]])
custom_id = task_info[0]
task.configuration["custom_id"] = custom_id
self.log([u"Task custom_id: %s", task.configuration["custom_id"]])
task.text_file_path = task_info[1]
self.log([u"Task text file path: %s", task.text_file_path])
task.audio_file_path = task_info[2]
self.log([u"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["o_name"]
)
self.log([u"Task sync map file path: %s", task.sync_map_file_path])
self.log(u"Replacing placeholder in os_file_smil_audio_ref")
task.configuration["o_smil_audio_ref"] = self._replace_placeholder(
task.configuration["o_smil_audio_ref"],
custom_id
)
self.log(u"Replacing placeholder in os_file_smil_page_ref")
task.configuration["o_smil_page_ref"] = self._replace_placeholder(
task.configuration["o_smil_page_ref"],
custom_id
)
self.log(u"Returning task")
return task | [
"def",
"_create_task",
"(",
"self",
",",
"task_info",
",",
"config_string",
",",
"sync_map_root_directory",
",",
"job_os_hierarchy_type",
")",
":",
"self",
".",
"log",
"(",
"u\"Converting config string to config dict\"",
")",
"parameters",
"=",
"gf",
".",
"config_stri... | Create a task object from
1. the ``task_info`` found analyzing the container entries, and
2. the given ``config_string``.
:param list task_info: the task information: ``[prefix, text_path, audio_path]``
:param string config_string: the configuration string
:param string sync_map_root_directory: the root directory for the sync map files
:param job_os_hierarchy_type: type of job output hierarchy
:type job_os_hierarchy_type: :class:`~aeneas.hierarchytype.HierarchyType`
:rtype: :class:`~aeneas.task.Task` | [
"Create",
"a",
"task",
"object",
"from"
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/analyzecontainer.py#L330-L388 |
245,926 | readbeyond/aeneas | aeneas/analyzecontainer.py | AnalyzeContainer._compute_sync_map_file_path | def _compute_sync_map_file_path(
self,
root,
hierarchy_type,
custom_id,
file_name
):
"""
Compute the sync map file path inside the output container.
:param string root: the root of the sync map files inside the container
:param job_os_hierarchy_type: type of job output hierarchy
:type job_os_hierarchy_type: :class:`~aeneas.hierarchytype.HierarchyType`
:param string custom_id: the task custom id (flat) or
page directory name (paged)
:param string file_name: the output file name for the sync map
:rtype: string
"""
prefix = root
if hierarchy_type == HierarchyType.PAGED:
prefix = gf.norm_join(prefix, custom_id)
file_name_joined = gf.norm_join(prefix, file_name)
return self._replace_placeholder(file_name_joined, custom_id) | python | def _compute_sync_map_file_path(
self,
root,
hierarchy_type,
custom_id,
file_name
):
prefix = root
if hierarchy_type == HierarchyType.PAGED:
prefix = gf.norm_join(prefix, custom_id)
file_name_joined = gf.norm_join(prefix, file_name)
return self._replace_placeholder(file_name_joined, custom_id) | [
"def",
"_compute_sync_map_file_path",
"(",
"self",
",",
"root",
",",
"hierarchy_type",
",",
"custom_id",
",",
"file_name",
")",
":",
"prefix",
"=",
"root",
"if",
"hierarchy_type",
"==",
"HierarchyType",
".",
"PAGED",
":",
"prefix",
"=",
"gf",
".",
"norm_join",... | Compute the sync map file path inside the output container.
:param string root: the root of the sync map files inside the container
:param job_os_hierarchy_type: type of job output hierarchy
:type job_os_hierarchy_type: :class:`~aeneas.hierarchytype.HierarchyType`
:param string custom_id: the task custom id (flat) or
page directory name (paged)
:param string file_name: the output file name for the sync map
:rtype: string | [
"Compute",
"the",
"sync",
"map",
"file",
"path",
"inside",
"the",
"output",
"container",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/analyzecontainer.py#L403-L425 |
245,927 | readbeyond/aeneas | aeneas/analyzecontainer.py | AnalyzeContainer._find_files | def _find_files(self, entries, root, relative_path, file_name_regex):
"""
Return the elements in entries that
1. are in ``root/relative_path``, and
2. match ``file_name_regex``.
:param list entries: the list of entries (file paths) in the container
:param string root: the root directory of the container
:param string relative_path: the relative path in which we must search
:param regex file_name_regex: the regex matching the desired file names
:rtype: list of strings (path)
"""
self.log([u"Finding files within root: '%s'", root])
target = root
if relative_path is not None:
self.log([u"Joining relative path: '%s'", relative_path])
target = gf.norm_join(root, relative_path)
self.log([u"Finding files within target: '%s'", target])
files = []
target_len = len(target)
for entry in entries:
if entry.startswith(target):
self.log([u"Examining entry: '%s'", entry])
entry_suffix = entry[target_len + 1:]
self.log([u"Examining entry suffix: '%s'", entry_suffix])
if re.search(file_name_regex, entry_suffix) is not None:
self.log([u"Match: '%s'", entry])
files.append(entry)
else:
self.log([u"No match: '%s'", entry])
return sorted(files) | python | def _find_files(self, entries, root, relative_path, file_name_regex):
self.log([u"Finding files within root: '%s'", root])
target = root
if relative_path is not None:
self.log([u"Joining relative path: '%s'", relative_path])
target = gf.norm_join(root, relative_path)
self.log([u"Finding files within target: '%s'", target])
files = []
target_len = len(target)
for entry in entries:
if entry.startswith(target):
self.log([u"Examining entry: '%s'", entry])
entry_suffix = entry[target_len + 1:]
self.log([u"Examining entry suffix: '%s'", entry_suffix])
if re.search(file_name_regex, entry_suffix) is not None:
self.log([u"Match: '%s'", entry])
files.append(entry)
else:
self.log([u"No match: '%s'", entry])
return sorted(files) | [
"def",
"_find_files",
"(",
"self",
",",
"entries",
",",
"root",
",",
"relative_path",
",",
"file_name_regex",
")",
":",
"self",
".",
"log",
"(",
"[",
"u\"Finding files within root: '%s'\"",
",",
"root",
"]",
")",
"target",
"=",
"root",
"if",
"relative_path",
... | Return the elements in entries that
1. are in ``root/relative_path``, and
2. match ``file_name_regex``.
:param list entries: the list of entries (file paths) in the container
:param string root: the root directory of the container
:param string relative_path: the relative path in which we must search
:param regex file_name_regex: the regex matching the desired file names
:rtype: list of strings (path) | [
"Return",
"the",
"elements",
"in",
"entries",
"that"
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/analyzecontainer.py#L427-L458 |
245,928 | readbeyond/aeneas | aeneas/analyzecontainer.py | AnalyzeContainer._match_files_flat_hierarchy | def _match_files_flat_hierarchy(self, text_files, audio_files):
"""
Match audio and text files in flat hierarchies.
Two files match if their names,
once removed the file extension,
are the same.
Examples: ::
foo/text/a.txt foo/audio/a.mp3 => match: ["a", "foo/text/a.txt", "foo/audio/a.mp3"]
foo/text/a.txt foo/audio/b.mp3 => no match
foo/res/c.txt foo/res/c.mp3 => match: ["c", "foo/res/c.txt", "foo/res/c.mp3"]
foo/res/d.txt foo/res/e.mp3 => no match
:param list text_files: the entries corresponding to text files
:param list audio_files: the entries corresponding to audio files
:rtype: list of lists (see above)
"""
self.log(u"Matching files in flat hierarchy")
self.log([u"Text files: '%s'", text_files])
self.log([u"Audio files: '%s'", audio_files])
d_text = {}
d_audio = {}
for text_file in text_files:
text_file_no_ext = gf.file_name_without_extension(text_file)
d_text[text_file_no_ext] = text_file
self.log([u"Added text file '%s' to key '%s'", text_file, text_file_no_ext])
for audio_file in audio_files:
audio_file_no_ext = gf.file_name_without_extension(audio_file)
d_audio[audio_file_no_ext] = audio_file
self.log([u"Added audio file '%s' to key '%s'", audio_file, audio_file_no_ext])
tasks = []
for key in d_text.keys():
self.log([u"Examining text key '%s'", key])
if key in d_audio:
self.log([u"Key '%s' is also in audio", key])
tasks.append([key, d_text[key], d_audio[key]])
self.log([u"Added pair ('%s', '%s')", d_text[key], d_audio[key]])
return tasks | python | def _match_files_flat_hierarchy(self, text_files, audio_files):
self.log(u"Matching files in flat hierarchy")
self.log([u"Text files: '%s'", text_files])
self.log([u"Audio files: '%s'", audio_files])
d_text = {}
d_audio = {}
for text_file in text_files:
text_file_no_ext = gf.file_name_without_extension(text_file)
d_text[text_file_no_ext] = text_file
self.log([u"Added text file '%s' to key '%s'", text_file, text_file_no_ext])
for audio_file in audio_files:
audio_file_no_ext = gf.file_name_without_extension(audio_file)
d_audio[audio_file_no_ext] = audio_file
self.log([u"Added audio file '%s' to key '%s'", audio_file, audio_file_no_ext])
tasks = []
for key in d_text.keys():
self.log([u"Examining text key '%s'", key])
if key in d_audio:
self.log([u"Key '%s' is also in audio", key])
tasks.append([key, d_text[key], d_audio[key]])
self.log([u"Added pair ('%s', '%s')", d_text[key], d_audio[key]])
return tasks | [
"def",
"_match_files_flat_hierarchy",
"(",
"self",
",",
"text_files",
",",
"audio_files",
")",
":",
"self",
".",
"log",
"(",
"u\"Matching files in flat hierarchy\"",
")",
"self",
".",
"log",
"(",
"[",
"u\"Text files: '%s'\"",
",",
"text_files",
"]",
")",
"self",
... | Match audio and text files in flat hierarchies.
Two files match if their names,
once removed the file extension,
are the same.
Examples: ::
foo/text/a.txt foo/audio/a.mp3 => match: ["a", "foo/text/a.txt", "foo/audio/a.mp3"]
foo/text/a.txt foo/audio/b.mp3 => no match
foo/res/c.txt foo/res/c.mp3 => match: ["c", "foo/res/c.txt", "foo/res/c.mp3"]
foo/res/d.txt foo/res/e.mp3 => no match
:param list text_files: the entries corresponding to text files
:param list audio_files: the entries corresponding to audio files
:rtype: list of lists (see above) | [
"Match",
"audio",
"and",
"text",
"files",
"in",
"flat",
"hierarchies",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/analyzecontainer.py#L460-L499 |
245,929 | readbeyond/aeneas | aeneas/analyzecontainer.py | AnalyzeContainer._match_directories | def _match_directories(self, entries, root, regex_string):
"""
Match directory names in paged hierarchies.
Example: ::
root = /foo/bar
regex_string = [0-9]+
/foo/bar/
1/
bar
baz
2/
bar
3/
foo
=> ["/foo/bar/1", "/foo/bar/2", "/foo/bar/3"]
:param list entries: the list of entries (paths) of a container
:param string root: the root directory to search within
:param string regex_string: regex string to match directory names
:rtype: list of matched directories
"""
self.log(u"Matching directory names in paged hierarchy")
self.log([u"Matching within '%s'", root])
self.log([u"Matching regex '%s'", regex_string])
regex = re.compile(r"" + regex_string)
directories = set()
root_len = len(root)
for entry in entries:
# look only inside root dir
if entry.startswith(root):
self.log([u"Examining '%s'", entry])
# remove common prefix root/
entry = entry[root_len + 1:]
# split path
entry_splitted = entry.split(os.sep)
# match regex
if ((len(entry_splitted) >= 2) and
(re.match(regex, entry_splitted[0]) is not None)):
directories.add(entry_splitted[0])
self.log([u"Match: '%s'", entry_splitted[0]])
else:
self.log([u"No match: '%s'", entry])
return sorted(directories) | python | def _match_directories(self, entries, root, regex_string):
self.log(u"Matching directory names in paged hierarchy")
self.log([u"Matching within '%s'", root])
self.log([u"Matching regex '%s'", regex_string])
regex = re.compile(r"" + regex_string)
directories = set()
root_len = len(root)
for entry in entries:
# look only inside root dir
if entry.startswith(root):
self.log([u"Examining '%s'", entry])
# remove common prefix root/
entry = entry[root_len + 1:]
# split path
entry_splitted = entry.split(os.sep)
# match regex
if ((len(entry_splitted) >= 2) and
(re.match(regex, entry_splitted[0]) is not None)):
directories.add(entry_splitted[0])
self.log([u"Match: '%s'", entry_splitted[0]])
else:
self.log([u"No match: '%s'", entry])
return sorted(directories) | [
"def",
"_match_directories",
"(",
"self",
",",
"entries",
",",
"root",
",",
"regex_string",
")",
":",
"self",
".",
"log",
"(",
"u\"Matching directory names in paged hierarchy\"",
")",
"self",
".",
"log",
"(",
"[",
"u\"Matching within '%s'\"",
",",
"root",
"]",
"... | Match directory names in paged hierarchies.
Example: ::
root = /foo/bar
regex_string = [0-9]+
/foo/bar/
1/
bar
baz
2/
bar
3/
foo
=> ["/foo/bar/1", "/foo/bar/2", "/foo/bar/3"]
:param list entries: the list of entries (paths) of a container
:param string root: the root directory to search within
:param string regex_string: regex string to match directory names
:rtype: list of matched directories | [
"Match",
"directory",
"names",
"in",
"paged",
"hierarchies",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/analyzecontainer.py#L501-L547 |
245,930 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask.load_task | def load_task(self, task):
"""
Load the task from the given ``Task`` object.
:param task: the task to load
:type task: :class:`~aeneas.task.Task`
:raises: :class:`~aeneas.executetask.ExecuteTaskInputError`: if ``task`` is not an instance of :class:`~aeneas.task.Task`
"""
if not isinstance(task, Task):
self.log_exc(u"task is not an instance of Task", None, True, ExecuteTaskInputError)
self.task = task | python | def load_task(self, task):
if not isinstance(task, Task):
self.log_exc(u"task is not an instance of Task", None, True, ExecuteTaskInputError)
self.task = task | [
"def",
"load_task",
"(",
"self",
",",
"task",
")",
":",
"if",
"not",
"isinstance",
"(",
"task",
",",
"Task",
")",
":",
"self",
".",
"log_exc",
"(",
"u\"task is not an instance of Task\"",
",",
"None",
",",
"True",
",",
"ExecuteTaskInputError",
")",
"self",
... | Load the task from the given ``Task`` object.
:param task: the task to load
:type task: :class:`~aeneas.task.Task`
:raises: :class:`~aeneas.executetask.ExecuteTaskInputError`: if ``task`` is not an instance of :class:`~aeneas.task.Task` | [
"Load",
"the",
"task",
"from",
"the",
"given",
"Task",
"object",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L97-L107 |
245,931 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._step_begin | def _step_begin(self, label, log=True):
""" Log begin of a step """
if log:
self.step_label = label
self.step_begin_time = self.log(u"STEP %d BEGIN (%s)" % (self.step_index, label)) | python | def _step_begin(self, label, log=True):
if log:
self.step_label = label
self.step_begin_time = self.log(u"STEP %d BEGIN (%s)" % (self.step_index, label)) | [
"def",
"_step_begin",
"(",
"self",
",",
"label",
",",
"log",
"=",
"True",
")",
":",
"if",
"log",
":",
"self",
".",
"step_label",
"=",
"label",
"self",
".",
"step_begin_time",
"=",
"self",
".",
"log",
"(",
"u\"STEP %d BEGIN (%s)\"",
"%",
"(",
"self",
".... | Log begin of a step | [
"Log",
"begin",
"of",
"a",
"step"
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L109-L113 |
245,932 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._step_end | def _step_end(self, log=True):
""" Log end of a step """
if log:
step_end_time = self.log(u"STEP %d END (%s)" % (self.step_index, self.step_label))
diff = (step_end_time - self.step_begin_time)
diff = float(diff.seconds + diff.microseconds / 1000000.0)
self.step_total += diff
self.log(u"STEP %d DURATION %.3f (%s)" % (self.step_index, diff, self.step_label))
self.step_index += 1 | python | def _step_end(self, log=True):
if log:
step_end_time = self.log(u"STEP %d END (%s)" % (self.step_index, self.step_label))
diff = (step_end_time - self.step_begin_time)
diff = float(diff.seconds + diff.microseconds / 1000000.0)
self.step_total += diff
self.log(u"STEP %d DURATION %.3f (%s)" % (self.step_index, diff, self.step_label))
self.step_index += 1 | [
"def",
"_step_end",
"(",
"self",
",",
"log",
"=",
"True",
")",
":",
"if",
"log",
":",
"step_end_time",
"=",
"self",
".",
"log",
"(",
"u\"STEP %d END (%s)\"",
"%",
"(",
"self",
".",
"step_index",
",",
"self",
".",
"step_label",
")",
")",
"diff",
"=",
... | Log end of a step | [
"Log",
"end",
"of",
"a",
"step"
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L115-L123 |
245,933 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._step_failure | def _step_failure(self, exc):
""" Log failure of a step """
self.log_crit(u"STEP %d (%s) FAILURE" % (self.step_index, self.step_label))
self.step_index += 1
self.log_exc(u"Unexpected error while executing task", exc, True, ExecuteTaskExecutionError) | python | def _step_failure(self, exc):
self.log_crit(u"STEP %d (%s) FAILURE" % (self.step_index, self.step_label))
self.step_index += 1
self.log_exc(u"Unexpected error while executing task", exc, True, ExecuteTaskExecutionError) | [
"def",
"_step_failure",
"(",
"self",
",",
"exc",
")",
":",
"self",
".",
"log_crit",
"(",
"u\"STEP %d (%s) FAILURE\"",
"%",
"(",
"self",
".",
"step_index",
",",
"self",
".",
"step_label",
")",
")",
"self",
".",
"step_index",
"+=",
"1",
"self",
".",
"log_e... | Log failure of a step | [
"Log",
"failure",
"of",
"a",
"step"
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L125-L129 |
245,934 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask.execute | def execute(self):
"""
Execute the task.
The sync map produced will be stored inside the task object.
:raises: :class:`~aeneas.executetask.ExecuteTaskInputError`: if there is a problem with the input parameters
:raises: :class:`~aeneas.executetask.ExecuteTaskExecutionError`: if there is a problem during the task execution
"""
self.log(u"Executing task...")
# check that we have the AudioFile object
if self.task.audio_file is None:
self.log_exc(u"The task does not seem to have its audio file set", None, True, ExecuteTaskInputError)
if (
(self.task.audio_file.audio_length is None) or
(self.task.audio_file.audio_length <= 0)
):
self.log_exc(u"The task seems to have an invalid audio file", None, True, ExecuteTaskInputError)
task_max_audio_length = self.rconf[RuntimeConfiguration.TASK_MAX_AUDIO_LENGTH]
if (
(task_max_audio_length > 0) and
(self.task.audio_file.audio_length > task_max_audio_length)
):
self.log_exc(u"The audio file of the task has length %.3f, more than the maximum allowed (%.3f)." % (self.task.audio_file.audio_length, task_max_audio_length), None, True, ExecuteTaskInputError)
# check that we have the TextFile object
if self.task.text_file is None:
self.log_exc(u"The task does not seem to have its text file set", None, True, ExecuteTaskInputError)
if len(self.task.text_file) == 0:
self.log_exc(u"The task text file seems to have no text fragments", None, True, ExecuteTaskInputError)
task_max_text_length = self.rconf[RuntimeConfiguration.TASK_MAX_TEXT_LENGTH]
if (
(task_max_text_length > 0) and
(len(self.task.text_file) > task_max_text_length)
):
self.log_exc(u"The text file of the task has %d fragments, more than the maximum allowed (%d)." % (len(self.task.text_file), task_max_text_length), None, True, ExecuteTaskInputError)
if self.task.text_file.chars == 0:
self.log_exc(u"The task text file seems to have empty text", None, True, ExecuteTaskInputError)
self.log(u"Both audio and text input file are present")
# execute
self.step_index = 1
self.step_total = 0.000
if self.task.text_file.file_format in TextFileFormat.MULTILEVEL_VALUES:
self._execute_multi_level_task()
else:
self._execute_single_level_task()
self.log(u"Executing task... done") | python | def execute(self):
self.log(u"Executing task...")
# check that we have the AudioFile object
if self.task.audio_file is None:
self.log_exc(u"The task does not seem to have its audio file set", None, True, ExecuteTaskInputError)
if (
(self.task.audio_file.audio_length is None) or
(self.task.audio_file.audio_length <= 0)
):
self.log_exc(u"The task seems to have an invalid audio file", None, True, ExecuteTaskInputError)
task_max_audio_length = self.rconf[RuntimeConfiguration.TASK_MAX_AUDIO_LENGTH]
if (
(task_max_audio_length > 0) and
(self.task.audio_file.audio_length > task_max_audio_length)
):
self.log_exc(u"The audio file of the task has length %.3f, more than the maximum allowed (%.3f)." % (self.task.audio_file.audio_length, task_max_audio_length), None, True, ExecuteTaskInputError)
# check that we have the TextFile object
if self.task.text_file is None:
self.log_exc(u"The task does not seem to have its text file set", None, True, ExecuteTaskInputError)
if len(self.task.text_file) == 0:
self.log_exc(u"The task text file seems to have no text fragments", None, True, ExecuteTaskInputError)
task_max_text_length = self.rconf[RuntimeConfiguration.TASK_MAX_TEXT_LENGTH]
if (
(task_max_text_length > 0) and
(len(self.task.text_file) > task_max_text_length)
):
self.log_exc(u"The text file of the task has %d fragments, more than the maximum allowed (%d)." % (len(self.task.text_file), task_max_text_length), None, True, ExecuteTaskInputError)
if self.task.text_file.chars == 0:
self.log_exc(u"The task text file seems to have empty text", None, True, ExecuteTaskInputError)
self.log(u"Both audio and text input file are present")
# execute
self.step_index = 1
self.step_total = 0.000
if self.task.text_file.file_format in TextFileFormat.MULTILEVEL_VALUES:
self._execute_multi_level_task()
else:
self._execute_single_level_task()
self.log(u"Executing task... done") | [
"def",
"execute",
"(",
"self",
")",
":",
"self",
".",
"log",
"(",
"u\"Executing task...\"",
")",
"# check that we have the AudioFile object",
"if",
"self",
".",
"task",
".",
"audio_file",
"is",
"None",
":",
"self",
".",
"log_exc",
"(",
"u\"The task does not seem t... | Execute the task.
The sync map produced will be stored inside the task object.
:raises: :class:`~aeneas.executetask.ExecuteTaskInputError`: if there is a problem with the input parameters
:raises: :class:`~aeneas.executetask.ExecuteTaskExecutionError`: if there is a problem during the task execution | [
"Execute",
"the",
"task",
".",
"The",
"sync",
"map",
"produced",
"will",
"be",
"stored",
"inside",
"the",
"task",
"object",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L135-L183 |
245,935 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._execute_single_level_task | def _execute_single_level_task(self):
""" Execute a single-level task """
self.log(u"Executing single level task...")
try:
# load audio file, extract MFCCs from real wave, clear audio file
self._step_begin(u"extract MFCC real wave")
real_wave_mfcc = self._extract_mfcc(
file_path=self.task.audio_file_path_absolute,
file_format=None,
)
self._step_end()
# compute head and/or tail and set it
self._step_begin(u"compute head tail")
(head_length, process_length, tail_length) = self._compute_head_process_tail(real_wave_mfcc)
real_wave_mfcc.set_head_middle_tail(head_length, process_length, tail_length)
self._step_end()
# compute alignment, outputting a tree of time intervals
self._set_synthesizer()
sync_root = Tree()
self._execute_inner(
real_wave_mfcc,
self.task.text_file,
sync_root=sync_root,
force_aba_auto=False,
log=True,
leaf_level=True
)
self._clear_cache_synthesizer()
# create syncmap and add it to task
self._step_begin(u"create sync map")
self._create_sync_map(sync_root=sync_root)
self._step_end()
# log total
self._step_total()
self.log(u"Executing single level task... done")
except Exception as exc:
self._step_failure(exc) | python | def _execute_single_level_task(self):
self.log(u"Executing single level task...")
try:
# load audio file, extract MFCCs from real wave, clear audio file
self._step_begin(u"extract MFCC real wave")
real_wave_mfcc = self._extract_mfcc(
file_path=self.task.audio_file_path_absolute,
file_format=None,
)
self._step_end()
# compute head and/or tail and set it
self._step_begin(u"compute head tail")
(head_length, process_length, tail_length) = self._compute_head_process_tail(real_wave_mfcc)
real_wave_mfcc.set_head_middle_tail(head_length, process_length, tail_length)
self._step_end()
# compute alignment, outputting a tree of time intervals
self._set_synthesizer()
sync_root = Tree()
self._execute_inner(
real_wave_mfcc,
self.task.text_file,
sync_root=sync_root,
force_aba_auto=False,
log=True,
leaf_level=True
)
self._clear_cache_synthesizer()
# create syncmap and add it to task
self._step_begin(u"create sync map")
self._create_sync_map(sync_root=sync_root)
self._step_end()
# log total
self._step_total()
self.log(u"Executing single level task... done")
except Exception as exc:
self._step_failure(exc) | [
"def",
"_execute_single_level_task",
"(",
"self",
")",
":",
"self",
".",
"log",
"(",
"u\"Executing single level task...\"",
")",
"try",
":",
"# load audio file, extract MFCCs from real wave, clear audio file",
"self",
".",
"_step_begin",
"(",
"u\"extract MFCC real wave\"",
")... | Execute a single-level task | [
"Execute",
"a",
"single",
"-",
"level",
"task"
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L185-L225 |
245,936 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._execute_level | def _execute_level(self, level, audio_file_mfcc, text_files, sync_roots, force_aba_auto=False):
"""
Compute the alignment for all the nodes in the given level.
Return a pair (next_level_text_files, next_level_sync_roots),
containing two lists of text file subtrees and sync map subtrees
on the next level.
:param int level: the level
:param audio_file_mfcc: the audio MFCC representation for this level
:type audio_file_mfcc: :class:`~aeneas.audiofilemfcc.AudioFileMFCC`
:param list text_files: a list of :class:`~aeneas.textfile.TextFile` objects,
each representing a (sub)tree of the Task text file
:param list sync_roots: a list of :class:`~aeneas.tree.Tree` objects,
each representing a SyncMapFragment tree,
one for each element in ``text_files``
:param bool force_aba_auto: if ``True``, force using the AUTO ABA algorithm
:rtype: (list, list)
"""
self._set_synthesizer()
next_level_text_files = []
next_level_sync_roots = []
for text_file_index, text_file in enumerate(text_files):
self.log([u"Text level %d, fragment %d", level, text_file_index])
self.log([u" Len: %d", len(text_file)])
sync_root = sync_roots[text_file_index]
if (level > 1) and (len(text_file) == 1):
self.log(u"Level > 1 and only one text fragment => return trivial tree")
self._append_trivial_tree(text_file, sync_root)
elif (level > 1) and (sync_root.value.begin == sync_root.value.end):
self.log(u"Level > 1 and parent has begin == end => return trivial tree")
self._append_trivial_tree(text_file, sync_root)
else:
self.log(u"Level == 1 or more than one text fragment with non-zero parent => compute tree")
if not sync_root.is_empty:
begin = sync_root.value.begin
end = sync_root.value.end
self.log([u" Setting begin: %.3f", begin])
self.log([u" Setting end: %.3f", end])
audio_file_mfcc.set_head_middle_tail(head_length=begin, middle_length=(end - begin))
else:
self.log(u" No begin or end to set")
self._execute_inner(
audio_file_mfcc,
text_file,
sync_root=sync_root,
force_aba_auto=force_aba_auto,
log=False,
leaf_level=(level == 3)
)
# store next level roots
next_level_text_files.extend(text_file.children_not_empty)
# we added head and tail, we must not pass them to the next level
next_level_sync_roots.extend(sync_root.children[1:-1])
self._clear_cache_synthesizer()
return (next_level_text_files, next_level_sync_roots) | python | def _execute_level(self, level, audio_file_mfcc, text_files, sync_roots, force_aba_auto=False):
self._set_synthesizer()
next_level_text_files = []
next_level_sync_roots = []
for text_file_index, text_file in enumerate(text_files):
self.log([u"Text level %d, fragment %d", level, text_file_index])
self.log([u" Len: %d", len(text_file)])
sync_root = sync_roots[text_file_index]
if (level > 1) and (len(text_file) == 1):
self.log(u"Level > 1 and only one text fragment => return trivial tree")
self._append_trivial_tree(text_file, sync_root)
elif (level > 1) and (sync_root.value.begin == sync_root.value.end):
self.log(u"Level > 1 and parent has begin == end => return trivial tree")
self._append_trivial_tree(text_file, sync_root)
else:
self.log(u"Level == 1 or more than one text fragment with non-zero parent => compute tree")
if not sync_root.is_empty:
begin = sync_root.value.begin
end = sync_root.value.end
self.log([u" Setting begin: %.3f", begin])
self.log([u" Setting end: %.3f", end])
audio_file_mfcc.set_head_middle_tail(head_length=begin, middle_length=(end - begin))
else:
self.log(u" No begin or end to set")
self._execute_inner(
audio_file_mfcc,
text_file,
sync_root=sync_root,
force_aba_auto=force_aba_auto,
log=False,
leaf_level=(level == 3)
)
# store next level roots
next_level_text_files.extend(text_file.children_not_empty)
# we added head and tail, we must not pass them to the next level
next_level_sync_roots.extend(sync_root.children[1:-1])
self._clear_cache_synthesizer()
return (next_level_text_files, next_level_sync_roots) | [
"def",
"_execute_level",
"(",
"self",
",",
"level",
",",
"audio_file_mfcc",
",",
"text_files",
",",
"sync_roots",
",",
"force_aba_auto",
"=",
"False",
")",
":",
"self",
".",
"_set_synthesizer",
"(",
")",
"next_level_text_files",
"=",
"[",
"]",
"next_level_sync_r... | Compute the alignment for all the nodes in the given level.
Return a pair (next_level_text_files, next_level_sync_roots),
containing two lists of text file subtrees and sync map subtrees
on the next level.
:param int level: the level
:param audio_file_mfcc: the audio MFCC representation for this level
:type audio_file_mfcc: :class:`~aeneas.audiofilemfcc.AudioFileMFCC`
:param list text_files: a list of :class:`~aeneas.textfile.TextFile` objects,
each representing a (sub)tree of the Task text file
:param list sync_roots: a list of :class:`~aeneas.tree.Tree` objects,
each representing a SyncMapFragment tree,
one for each element in ``text_files``
:param bool force_aba_auto: if ``True``, force using the AUTO ABA algorithm
:rtype: (list, list) | [
"Compute",
"the",
"alignment",
"for",
"all",
"the",
"nodes",
"in",
"the",
"given",
"level",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L303-L358 |
245,937 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._execute_inner | def _execute_inner(self, audio_file_mfcc, text_file, sync_root=None, force_aba_auto=False, log=True, leaf_level=False):
"""
Align a subinterval of the given AudioFileMFCC
with the given TextFile.
Return the computed tree of time intervals,
rooted at ``sync_root`` if the latter is not ``None``,
or as a new ``Tree`` otherwise.
The begin and end positions inside the AudioFileMFCC
must have been set ahead by the caller.
The text fragments being aligned are the vchildren of ``text_file``.
:param audio_file_mfcc: the audio file MFCC representation
:type audio_file_mfcc: :class:`~aeneas.audiofilemfcc.AudioFileMFCC`
:param text_file: the text file subtree to align
:type text_file: :class:`~aeneas.textfile.TextFile`
:param sync_root: the tree node to which fragments should be appended
:type sync_root: :class:`~aeneas.tree.Tree`
:param bool force_aba_auto: if ``True``, do not run aba algorithm
:param bool log: if ``True``, log steps
:param bool leaf_level: alert aba if the computation is at a leaf level
:rtype: :class:`~aeneas.tree.Tree`
"""
self._step_begin(u"synthesize text", log=log)
synt_handler, synt_path, synt_anchors, synt_format = self._synthesize(text_file)
self._step_end(log=log)
self._step_begin(u"extract MFCC synt wave", log=log)
synt_wave_mfcc = self._extract_mfcc(
file_path=synt_path,
file_format=synt_format,
)
gf.delete_file(synt_handler, synt_path)
self._step_end(log=log)
self._step_begin(u"align waves", log=log)
indices = self._align_waves(audio_file_mfcc, synt_wave_mfcc, synt_anchors)
self._step_end(log=log)
self._step_begin(u"adjust boundaries", log=log)
self._adjust_boundaries(indices, text_file, audio_file_mfcc, sync_root, force_aba_auto, leaf_level)
self._step_end(log=log) | python | def _execute_inner(self, audio_file_mfcc, text_file, sync_root=None, force_aba_auto=False, log=True, leaf_level=False):
self._step_begin(u"synthesize text", log=log)
synt_handler, synt_path, synt_anchors, synt_format = self._synthesize(text_file)
self._step_end(log=log)
self._step_begin(u"extract MFCC synt wave", log=log)
synt_wave_mfcc = self._extract_mfcc(
file_path=synt_path,
file_format=synt_format,
)
gf.delete_file(synt_handler, synt_path)
self._step_end(log=log)
self._step_begin(u"align waves", log=log)
indices = self._align_waves(audio_file_mfcc, synt_wave_mfcc, synt_anchors)
self._step_end(log=log)
self._step_begin(u"adjust boundaries", log=log)
self._adjust_boundaries(indices, text_file, audio_file_mfcc, sync_root, force_aba_auto, leaf_level)
self._step_end(log=log) | [
"def",
"_execute_inner",
"(",
"self",
",",
"audio_file_mfcc",
",",
"text_file",
",",
"sync_root",
"=",
"None",
",",
"force_aba_auto",
"=",
"False",
",",
"log",
"=",
"True",
",",
"leaf_level",
"=",
"False",
")",
":",
"self",
".",
"_step_begin",
"(",
"u\"syn... | Align a subinterval of the given AudioFileMFCC
with the given TextFile.
Return the computed tree of time intervals,
rooted at ``sync_root`` if the latter is not ``None``,
or as a new ``Tree`` otherwise.
The begin and end positions inside the AudioFileMFCC
must have been set ahead by the caller.
The text fragments being aligned are the vchildren of ``text_file``.
:param audio_file_mfcc: the audio file MFCC representation
:type audio_file_mfcc: :class:`~aeneas.audiofilemfcc.AudioFileMFCC`
:param text_file: the text file subtree to align
:type text_file: :class:`~aeneas.textfile.TextFile`
:param sync_root: the tree node to which fragments should be appended
:type sync_root: :class:`~aeneas.tree.Tree`
:param bool force_aba_auto: if ``True``, do not run aba algorithm
:param bool log: if ``True``, log steps
:param bool leaf_level: alert aba if the computation is at a leaf level
:rtype: :class:`~aeneas.tree.Tree` | [
"Align",
"a",
"subinterval",
"of",
"the",
"given",
"AudioFileMFCC",
"with",
"the",
"given",
"TextFile",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L360-L403 |
245,938 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._load_audio_file | def _load_audio_file(self):
"""
Load audio in memory.
:rtype: :class:`~aeneas.audiofile.AudioFile`
"""
self._step_begin(u"load audio file")
# NOTE file_format=None forces conversion to
# PCM16 mono WAVE with default sample rate
audio_file = AudioFile(
file_path=self.task.audio_file_path_absolute,
file_format=None,
rconf=self.rconf,
logger=self.logger
)
audio_file.read_samples_from_file()
self._step_end()
return audio_file | python | def _load_audio_file(self):
self._step_begin(u"load audio file")
# NOTE file_format=None forces conversion to
# PCM16 mono WAVE with default sample rate
audio_file = AudioFile(
file_path=self.task.audio_file_path_absolute,
file_format=None,
rconf=self.rconf,
logger=self.logger
)
audio_file.read_samples_from_file()
self._step_end()
return audio_file | [
"def",
"_load_audio_file",
"(",
"self",
")",
":",
"self",
".",
"_step_begin",
"(",
"u\"load audio file\"",
")",
"# NOTE file_format=None forces conversion to",
"# PCM16 mono WAVE with default sample rate",
"audio_file",
"=",
"AudioFile",
"(",
"file_path",
"=",
"self",
... | Load audio in memory.
:rtype: :class:`~aeneas.audiofile.AudioFile` | [
"Load",
"audio",
"in",
"memory",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L405-L422 |
245,939 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._clear_audio_file | def _clear_audio_file(self, audio_file):
"""
Clear audio from memory.
:param audio_file: the object to clear
:type audio_file: :class:`~aeneas.audiofile.AudioFile`
"""
self._step_begin(u"clear audio file")
audio_file.clear_data()
audio_file = None
self._step_end() | python | def _clear_audio_file(self, audio_file):
self._step_begin(u"clear audio file")
audio_file.clear_data()
audio_file = None
self._step_end() | [
"def",
"_clear_audio_file",
"(",
"self",
",",
"audio_file",
")",
":",
"self",
".",
"_step_begin",
"(",
"u\"clear audio file\"",
")",
"audio_file",
".",
"clear_data",
"(",
")",
"audio_file",
"=",
"None",
"self",
".",
"_step_end",
"(",
")"
] | Clear audio from memory.
:param audio_file: the object to clear
:type audio_file: :class:`~aeneas.audiofile.AudioFile` | [
"Clear",
"audio",
"from",
"memory",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L424-L434 |
245,940 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._extract_mfcc | def _extract_mfcc(self, file_path=None, file_format=None, audio_file=None):
"""
Extract the MFCCs from the given audio file.
:rtype: :class:`~aeneas.audiofilemfcc.AudioFileMFCC`
"""
audio_file_mfcc = AudioFileMFCC(
file_path=file_path,
file_format=file_format,
audio_file=audio_file,
rconf=self.rconf,
logger=self.logger
)
if self.rconf.mmn:
self.log(u"Running VAD inside _extract_mfcc...")
audio_file_mfcc.run_vad(
log_energy_threshold=self.rconf[RuntimeConfiguration.MFCC_MASK_LOG_ENERGY_THRESHOLD],
min_nonspeech_length=self.rconf[RuntimeConfiguration.MFCC_MASK_MIN_NONSPEECH_LENGTH],
extend_before=self.rconf[RuntimeConfiguration.MFCC_MASK_EXTEND_SPEECH_INTERVAL_BEFORE],
extend_after=self.rconf[RuntimeConfiguration.MFCC_MASK_EXTEND_SPEECH_INTERVAL_AFTER]
)
self.log(u"Running VAD inside _extract_mfcc... done")
return audio_file_mfcc | python | def _extract_mfcc(self, file_path=None, file_format=None, audio_file=None):
audio_file_mfcc = AudioFileMFCC(
file_path=file_path,
file_format=file_format,
audio_file=audio_file,
rconf=self.rconf,
logger=self.logger
)
if self.rconf.mmn:
self.log(u"Running VAD inside _extract_mfcc...")
audio_file_mfcc.run_vad(
log_energy_threshold=self.rconf[RuntimeConfiguration.MFCC_MASK_LOG_ENERGY_THRESHOLD],
min_nonspeech_length=self.rconf[RuntimeConfiguration.MFCC_MASK_MIN_NONSPEECH_LENGTH],
extend_before=self.rconf[RuntimeConfiguration.MFCC_MASK_EXTEND_SPEECH_INTERVAL_BEFORE],
extend_after=self.rconf[RuntimeConfiguration.MFCC_MASK_EXTEND_SPEECH_INTERVAL_AFTER]
)
self.log(u"Running VAD inside _extract_mfcc... done")
return audio_file_mfcc | [
"def",
"_extract_mfcc",
"(",
"self",
",",
"file_path",
"=",
"None",
",",
"file_format",
"=",
"None",
",",
"audio_file",
"=",
"None",
")",
":",
"audio_file_mfcc",
"=",
"AudioFileMFCC",
"(",
"file_path",
"=",
"file_path",
",",
"file_format",
"=",
"file_format",
... | Extract the MFCCs from the given audio file.
:rtype: :class:`~aeneas.audiofilemfcc.AudioFileMFCC` | [
"Extract",
"the",
"MFCCs",
"from",
"the",
"given",
"audio",
"file",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L436-L458 |
245,941 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._compute_head_process_tail | def _compute_head_process_tail(self, audio_file_mfcc):
"""
Set the audio file head or tail,
by either reading the explicit values
from the Task configuration,
or using SD to determine them.
This function returns the lengths, in seconds,
of the (head, process, tail).
:rtype: tuple (float, float, float)
"""
head_length = self.task.configuration["i_a_head"]
process_length = self.task.configuration["i_a_process"]
tail_length = self.task.configuration["i_a_tail"]
head_max = self.task.configuration["i_a_head_max"]
head_min = self.task.configuration["i_a_head_min"]
tail_max = self.task.configuration["i_a_tail_max"]
tail_min = self.task.configuration["i_a_tail_min"]
if (
(head_length is not None) or
(process_length is not None) or
(tail_length is not None)
):
self.log(u"Setting explicit head process tail")
else:
self.log(u"Detecting head tail...")
sd = SD(audio_file_mfcc, self.task.text_file, rconf=self.rconf, logger=self.logger)
head_length = TimeValue("0.000")
process_length = None
tail_length = TimeValue("0.000")
if (head_min is not None) or (head_max is not None):
self.log(u"Detecting HEAD...")
head_length = sd.detect_head(head_min, head_max)
self.log([u"Detected HEAD: %.3f", head_length])
self.log(u"Detecting HEAD... done")
if (tail_min is not None) or (tail_max is not None):
self.log(u"Detecting TAIL...")
tail_length = sd.detect_tail(tail_min, tail_max)
self.log([u"Detected TAIL: %.3f", tail_length])
self.log(u"Detecting TAIL... done")
self.log(u"Detecting head tail... done")
self.log([u"Head: %s", gf.safe_float(head_length, None)])
self.log([u"Process: %s", gf.safe_float(process_length, None)])
self.log([u"Tail: %s", gf.safe_float(tail_length, None)])
return (head_length, process_length, tail_length) | python | def _compute_head_process_tail(self, audio_file_mfcc):
head_length = self.task.configuration["i_a_head"]
process_length = self.task.configuration["i_a_process"]
tail_length = self.task.configuration["i_a_tail"]
head_max = self.task.configuration["i_a_head_max"]
head_min = self.task.configuration["i_a_head_min"]
tail_max = self.task.configuration["i_a_tail_max"]
tail_min = self.task.configuration["i_a_tail_min"]
if (
(head_length is not None) or
(process_length is not None) or
(tail_length is not None)
):
self.log(u"Setting explicit head process tail")
else:
self.log(u"Detecting head tail...")
sd = SD(audio_file_mfcc, self.task.text_file, rconf=self.rconf, logger=self.logger)
head_length = TimeValue("0.000")
process_length = None
tail_length = TimeValue("0.000")
if (head_min is not None) or (head_max is not None):
self.log(u"Detecting HEAD...")
head_length = sd.detect_head(head_min, head_max)
self.log([u"Detected HEAD: %.3f", head_length])
self.log(u"Detecting HEAD... done")
if (tail_min is not None) or (tail_max is not None):
self.log(u"Detecting TAIL...")
tail_length = sd.detect_tail(tail_min, tail_max)
self.log([u"Detected TAIL: %.3f", tail_length])
self.log(u"Detecting TAIL... done")
self.log(u"Detecting head tail... done")
self.log([u"Head: %s", gf.safe_float(head_length, None)])
self.log([u"Process: %s", gf.safe_float(process_length, None)])
self.log([u"Tail: %s", gf.safe_float(tail_length, None)])
return (head_length, process_length, tail_length) | [
"def",
"_compute_head_process_tail",
"(",
"self",
",",
"audio_file_mfcc",
")",
":",
"head_length",
"=",
"self",
".",
"task",
".",
"configuration",
"[",
"\"i_a_head\"",
"]",
"process_length",
"=",
"self",
".",
"task",
".",
"configuration",
"[",
"\"i_a_process\"",
... | Set the audio file head or tail,
by either reading the explicit values
from the Task configuration,
or using SD to determine them.
This function returns the lengths, in seconds,
of the (head, process, tail).
:rtype: tuple (float, float, float) | [
"Set",
"the",
"audio",
"file",
"head",
"or",
"tail",
"by",
"either",
"reading",
"the",
"explicit",
"values",
"from",
"the",
"Task",
"configuration",
"or",
"using",
"SD",
"to",
"determine",
"them",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L460-L505 |
245,942 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._clear_cache_synthesizer | def _clear_cache_synthesizer(self):
""" Clear the cache of the synthesizer """
self.log(u"Clearing synthesizer...")
self.synthesizer.clear_cache()
self.log(u"Clearing synthesizer... done") | python | def _clear_cache_synthesizer(self):
self.log(u"Clearing synthesizer...")
self.synthesizer.clear_cache()
self.log(u"Clearing synthesizer... done") | [
"def",
"_clear_cache_synthesizer",
"(",
"self",
")",
":",
"self",
".",
"log",
"(",
"u\"Clearing synthesizer...\"",
")",
"self",
".",
"synthesizer",
".",
"clear_cache",
"(",
")",
"self",
".",
"log",
"(",
"u\"Clearing synthesizer... done\"",
")"
] | Clear the cache of the synthesizer | [
"Clear",
"the",
"cache",
"of",
"the",
"synthesizer"
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L513-L517 |
245,943 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._synthesize | def _synthesize(self, text_file):
"""
Synthesize text into a WAVE file.
Return a tuple consisting of:
1. the handler of the generated audio file
2. the path of the generated audio file
3. the list of anchors, that is, a list of floats
each representing the start time of the corresponding
text fragment in the generated wave file
``[start_1, start_2, ..., start_n]``
4. a tuple describing the format of the audio file
:param text_file: the text to be synthesized
:type text_file: :class:`~aeneas.textfile.TextFile`
:rtype: tuple (handler, string, list)
"""
handler, path = gf.tmp_file(suffix=u".wav", root=self.rconf[RuntimeConfiguration.TMP_PATH])
result = self.synthesizer.synthesize(text_file, path)
return (handler, path, result[0], self.synthesizer.output_audio_format) | python | def _synthesize(self, text_file):
handler, path = gf.tmp_file(suffix=u".wav", root=self.rconf[RuntimeConfiguration.TMP_PATH])
result = self.synthesizer.synthesize(text_file, path)
return (handler, path, result[0], self.synthesizer.output_audio_format) | [
"def",
"_synthesize",
"(",
"self",
",",
"text_file",
")",
":",
"handler",
",",
"path",
"=",
"gf",
".",
"tmp_file",
"(",
"suffix",
"=",
"u\".wav\"",
",",
"root",
"=",
"self",
".",
"rconf",
"[",
"RuntimeConfiguration",
".",
"TMP_PATH",
"]",
")",
"result",
... | Synthesize text into a WAVE file.
Return a tuple consisting of:
1. the handler of the generated audio file
2. the path of the generated audio file
3. the list of anchors, that is, a list of floats
each representing the start time of the corresponding
text fragment in the generated wave file
``[start_1, start_2, ..., start_n]``
4. a tuple describing the format of the audio file
:param text_file: the text to be synthesized
:type text_file: :class:`~aeneas.textfile.TextFile`
:rtype: tuple (handler, string, list) | [
"Synthesize",
"text",
"into",
"a",
"WAVE",
"file",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L519-L539 |
245,944 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._align_waves | def _align_waves(self, real_wave_mfcc, synt_wave_mfcc, synt_anchors):
"""
Align two AudioFileMFCC objects,
representing WAVE files.
Return a list of boundary indices.
"""
self.log(u"Creating DTWAligner...")
aligner = DTWAligner(
real_wave_mfcc,
synt_wave_mfcc,
rconf=self.rconf,
logger=self.logger
)
self.log(u"Creating DTWAligner... done")
self.log(u"Computing boundary indices...")
boundary_indices = aligner.compute_boundaries(synt_anchors)
self.log(u"Computing boundary indices... done")
return boundary_indices | python | def _align_waves(self, real_wave_mfcc, synt_wave_mfcc, synt_anchors):
self.log(u"Creating DTWAligner...")
aligner = DTWAligner(
real_wave_mfcc,
synt_wave_mfcc,
rconf=self.rconf,
logger=self.logger
)
self.log(u"Creating DTWAligner... done")
self.log(u"Computing boundary indices...")
boundary_indices = aligner.compute_boundaries(synt_anchors)
self.log(u"Computing boundary indices... done")
return boundary_indices | [
"def",
"_align_waves",
"(",
"self",
",",
"real_wave_mfcc",
",",
"synt_wave_mfcc",
",",
"synt_anchors",
")",
":",
"self",
".",
"log",
"(",
"u\"Creating DTWAligner...\"",
")",
"aligner",
"=",
"DTWAligner",
"(",
"real_wave_mfcc",
",",
"synt_wave_mfcc",
",",
"rconf",
... | Align two AudioFileMFCC objects,
representing WAVE files.
Return a list of boundary indices. | [
"Align",
"two",
"AudioFileMFCC",
"objects",
"representing",
"WAVE",
"files",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L541-L559 |
245,945 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._adjust_boundaries | def _adjust_boundaries(self, boundary_indices, text_file, real_wave_mfcc, sync_root, force_aba_auto=False, leaf_level=False):
"""
Adjust boundaries as requested by the user.
Return the computed time map, that is,
a list of pairs ``[start_time, end_time]``,
of length equal to number of fragments + 2,
where the two extra elements are for
the HEAD (first) and TAIL (last).
"""
# boundary_indices contains the boundary indices in the all_mfcc of real_wave_mfcc
# starting with the (head-1st fragment) and ending with (-1th fragment-tail)
aba_parameters = self.task.configuration.aba_parameters()
if force_aba_auto:
self.log(u"Forced running algorithm: 'auto'")
aba_parameters["algorithm"] = (AdjustBoundaryAlgorithm.AUTO, [])
# note that the other aba settings (nonspeech and nozero)
# remain as specified by the user
self.log([u"ABA parameters: %s", aba_parameters])
aba = AdjustBoundaryAlgorithm(rconf=self.rconf, logger=self.logger)
aba.adjust(
aba_parameters=aba_parameters,
real_wave_mfcc=real_wave_mfcc,
boundary_indices=boundary_indices,
text_file=text_file,
allow_arbitrary_shift=leaf_level
)
aba.append_fragment_list_to_sync_root(sync_root=sync_root) | python | def _adjust_boundaries(self, boundary_indices, text_file, real_wave_mfcc, sync_root, force_aba_auto=False, leaf_level=False):
# boundary_indices contains the boundary indices in the all_mfcc of real_wave_mfcc
# starting with the (head-1st fragment) and ending with (-1th fragment-tail)
aba_parameters = self.task.configuration.aba_parameters()
if force_aba_auto:
self.log(u"Forced running algorithm: 'auto'")
aba_parameters["algorithm"] = (AdjustBoundaryAlgorithm.AUTO, [])
# note that the other aba settings (nonspeech and nozero)
# remain as specified by the user
self.log([u"ABA parameters: %s", aba_parameters])
aba = AdjustBoundaryAlgorithm(rconf=self.rconf, logger=self.logger)
aba.adjust(
aba_parameters=aba_parameters,
real_wave_mfcc=real_wave_mfcc,
boundary_indices=boundary_indices,
text_file=text_file,
allow_arbitrary_shift=leaf_level
)
aba.append_fragment_list_to_sync_root(sync_root=sync_root) | [
"def",
"_adjust_boundaries",
"(",
"self",
",",
"boundary_indices",
",",
"text_file",
",",
"real_wave_mfcc",
",",
"sync_root",
",",
"force_aba_auto",
"=",
"False",
",",
"leaf_level",
"=",
"False",
")",
":",
"# boundary_indices contains the boundary indices in the all_mfcc ... | Adjust boundaries as requested by the user.
Return the computed time map, that is,
a list of pairs ``[start_time, end_time]``,
of length equal to number of fragments + 2,
where the two extra elements are for
the HEAD (first) and TAIL (last). | [
"Adjust",
"boundaries",
"as",
"requested",
"by",
"the",
"user",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L561-L588 |
245,946 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._append_trivial_tree | def _append_trivial_tree(self, text_file, sync_root):
"""
Append trivial tree, made by one HEAD,
one sync map fragment for each element of ``text_file``,
and one TAIL.
This function is called if either ``text_file`` has only one element,
or if ``sync_root.value`` is an interval with zero length
(i.e., ``sync_root.value.begin == sync_root.value.end``).
"""
interval = sync_root.value
#
# NOTE the following is correct, but it is a bit obscure
# time_values = [interval.begin] * (1 + len(text_file)) + [interval.end] * 2
#
if len(text_file) == 1:
time_values = [interval.begin, interval.begin, interval.end, interval.end]
else:
# interval.begin == interval.end
time_values = [interval.begin] * (3 + len(text_file))
aba = AdjustBoundaryAlgorithm(rconf=self.rconf, logger=self.logger)
aba.intervals_to_fragment_list(
text_file=text_file,
time_values=time_values
)
aba.append_fragment_list_to_sync_root(sync_root=sync_root) | python | def _append_trivial_tree(self, text_file, sync_root):
interval = sync_root.value
#
# NOTE the following is correct, but it is a bit obscure
# time_values = [interval.begin] * (1 + len(text_file)) + [interval.end] * 2
#
if len(text_file) == 1:
time_values = [interval.begin, interval.begin, interval.end, interval.end]
else:
# interval.begin == interval.end
time_values = [interval.begin] * (3 + len(text_file))
aba = AdjustBoundaryAlgorithm(rconf=self.rconf, logger=self.logger)
aba.intervals_to_fragment_list(
text_file=text_file,
time_values=time_values
)
aba.append_fragment_list_to_sync_root(sync_root=sync_root) | [
"def",
"_append_trivial_tree",
"(",
"self",
",",
"text_file",
",",
"sync_root",
")",
":",
"interval",
"=",
"sync_root",
".",
"value",
"#",
"# NOTE the following is correct, but it is a bit obscure",
"# time_values = [interval.begin] * (1 + len(text_file)) + [interval.end] * 2",
"... | Append trivial tree, made by one HEAD,
one sync map fragment for each element of ``text_file``,
and one TAIL.
This function is called if either ``text_file`` has only one element,
or if ``sync_root.value`` is an interval with zero length
(i.e., ``sync_root.value.begin == sync_root.value.end``). | [
"Append",
"trivial",
"tree",
"made",
"by",
"one",
"HEAD",
"one",
"sync",
"map",
"fragment",
"for",
"each",
"element",
"of",
"text_file",
"and",
"one",
"TAIL",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L590-L615 |
245,947 | readbeyond/aeneas | aeneas/executetask.py | ExecuteTask._create_sync_map | def _create_sync_map(self, sync_root):
"""
If requested, check that the computed sync map is consistent.
Then, add it to the Task.
"""
sync_map = SyncMap(tree=sync_root, rconf=self.rconf, logger=self.logger)
if self.rconf.safety_checks:
self.log(u"Running sanity check on computed sync map...")
if not sync_map.leaves_are_consistent:
self._step_failure(ValueError(u"The computed sync map contains inconsistent fragments"))
self.log(u"Running sanity check on computed sync map... passed")
else:
self.log(u"Not running sanity check on computed sync map")
self.task.sync_map = sync_map | python | def _create_sync_map(self, sync_root):
sync_map = SyncMap(tree=sync_root, rconf=self.rconf, logger=self.logger)
if self.rconf.safety_checks:
self.log(u"Running sanity check on computed sync map...")
if not sync_map.leaves_are_consistent:
self._step_failure(ValueError(u"The computed sync map contains inconsistent fragments"))
self.log(u"Running sanity check on computed sync map... passed")
else:
self.log(u"Not running sanity check on computed sync map")
self.task.sync_map = sync_map | [
"def",
"_create_sync_map",
"(",
"self",
",",
"sync_root",
")",
":",
"sync_map",
"=",
"SyncMap",
"(",
"tree",
"=",
"sync_root",
",",
"rconf",
"=",
"self",
".",
"rconf",
",",
"logger",
"=",
"self",
".",
"logger",
")",
"if",
"self",
".",
"rconf",
".",
"... | If requested, check that the computed sync map is consistent.
Then, add it to the Task. | [
"If",
"requested",
"check",
"that",
"the",
"computed",
"sync",
"map",
"is",
"consistent",
".",
"Then",
"add",
"it",
"to",
"the",
"Task",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/executetask.py#L617-L630 |
245,948 | readbeyond/aeneas | aeneas/sd.py | SD.detect_interval | def detect_interval(
self,
min_head_length=None,
max_head_length=None,
min_tail_length=None,
max_tail_length=None
):
"""
Detect the interval of the audio file
containing the fragments in the text file.
Return the audio interval as a tuple of two
:class:`~aeneas.exacttiming.TimeValue` objects,
representing the begin and end time, in seconds,
with respect to the full wave duration.
If one of the parameters is ``None``, the default value
(``0.0`` for min, ``10.0`` for max) will be used.
:param min_head_length: estimated minimum head length
:type min_head_length: :class:`~aeneas.exacttiming.TimeValue`
:param max_head_length: estimated maximum head length
:type max_head_length: :class:`~aeneas.exacttiming.TimeValue`
:param min_tail_length: estimated minimum tail length
:type min_tail_length: :class:`~aeneas.exacttiming.TimeValue`
:param max_tail_length: estimated maximum tail length
:type max_tail_length: :class:`~aeneas.exacttiming.TimeValue`
:rtype: (:class:`~aeneas.exacttiming.TimeValue`, :class:`~aeneas.exacttiming.TimeValue`)
:raises: TypeError: if one of the parameters is not ``None`` or a number
:raises: ValueError: if one of the parameters is negative
"""
head = self.detect_head(min_head_length, max_head_length)
tail = self.detect_tail(min_tail_length, max_tail_length)
begin = head
end = self.real_wave_mfcc.audio_length - tail
self.log([u"Audio length: %.3f", self.real_wave_mfcc.audio_length])
self.log([u"Head length: %.3f", head])
self.log([u"Tail length: %.3f", tail])
self.log([u"Begin: %.3f", begin])
self.log([u"End: %.3f", end])
if (begin >= TimeValue("0.000")) and (end > begin):
self.log([u"Returning %.3f %.3f", begin, end])
return (begin, end)
self.log(u"Returning (0.000, 0.000)")
return (TimeValue("0.000"), TimeValue("0.000")) | python | def detect_interval(
self,
min_head_length=None,
max_head_length=None,
min_tail_length=None,
max_tail_length=None
):
head = self.detect_head(min_head_length, max_head_length)
tail = self.detect_tail(min_tail_length, max_tail_length)
begin = head
end = self.real_wave_mfcc.audio_length - tail
self.log([u"Audio length: %.3f", self.real_wave_mfcc.audio_length])
self.log([u"Head length: %.3f", head])
self.log([u"Tail length: %.3f", tail])
self.log([u"Begin: %.3f", begin])
self.log([u"End: %.3f", end])
if (begin >= TimeValue("0.000")) and (end > begin):
self.log([u"Returning %.3f %.3f", begin, end])
return (begin, end)
self.log(u"Returning (0.000, 0.000)")
return (TimeValue("0.000"), TimeValue("0.000")) | [
"def",
"detect_interval",
"(",
"self",
",",
"min_head_length",
"=",
"None",
",",
"max_head_length",
"=",
"None",
",",
"min_tail_length",
"=",
"None",
",",
"max_tail_length",
"=",
"None",
")",
":",
"head",
"=",
"self",
".",
"detect_head",
"(",
"min_head_length"... | Detect the interval of the audio file
containing the fragments in the text file.
Return the audio interval as a tuple of two
:class:`~aeneas.exacttiming.TimeValue` objects,
representing the begin and end time, in seconds,
with respect to the full wave duration.
If one of the parameters is ``None``, the default value
(``0.0`` for min, ``10.0`` for max) will be used.
:param min_head_length: estimated minimum head length
:type min_head_length: :class:`~aeneas.exacttiming.TimeValue`
:param max_head_length: estimated maximum head length
:type max_head_length: :class:`~aeneas.exacttiming.TimeValue`
:param min_tail_length: estimated minimum tail length
:type min_tail_length: :class:`~aeneas.exacttiming.TimeValue`
:param max_tail_length: estimated maximum tail length
:type max_tail_length: :class:`~aeneas.exacttiming.TimeValue`
:rtype: (:class:`~aeneas.exacttiming.TimeValue`, :class:`~aeneas.exacttiming.TimeValue`)
:raises: TypeError: if one of the parameters is not ``None`` or a number
:raises: ValueError: if one of the parameters is negative | [
"Detect",
"the",
"interval",
"of",
"the",
"audio",
"file",
"containing",
"the",
"fragments",
"in",
"the",
"text",
"file",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/sd.py#L126-L170 |
245,949 | readbeyond/aeneas | aeneas/sd.py | SD.detect_head | def detect_head(self, min_head_length=None, max_head_length=None):
"""
Detect the audio head, returning its duration, in seconds.
:param min_head_length: estimated minimum head length
:type min_head_length: :class:`~aeneas.exacttiming.TimeValue`
:param max_head_length: estimated maximum head length
:type max_head_length: :class:`~aeneas.exacttiming.TimeValue`
:rtype: :class:`~aeneas.exacttiming.TimeValue`
:raises: TypeError: if one of the parameters is not ``None`` or a number
:raises: ValueError: if one of the parameters is negative
"""
return self._detect(min_head_length, max_head_length, tail=False) | python | def detect_head(self, min_head_length=None, max_head_length=None):
return self._detect(min_head_length, max_head_length, tail=False) | [
"def",
"detect_head",
"(",
"self",
",",
"min_head_length",
"=",
"None",
",",
"max_head_length",
"=",
"None",
")",
":",
"return",
"self",
".",
"_detect",
"(",
"min_head_length",
",",
"max_head_length",
",",
"tail",
"=",
"False",
")"
] | Detect the audio head, returning its duration, in seconds.
:param min_head_length: estimated minimum head length
:type min_head_length: :class:`~aeneas.exacttiming.TimeValue`
:param max_head_length: estimated maximum head length
:type max_head_length: :class:`~aeneas.exacttiming.TimeValue`
:rtype: :class:`~aeneas.exacttiming.TimeValue`
:raises: TypeError: if one of the parameters is not ``None`` or a number
:raises: ValueError: if one of the parameters is negative | [
"Detect",
"the",
"audio",
"head",
"returning",
"its",
"duration",
"in",
"seconds",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/sd.py#L172-L184 |
245,950 | readbeyond/aeneas | aeneas/sd.py | SD.detect_tail | def detect_tail(self, min_tail_length=None, max_tail_length=None):
"""
Detect the audio tail, returning its duration, in seconds.
:param min_tail_length: estimated minimum tail length
:type min_tail_length: :class:`~aeneas.exacttiming.TimeValue`
:param max_tail_length: estimated maximum tail length
:type max_tail_length: :class:`~aeneas.exacttiming.TimeValue`
:rtype: :class:`~aeneas.exacttiming.TimeValue`
:raises: TypeError: if one of the parameters is not ``None`` or a number
:raises: ValueError: if one of the parameters is negative
"""
return self._detect(min_tail_length, max_tail_length, tail=True) | python | def detect_tail(self, min_tail_length=None, max_tail_length=None):
return self._detect(min_tail_length, max_tail_length, tail=True) | [
"def",
"detect_tail",
"(",
"self",
",",
"min_tail_length",
"=",
"None",
",",
"max_tail_length",
"=",
"None",
")",
":",
"return",
"self",
".",
"_detect",
"(",
"min_tail_length",
",",
"max_tail_length",
",",
"tail",
"=",
"True",
")"
] | Detect the audio tail, returning its duration, in seconds.
:param min_tail_length: estimated minimum tail length
:type min_tail_length: :class:`~aeneas.exacttiming.TimeValue`
:param max_tail_length: estimated maximum tail length
:type max_tail_length: :class:`~aeneas.exacttiming.TimeValue`
:rtype: :class:`~aeneas.exacttiming.TimeValue`
:raises: TypeError: if one of the parameters is not ``None`` or a number
:raises: ValueError: if one of the parameters is negative | [
"Detect",
"the",
"audio",
"tail",
"returning",
"its",
"duration",
"in",
"seconds",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/sd.py#L186-L198 |
245,951 | readbeyond/aeneas | aeneas/synthesizer.py | Synthesizer._select_tts_engine | def _select_tts_engine(self):
"""
Select the TTS engine to be used by looking at the rconf object.
"""
self.log(u"Selecting TTS engine...")
requested_tts_engine = self.rconf[RuntimeConfiguration.TTS]
if requested_tts_engine == self.CUSTOM:
self.log(u"TTS engine: custom")
tts_path = self.rconf[RuntimeConfiguration.TTS_PATH]
if tts_path is None:
self.log_exc(u"You must specify a value for tts_path", None, True, ValueError)
if not gf.file_can_be_read(tts_path):
self.log_exc(u"Cannot read tts_path", None, True, OSError)
try:
import imp
self.log([u"Loading CustomTTSWrapper module from '%s'...", tts_path])
imp.load_source("CustomTTSWrapperModule", tts_path)
self.log([u"Loading CustomTTSWrapper module from '%s'... done", tts_path])
self.log(u"Importing CustomTTSWrapper...")
from CustomTTSWrapperModule import CustomTTSWrapper
self.log(u"Importing CustomTTSWrapper... done")
self.log(u"Creating CustomTTSWrapper instance...")
self.tts_engine = CustomTTSWrapper(rconf=self.rconf, logger=self.logger)
self.log(u"Creating CustomTTSWrapper instance... done")
except Exception as exc:
self.log_exc(u"Unable to load custom TTS wrapper", exc, True, OSError)
elif requested_tts_engine == self.AWS:
try:
import boto3
except ImportError as exc:
self.log_exc(u"Unable to import boto3 for AWS Polly TTS API wrapper", exc, True, ImportError)
self.log(u"TTS engine: AWS Polly TTS API")
self.tts_engine = AWSTTSWrapper(rconf=self.rconf, logger=self.logger)
elif requested_tts_engine == self.NUANCE:
try:
import requests
except ImportError as exc:
self.log_exc(u"Unable to import requests for Nuance TTS API wrapper", exc, True, ImportError)
self.log(u"TTS engine: Nuance TTS API")
self.tts_engine = NuanceTTSWrapper(rconf=self.rconf, logger=self.logger)
elif requested_tts_engine == self.ESPEAKNG:
self.log(u"TTS engine: eSpeak-ng")
self.tts_engine = ESPEAKNGTTSWrapper(rconf=self.rconf, logger=self.logger)
elif requested_tts_engine == self.FESTIVAL:
self.log(u"TTS engine: Festival")
self.tts_engine = FESTIVALTTSWrapper(rconf=self.rconf, logger=self.logger)
elif requested_tts_engine == self.MACOS:
self.log(u"TTS engine: macOS")
self.tts_engine = MacOSTTSWrapper(rconf=self.rconf, logger=self.logger)
else:
self.log(u"TTS engine: eSpeak")
self.tts_engine = ESPEAKTTSWrapper(rconf=self.rconf, logger=self.logger)
self.log(u"Selecting TTS engine... done") | python | def _select_tts_engine(self):
self.log(u"Selecting TTS engine...")
requested_tts_engine = self.rconf[RuntimeConfiguration.TTS]
if requested_tts_engine == self.CUSTOM:
self.log(u"TTS engine: custom")
tts_path = self.rconf[RuntimeConfiguration.TTS_PATH]
if tts_path is None:
self.log_exc(u"You must specify a value for tts_path", None, True, ValueError)
if not gf.file_can_be_read(tts_path):
self.log_exc(u"Cannot read tts_path", None, True, OSError)
try:
import imp
self.log([u"Loading CustomTTSWrapper module from '%s'...", tts_path])
imp.load_source("CustomTTSWrapperModule", tts_path)
self.log([u"Loading CustomTTSWrapper module from '%s'... done", tts_path])
self.log(u"Importing CustomTTSWrapper...")
from CustomTTSWrapperModule import CustomTTSWrapper
self.log(u"Importing CustomTTSWrapper... done")
self.log(u"Creating CustomTTSWrapper instance...")
self.tts_engine = CustomTTSWrapper(rconf=self.rconf, logger=self.logger)
self.log(u"Creating CustomTTSWrapper instance... done")
except Exception as exc:
self.log_exc(u"Unable to load custom TTS wrapper", exc, True, OSError)
elif requested_tts_engine == self.AWS:
try:
import boto3
except ImportError as exc:
self.log_exc(u"Unable to import boto3 for AWS Polly TTS API wrapper", exc, True, ImportError)
self.log(u"TTS engine: AWS Polly TTS API")
self.tts_engine = AWSTTSWrapper(rconf=self.rconf, logger=self.logger)
elif requested_tts_engine == self.NUANCE:
try:
import requests
except ImportError as exc:
self.log_exc(u"Unable to import requests for Nuance TTS API wrapper", exc, True, ImportError)
self.log(u"TTS engine: Nuance TTS API")
self.tts_engine = NuanceTTSWrapper(rconf=self.rconf, logger=self.logger)
elif requested_tts_engine == self.ESPEAKNG:
self.log(u"TTS engine: eSpeak-ng")
self.tts_engine = ESPEAKNGTTSWrapper(rconf=self.rconf, logger=self.logger)
elif requested_tts_engine == self.FESTIVAL:
self.log(u"TTS engine: Festival")
self.tts_engine = FESTIVALTTSWrapper(rconf=self.rconf, logger=self.logger)
elif requested_tts_engine == self.MACOS:
self.log(u"TTS engine: macOS")
self.tts_engine = MacOSTTSWrapper(rconf=self.rconf, logger=self.logger)
else:
self.log(u"TTS engine: eSpeak")
self.tts_engine = ESPEAKTTSWrapper(rconf=self.rconf, logger=self.logger)
self.log(u"Selecting TTS engine... done") | [
"def",
"_select_tts_engine",
"(",
"self",
")",
":",
"self",
".",
"log",
"(",
"u\"Selecting TTS engine...\"",
")",
"requested_tts_engine",
"=",
"self",
".",
"rconf",
"[",
"RuntimeConfiguration",
".",
"TTS",
"]",
"if",
"requested_tts_engine",
"==",
"self",
".",
"C... | Select the TTS engine to be used by looking at the rconf object. | [
"Select",
"the",
"TTS",
"engine",
"to",
"be",
"used",
"by",
"looking",
"at",
"the",
"rconf",
"object",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/synthesizer.py#L98-L150 |
245,952 | readbeyond/aeneas | aeneas/diagnostics.py | Diagnostics.check_shell_encoding | def check_shell_encoding(cls):
"""
Check whether ``sys.stdin`` and ``sys.stdout`` are UTF-8 encoded.
Return ``True`` on failure and ``False`` on success.
:rtype: bool
"""
is_in_utf8 = True
is_out_utf8 = True
if sys.stdin.encoding not in ["UTF-8", "UTF8"]:
is_in_utf8 = False
if sys.stdout.encoding not in ["UTF-8", "UTF8"]:
is_out_utf8 = False
if (is_in_utf8) and (is_out_utf8):
gf.print_success(u"shell encoding OK")
else:
gf.print_warning(u"shell encoding WARNING")
if not is_in_utf8:
gf.print_warning(u" The default input encoding of your shell is not UTF-8")
if not is_out_utf8:
gf.print_warning(u" The default output encoding of your shell is not UTF-8")
gf.print_info(u" If you plan to use aeneas on the command line,")
if gf.is_posix():
gf.print_info(u" you might want to 'export PYTHONIOENCODING=UTF-8' in your shell")
else:
gf.print_info(u" you might want to 'set PYTHONIOENCODING=UTF-8' in your shell")
return True
return False | python | def check_shell_encoding(cls):
is_in_utf8 = True
is_out_utf8 = True
if sys.stdin.encoding not in ["UTF-8", "UTF8"]:
is_in_utf8 = False
if sys.stdout.encoding not in ["UTF-8", "UTF8"]:
is_out_utf8 = False
if (is_in_utf8) and (is_out_utf8):
gf.print_success(u"shell encoding OK")
else:
gf.print_warning(u"shell encoding WARNING")
if not is_in_utf8:
gf.print_warning(u" The default input encoding of your shell is not UTF-8")
if not is_out_utf8:
gf.print_warning(u" The default output encoding of your shell is not UTF-8")
gf.print_info(u" If you plan to use aeneas on the command line,")
if gf.is_posix():
gf.print_info(u" you might want to 'export PYTHONIOENCODING=UTF-8' in your shell")
else:
gf.print_info(u" you might want to 'set PYTHONIOENCODING=UTF-8' in your shell")
return True
return False | [
"def",
"check_shell_encoding",
"(",
"cls",
")",
":",
"is_in_utf8",
"=",
"True",
"is_out_utf8",
"=",
"True",
"if",
"sys",
".",
"stdin",
".",
"encoding",
"not",
"in",
"[",
"\"UTF-8\"",
",",
"\"UTF8\"",
"]",
":",
"is_in_utf8",
"=",
"False",
"if",
"sys",
"."... | Check whether ``sys.stdin`` and ``sys.stdout`` are UTF-8 encoded.
Return ``True`` on failure and ``False`` on success.
:rtype: bool | [
"Check",
"whether",
"sys",
".",
"stdin",
"and",
"sys",
".",
"stdout",
"are",
"UTF",
"-",
"8",
"encoded",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/diagnostics.py#L49-L77 |
245,953 | readbeyond/aeneas | aeneas/diagnostics.py | Diagnostics.check_ffprobe | def check_ffprobe(cls):
"""
Check whether ``ffprobe`` can be called.
Return ``True`` on failure and ``False`` on success.
:rtype: bool
"""
try:
from aeneas.ffprobewrapper import FFPROBEWrapper
file_path = gf.absolute_path(u"tools/res/audio.mp3", __file__)
prober = FFPROBEWrapper()
properties = prober.read_properties(file_path)
gf.print_success(u"ffprobe OK")
return False
except:
pass
gf.print_error(u"ffprobe ERROR")
gf.print_info(u" Please make sure you have ffprobe installed correctly")
gf.print_info(u" (usually it is provided by the ffmpeg installer)")
gf.print_info(u" and that its path is in your PATH environment variable")
return True | python | def check_ffprobe(cls):
try:
from aeneas.ffprobewrapper import FFPROBEWrapper
file_path = gf.absolute_path(u"tools/res/audio.mp3", __file__)
prober = FFPROBEWrapper()
properties = prober.read_properties(file_path)
gf.print_success(u"ffprobe OK")
return False
except:
pass
gf.print_error(u"ffprobe ERROR")
gf.print_info(u" Please make sure you have ffprobe installed correctly")
gf.print_info(u" (usually it is provided by the ffmpeg installer)")
gf.print_info(u" and that its path is in your PATH environment variable")
return True | [
"def",
"check_ffprobe",
"(",
"cls",
")",
":",
"try",
":",
"from",
"aeneas",
".",
"ffprobewrapper",
"import",
"FFPROBEWrapper",
"file_path",
"=",
"gf",
".",
"absolute_path",
"(",
"u\"tools/res/audio.mp3\"",
",",
"__file__",
")",
"prober",
"=",
"FFPROBEWrapper",
"... | Check whether ``ffprobe`` can be called.
Return ``True`` on failure and ``False`` on success.
:rtype: bool | [
"Check",
"whether",
"ffprobe",
"can",
"be",
"called",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/diagnostics.py#L80-L101 |
245,954 | readbeyond/aeneas | aeneas/diagnostics.py | Diagnostics.check_ffmpeg | def check_ffmpeg(cls):
"""
Check whether ``ffmpeg`` can be called.
Return ``True`` on failure and ``False`` on success.
:rtype: bool
"""
try:
from aeneas.ffmpegwrapper import FFMPEGWrapper
input_file_path = gf.absolute_path(u"tools/res/audio.mp3", __file__)
handler, output_file_path = gf.tmp_file(suffix=u".wav")
converter = FFMPEGWrapper()
result = converter.convert(input_file_path, output_file_path)
gf.delete_file(handler, output_file_path)
if result:
gf.print_success(u"ffmpeg OK")
return False
except:
pass
gf.print_error(u"ffmpeg ERROR")
gf.print_info(u" Please make sure you have ffmpeg installed correctly")
gf.print_info(u" and that its path is in your PATH environment variable")
return True | python | def check_ffmpeg(cls):
try:
from aeneas.ffmpegwrapper import FFMPEGWrapper
input_file_path = gf.absolute_path(u"tools/res/audio.mp3", __file__)
handler, output_file_path = gf.tmp_file(suffix=u".wav")
converter = FFMPEGWrapper()
result = converter.convert(input_file_path, output_file_path)
gf.delete_file(handler, output_file_path)
if result:
gf.print_success(u"ffmpeg OK")
return False
except:
pass
gf.print_error(u"ffmpeg ERROR")
gf.print_info(u" Please make sure you have ffmpeg installed correctly")
gf.print_info(u" and that its path is in your PATH environment variable")
return True | [
"def",
"check_ffmpeg",
"(",
"cls",
")",
":",
"try",
":",
"from",
"aeneas",
".",
"ffmpegwrapper",
"import",
"FFMPEGWrapper",
"input_file_path",
"=",
"gf",
".",
"absolute_path",
"(",
"u\"tools/res/audio.mp3\"",
",",
"__file__",
")",
"handler",
",",
"output_file_path... | Check whether ``ffmpeg`` can be called.
Return ``True`` on failure and ``False`` on success.
:rtype: bool | [
"Check",
"whether",
"ffmpeg",
"can",
"be",
"called",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/diagnostics.py#L104-L127 |
245,955 | readbeyond/aeneas | aeneas/diagnostics.py | Diagnostics.check_espeak | def check_espeak(cls):
"""
Check whether ``espeak`` can be called.
Return ``True`` on failure and ``False`` on success.
:rtype: bool
"""
try:
from aeneas.textfile import TextFile
from aeneas.textfile import TextFragment
from aeneas.ttswrappers.espeakttswrapper import ESPEAKTTSWrapper
text = u"From fairest creatures we desire increase,"
text_file = TextFile()
text_file.add_fragment(TextFragment(language=u"eng", lines=[text], filtered_lines=[text]))
handler, output_file_path = gf.tmp_file(suffix=u".wav")
ESPEAKTTSWrapper().synthesize_multiple(text_file, output_file_path)
gf.delete_file(handler, output_file_path)
gf.print_success(u"espeak OK")
return False
except:
pass
gf.print_error(u"espeak ERROR")
gf.print_info(u" Please make sure you have espeak installed correctly")
gf.print_info(u" and that its path is in your PATH environment variable")
gf.print_info(u" You might also want to check that the espeak-data directory")
gf.print_info(u" is set up correctly, for example, it has the correct permissions")
return True | python | def check_espeak(cls):
try:
from aeneas.textfile import TextFile
from aeneas.textfile import TextFragment
from aeneas.ttswrappers.espeakttswrapper import ESPEAKTTSWrapper
text = u"From fairest creatures we desire increase,"
text_file = TextFile()
text_file.add_fragment(TextFragment(language=u"eng", lines=[text], filtered_lines=[text]))
handler, output_file_path = gf.tmp_file(suffix=u".wav")
ESPEAKTTSWrapper().synthesize_multiple(text_file, output_file_path)
gf.delete_file(handler, output_file_path)
gf.print_success(u"espeak OK")
return False
except:
pass
gf.print_error(u"espeak ERROR")
gf.print_info(u" Please make sure you have espeak installed correctly")
gf.print_info(u" and that its path is in your PATH environment variable")
gf.print_info(u" You might also want to check that the espeak-data directory")
gf.print_info(u" is set up correctly, for example, it has the correct permissions")
return True | [
"def",
"check_espeak",
"(",
"cls",
")",
":",
"try",
":",
"from",
"aeneas",
".",
"textfile",
"import",
"TextFile",
"from",
"aeneas",
".",
"textfile",
"import",
"TextFragment",
"from",
"aeneas",
".",
"ttswrappers",
".",
"espeakttswrapper",
"import",
"ESPEAKTTSWrap... | Check whether ``espeak`` can be called.
Return ``True`` on failure and ``False`` on success.
:rtype: bool | [
"Check",
"whether",
"espeak",
"can",
"be",
"called",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/diagnostics.py#L130-L157 |
245,956 | readbeyond/aeneas | aeneas/diagnostics.py | Diagnostics.check_cdtw | def check_cdtw(cls):
"""
Check whether Python C extension ``cdtw`` can be imported.
Return ``True`` on failure and ``False`` on success.
:rtype: bool
"""
if gf.can_run_c_extension("cdtw"):
gf.print_success(u"aeneas.cdtw AVAILABLE")
return False
gf.print_warning(u"aeneas.cdtw NOT AVAILABLE")
gf.print_info(u" You can still run aeneas but it will be significantly slower")
gf.print_info(u" Please refer to the installation documentation for details")
return True | python | def check_cdtw(cls):
if gf.can_run_c_extension("cdtw"):
gf.print_success(u"aeneas.cdtw AVAILABLE")
return False
gf.print_warning(u"aeneas.cdtw NOT AVAILABLE")
gf.print_info(u" You can still run aeneas but it will be significantly slower")
gf.print_info(u" Please refer to the installation documentation for details")
return True | [
"def",
"check_cdtw",
"(",
"cls",
")",
":",
"if",
"gf",
".",
"can_run_c_extension",
"(",
"\"cdtw\"",
")",
":",
"gf",
".",
"print_success",
"(",
"u\"aeneas.cdtw AVAILABLE\"",
")",
"return",
"False",
"gf",
".",
"print_warning",
"(",
"u\"aeneas.cdtw NOT AVAILABL... | Check whether Python C extension ``cdtw`` can be imported.
Return ``True`` on failure and ``False`` on success.
:rtype: bool | [
"Check",
"whether",
"Python",
"C",
"extension",
"cdtw",
"can",
"be",
"imported",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/diagnostics.py#L195-L209 |
245,957 | readbeyond/aeneas | aeneas/diagnostics.py | Diagnostics.check_cmfcc | def check_cmfcc(cls):
"""
Check whether Python C extension ``cmfcc`` can be imported.
Return ``True`` on failure and ``False`` on success.
:rtype: bool
"""
if gf.can_run_c_extension("cmfcc"):
gf.print_success(u"aeneas.cmfcc AVAILABLE")
return False
gf.print_warning(u"aeneas.cmfcc NOT AVAILABLE")
gf.print_info(u" You can still run aeneas but it will be significantly slower")
gf.print_info(u" Please refer to the installation documentation for details")
return True | python | def check_cmfcc(cls):
if gf.can_run_c_extension("cmfcc"):
gf.print_success(u"aeneas.cmfcc AVAILABLE")
return False
gf.print_warning(u"aeneas.cmfcc NOT AVAILABLE")
gf.print_info(u" You can still run aeneas but it will be significantly slower")
gf.print_info(u" Please refer to the installation documentation for details")
return True | [
"def",
"check_cmfcc",
"(",
"cls",
")",
":",
"if",
"gf",
".",
"can_run_c_extension",
"(",
"\"cmfcc\"",
")",
":",
"gf",
".",
"print_success",
"(",
"u\"aeneas.cmfcc AVAILABLE\"",
")",
"return",
"False",
"gf",
".",
"print_warning",
"(",
"u\"aeneas.cmfcc NOT AVAILA... | Check whether Python C extension ``cmfcc`` can be imported.
Return ``True`` on failure and ``False`` on success.
:rtype: bool | [
"Check",
"whether",
"Python",
"C",
"extension",
"cmfcc",
"can",
"be",
"imported",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/diagnostics.py#L212-L226 |
245,958 | readbeyond/aeneas | aeneas/diagnostics.py | Diagnostics.check_cew | def check_cew(cls):
"""
Check whether Python C extension ``cew`` can be imported.
Return ``True`` on failure and ``False`` on success.
:rtype: bool
"""
if gf.can_run_c_extension("cew"):
gf.print_success(u"aeneas.cew AVAILABLE")
return False
gf.print_warning(u"aeneas.cew NOT AVAILABLE")
gf.print_info(u" You can still run aeneas but it will be a bit slower")
gf.print_info(u" Please refer to the installation documentation for details")
return True | python | def check_cew(cls):
if gf.can_run_c_extension("cew"):
gf.print_success(u"aeneas.cew AVAILABLE")
return False
gf.print_warning(u"aeneas.cew NOT AVAILABLE")
gf.print_info(u" You can still run aeneas but it will be a bit slower")
gf.print_info(u" Please refer to the installation documentation for details")
return True | [
"def",
"check_cew",
"(",
"cls",
")",
":",
"if",
"gf",
".",
"can_run_c_extension",
"(",
"\"cew\"",
")",
":",
"gf",
".",
"print_success",
"(",
"u\"aeneas.cew AVAILABLE\"",
")",
"return",
"False",
"gf",
".",
"print_warning",
"(",
"u\"aeneas.cew NOT AVAILABLE\... | Check whether Python C extension ``cew`` can be imported.
Return ``True`` on failure and ``False`` on success.
:rtype: bool | [
"Check",
"whether",
"Python",
"C",
"extension",
"cew",
"can",
"be",
"imported",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/diagnostics.py#L229-L243 |
245,959 | readbeyond/aeneas | aeneas/diagnostics.py | Diagnostics.check_all | def check_all(cls, tools=True, encoding=True, c_ext=True):
"""
Perform all checks.
Return a tuple of booleans ``(errors, warnings, c_ext_warnings)``.
:param bool tools: if ``True``, check aeneas tools
:param bool encoding: if ``True``, check shell encoding
:param bool c_ext: if ``True``, check Python C extensions
:rtype: (bool, bool, bool)
"""
# errors are fatal
if cls.check_ffprobe():
return (True, False, False)
if cls.check_ffmpeg():
return (True, False, False)
if cls.check_espeak():
return (True, False, False)
if (tools) and (cls.check_tools()):
return (True, False, False)
# warnings are non-fatal
warnings = False
c_ext_warnings = False
if encoding:
warnings = cls.check_shell_encoding()
if c_ext:
# we do not want lazy evaluation
c_ext_warnings = cls.check_cdtw() or c_ext_warnings
c_ext_warnings = cls.check_cmfcc() or c_ext_warnings
c_ext_warnings = cls.check_cew() or c_ext_warnings
# return results
return (False, warnings, c_ext_warnings) | python | def check_all(cls, tools=True, encoding=True, c_ext=True):
# errors are fatal
if cls.check_ffprobe():
return (True, False, False)
if cls.check_ffmpeg():
return (True, False, False)
if cls.check_espeak():
return (True, False, False)
if (tools) and (cls.check_tools()):
return (True, False, False)
# warnings are non-fatal
warnings = False
c_ext_warnings = False
if encoding:
warnings = cls.check_shell_encoding()
if c_ext:
# we do not want lazy evaluation
c_ext_warnings = cls.check_cdtw() or c_ext_warnings
c_ext_warnings = cls.check_cmfcc() or c_ext_warnings
c_ext_warnings = cls.check_cew() or c_ext_warnings
# return results
return (False, warnings, c_ext_warnings) | [
"def",
"check_all",
"(",
"cls",
",",
"tools",
"=",
"True",
",",
"encoding",
"=",
"True",
",",
"c_ext",
"=",
"True",
")",
":",
"# errors are fatal",
"if",
"cls",
".",
"check_ffprobe",
"(",
")",
":",
"return",
"(",
"True",
",",
"False",
",",
"False",
"... | Perform all checks.
Return a tuple of booleans ``(errors, warnings, c_ext_warnings)``.
:param bool tools: if ``True``, check aeneas tools
:param bool encoding: if ``True``, check shell encoding
:param bool c_ext: if ``True``, check Python C extensions
:rtype: (bool, bool, bool) | [
"Perform",
"all",
"checks",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/diagnostics.py#L246-L277 |
245,960 | readbeyond/aeneas | aeneas/configuration.py | Configuration.config_string | def config_string(self):
"""
Build the storable string corresponding
to this configuration object.
:rtype: string
"""
return (gc.CONFIG_STRING_SEPARATOR_SYMBOL).join(
[u"%s%s%s" % (fn, gc.CONFIG_STRING_ASSIGNMENT_SYMBOL, self.data[fn]) for fn in sorted(self.data.keys()) if self.data[fn] is not None]
) | python | def config_string(self):
return (gc.CONFIG_STRING_SEPARATOR_SYMBOL).join(
[u"%s%s%s" % (fn, gc.CONFIG_STRING_ASSIGNMENT_SYMBOL, self.data[fn]) for fn in sorted(self.data.keys()) if self.data[fn] is not None]
) | [
"def",
"config_string",
"(",
"self",
")",
":",
"return",
"(",
"gc",
".",
"CONFIG_STRING_SEPARATOR_SYMBOL",
")",
".",
"join",
"(",
"[",
"u\"%s%s%s\"",
"%",
"(",
"fn",
",",
"gc",
".",
"CONFIG_STRING_ASSIGNMENT_SYMBOL",
",",
"self",
".",
"data",
"[",
"fn",
"]... | Build the storable string corresponding
to this configuration object.
:rtype: string | [
"Build",
"the",
"storable",
"string",
"corresponding",
"to",
"this",
"configuration",
"object",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/configuration.py#L169-L178 |
245,961 | readbeyond/aeneas | aeneas/exacttiming.py | TimeValue.geq_multiple | def geq_multiple(self, other):
"""
Return the next multiple of this time value,
greater than or equal to ``other``.
If ``other`` is zero, return this time value.
:rtype: :class:`~aeneas.exacttiming.TimeValue`
"""
if other == TimeValue("0.000"):
return self
return int(math.ceil(other / self)) * self | python | def geq_multiple(self, other):
if other == TimeValue("0.000"):
return self
return int(math.ceil(other / self)) * self | [
"def",
"geq_multiple",
"(",
"self",
",",
"other",
")",
":",
"if",
"other",
"==",
"TimeValue",
"(",
"\"0.000\"",
")",
":",
"return",
"self",
"return",
"int",
"(",
"math",
".",
"ceil",
"(",
"other",
"/",
"self",
")",
")",
"*",
"self"
] | Return the next multiple of this time value,
greater than or equal to ``other``.
If ``other`` is zero, return this time value.
:rtype: :class:`~aeneas.exacttiming.TimeValue` | [
"Return",
"the",
"next",
"multiple",
"of",
"this",
"time",
"value",
"greater",
"than",
"or",
"equal",
"to",
"other",
".",
"If",
"other",
"is",
"zero",
"return",
"this",
"time",
"value",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/exacttiming.py#L67-L77 |
245,962 | readbeyond/aeneas | aeneas/exacttiming.py | TimeInterval.starts_at | def starts_at(self, time_point):
"""
Returns ``True`` if this interval starts at the given time point.
:param time_point: the time point to test
:type time_point: :class:`~aeneas.exacttiming.TimeValue`
:raises TypeError: if ``time_point`` is not an instance of ``TimeValue``
:rtype: bool
"""
if not isinstance(time_point, TimeValue):
raise TypeError(u"time_point is not an instance of TimeValue")
return self.begin == time_point | python | def starts_at(self, time_point):
if not isinstance(time_point, TimeValue):
raise TypeError(u"time_point is not an instance of TimeValue")
return self.begin == time_point | [
"def",
"starts_at",
"(",
"self",
",",
"time_point",
")",
":",
"if",
"not",
"isinstance",
"(",
"time_point",
",",
"TimeValue",
")",
":",
"raise",
"TypeError",
"(",
"u\"time_point is not an instance of TimeValue\"",
")",
"return",
"self",
".",
"begin",
"==",
"time... | Returns ``True`` if this interval starts at the given time point.
:param time_point: the time point to test
:type time_point: :class:`~aeneas.exacttiming.TimeValue`
:raises TypeError: if ``time_point`` is not an instance of ``TimeValue``
:rtype: bool | [
"Returns",
"True",
"if",
"this",
"interval",
"starts",
"at",
"the",
"given",
"time",
"point",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/exacttiming.py#L371-L382 |
245,963 | readbeyond/aeneas | aeneas/exacttiming.py | TimeInterval.ends_at | def ends_at(self, time_point):
"""
Returns ``True`` if this interval ends at the given time point.
:param time_point: the time point to test
:type time_point: :class:`~aeneas.exacttiming.TimeValue`
:raises TypeError: if ``time_point`` is not an instance of ``TimeValue``
:rtype: bool
"""
if not isinstance(time_point, TimeValue):
raise TypeError(u"time_point is not an instance of TimeValue")
return self.end == time_point | python | def ends_at(self, time_point):
if not isinstance(time_point, TimeValue):
raise TypeError(u"time_point is not an instance of TimeValue")
return self.end == time_point | [
"def",
"ends_at",
"(",
"self",
",",
"time_point",
")",
":",
"if",
"not",
"isinstance",
"(",
"time_point",
",",
"TimeValue",
")",
":",
"raise",
"TypeError",
"(",
"u\"time_point is not an instance of TimeValue\"",
")",
"return",
"self",
".",
"end",
"==",
"time_poi... | Returns ``True`` if this interval ends at the given time point.
:param time_point: the time point to test
:type time_point: :class:`~aeneas.exacttiming.TimeValue`
:raises TypeError: if ``time_point`` is not an instance of ``TimeValue``
:rtype: bool | [
"Returns",
"True",
"if",
"this",
"interval",
"ends",
"at",
"the",
"given",
"time",
"point",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/exacttiming.py#L384-L395 |
245,964 | readbeyond/aeneas | aeneas/exacttiming.py | TimeInterval.percent_value | def percent_value(self, percent):
"""
Returns the time value at ``percent`` of this interval.
:param percent: the percent
:type percent: :class:`~aeneas.exacttiming.Decimal`
:raises TypeError: if ``time_point`` is not an instance of ``TimeValue``
:rtype: :class:`~aeneas.exacttiming.TimeValue`
"""
if not isinstance(percent, Decimal):
raise TypeError(u"percent is not an instance of Decimal")
percent = Decimal(max(min(percent, 100), 0) / 100)
return self.begin + self.length * percent | python | def percent_value(self, percent):
if not isinstance(percent, Decimal):
raise TypeError(u"percent is not an instance of Decimal")
percent = Decimal(max(min(percent, 100), 0) / 100)
return self.begin + self.length * percent | [
"def",
"percent_value",
"(",
"self",
",",
"percent",
")",
":",
"if",
"not",
"isinstance",
"(",
"percent",
",",
"Decimal",
")",
":",
"raise",
"TypeError",
"(",
"u\"percent is not an instance of Decimal\"",
")",
"percent",
"=",
"Decimal",
"(",
"max",
"(",
"min",... | Returns the time value at ``percent`` of this interval.
:param percent: the percent
:type percent: :class:`~aeneas.exacttiming.Decimal`
:raises TypeError: if ``time_point`` is not an instance of ``TimeValue``
:rtype: :class:`~aeneas.exacttiming.TimeValue` | [
"Returns",
"the",
"time",
"value",
"at",
"percent",
"of",
"this",
"interval",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/exacttiming.py#L397-L409 |
245,965 | readbeyond/aeneas | aeneas/exacttiming.py | TimeInterval.offset | def offset(self, offset, allow_negative=False, min_begin_value=None, max_end_value=None):
"""
Move this interval by the given shift ``offset``.
The begin and end time points of the translated interval
are ensured to be non-negative
(i.e., they are maxed with ``0.000``),
unless ``allow_negative`` is set to ``True``.
:param offset: the shift to be applied
:type offset: :class:`~aeneas.exacttiming.TimeValue`
:param allow_negative: if ``True``, allow the translated interval to have negative extrema
:type allow_negative: bool
:param min_begin_value: if not ``None``, specify the minimum value for the begin of the translated interval
:type min_begin_value: :class:`~aeneas.exacttiming.TimeValue`
:param max_begin_value: if not ``None``, specify the maximum value for the end of the translated interval
:type max_begin_value: :class:`~aeneas.exacttiming.TimeValue`
:raises TypeError: if ``offset`` is not an instance of ``TimeValue``
:rtype: :class:`~aeneas.exacttiming.TimeInterval`
"""
if not isinstance(offset, TimeValue):
raise TypeError(u"offset is not an instance of TimeValue")
self.begin += offset
self.end += offset
if not allow_negative:
self.begin = max(self.begin, TimeValue("0.000"))
self.end = max(self.end, TimeValue("0.000"))
if (min_begin_value is not None) and (max_end_value is not None):
self.begin = min(max(self.begin, min_begin_value), max_end_value)
self.end = min(self.end, max_end_value)
return self | python | def offset(self, offset, allow_negative=False, min_begin_value=None, max_end_value=None):
if not isinstance(offset, TimeValue):
raise TypeError(u"offset is not an instance of TimeValue")
self.begin += offset
self.end += offset
if not allow_negative:
self.begin = max(self.begin, TimeValue("0.000"))
self.end = max(self.end, TimeValue("0.000"))
if (min_begin_value is not None) and (max_end_value is not None):
self.begin = min(max(self.begin, min_begin_value), max_end_value)
self.end = min(self.end, max_end_value)
return self | [
"def",
"offset",
"(",
"self",
",",
"offset",
",",
"allow_negative",
"=",
"False",
",",
"min_begin_value",
"=",
"None",
",",
"max_end_value",
"=",
"None",
")",
":",
"if",
"not",
"isinstance",
"(",
"offset",
",",
"TimeValue",
")",
":",
"raise",
"TypeError",
... | Move this interval by the given shift ``offset``.
The begin and end time points of the translated interval
are ensured to be non-negative
(i.e., they are maxed with ``0.000``),
unless ``allow_negative`` is set to ``True``.
:param offset: the shift to be applied
:type offset: :class:`~aeneas.exacttiming.TimeValue`
:param allow_negative: if ``True``, allow the translated interval to have negative extrema
:type allow_negative: bool
:param min_begin_value: if not ``None``, specify the minimum value for the begin of the translated interval
:type min_begin_value: :class:`~aeneas.exacttiming.TimeValue`
:param max_begin_value: if not ``None``, specify the maximum value for the end of the translated interval
:type max_begin_value: :class:`~aeneas.exacttiming.TimeValue`
:raises TypeError: if ``offset`` is not an instance of ``TimeValue``
:rtype: :class:`~aeneas.exacttiming.TimeInterval` | [
"Move",
"this",
"interval",
"by",
"the",
"given",
"shift",
"offset",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/exacttiming.py#L411-L441 |
245,966 | readbeyond/aeneas | aeneas/exacttiming.py | TimeInterval.intersection | def intersection(self, other):
"""
Return the intersection between this time interval
and the given time interval, or
``None`` if the two intervals do not overlap.
:rtype: :class:`~aeneas.exacttiming.TimeInterval` or ``NoneType``
"""
relative_position = self.relative_position_of(other)
if relative_position in [
self.RELATIVE_POSITION_PP_C,
self.RELATIVE_POSITION_PI_LC,
self.RELATIVE_POSITION_PI_LG,
self.RELATIVE_POSITION_PI_CG,
self.RELATIVE_POSITION_IP_B,
self.RELATIVE_POSITION_II_LB,
]:
return TimeInterval(begin=self.begin, end=self.begin)
if relative_position in [
self.RELATIVE_POSITION_IP_E,
self.RELATIVE_POSITION_II_EG,
]:
return TimeInterval(begin=self.end, end=self.end)
if relative_position in [
self.RELATIVE_POSITION_II_BI,
self.RELATIVE_POSITION_II_BE,
self.RELATIVE_POSITION_II_II,
self.RELATIVE_POSITION_II_IE,
]:
return TimeInterval(begin=other.begin, end=other.end)
if relative_position in [
self.RELATIVE_POSITION_IP_I,
self.RELATIVE_POSITION_II_LI,
self.RELATIVE_POSITION_II_LE,
self.RELATIVE_POSITION_II_LG,
self.RELATIVE_POSITION_II_BG,
self.RELATIVE_POSITION_II_IG,
]:
begin = max(self.begin, other.begin)
end = min(self.end, other.end)
return TimeInterval(begin=begin, end=end)
return None | python | def intersection(self, other):
relative_position = self.relative_position_of(other)
if relative_position in [
self.RELATIVE_POSITION_PP_C,
self.RELATIVE_POSITION_PI_LC,
self.RELATIVE_POSITION_PI_LG,
self.RELATIVE_POSITION_PI_CG,
self.RELATIVE_POSITION_IP_B,
self.RELATIVE_POSITION_II_LB,
]:
return TimeInterval(begin=self.begin, end=self.begin)
if relative_position in [
self.RELATIVE_POSITION_IP_E,
self.RELATIVE_POSITION_II_EG,
]:
return TimeInterval(begin=self.end, end=self.end)
if relative_position in [
self.RELATIVE_POSITION_II_BI,
self.RELATIVE_POSITION_II_BE,
self.RELATIVE_POSITION_II_II,
self.RELATIVE_POSITION_II_IE,
]:
return TimeInterval(begin=other.begin, end=other.end)
if relative_position in [
self.RELATIVE_POSITION_IP_I,
self.RELATIVE_POSITION_II_LI,
self.RELATIVE_POSITION_II_LE,
self.RELATIVE_POSITION_II_LG,
self.RELATIVE_POSITION_II_BG,
self.RELATIVE_POSITION_II_IG,
]:
begin = max(self.begin, other.begin)
end = min(self.end, other.end)
return TimeInterval(begin=begin, end=end)
return None | [
"def",
"intersection",
"(",
"self",
",",
"other",
")",
":",
"relative_position",
"=",
"self",
".",
"relative_position_of",
"(",
"other",
")",
"if",
"relative_position",
"in",
"[",
"self",
".",
"RELATIVE_POSITION_PP_C",
",",
"self",
".",
"RELATIVE_POSITION_PI_LC",
... | Return the intersection between this time interval
and the given time interval, or
``None`` if the two intervals do not overlap.
:rtype: :class:`~aeneas.exacttiming.TimeInterval` or ``NoneType`` | [
"Return",
"the",
"intersection",
"between",
"this",
"time",
"interval",
"and",
"the",
"given",
"time",
"interval",
"or",
"None",
"if",
"the",
"two",
"intervals",
"do",
"not",
"overlap",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/exacttiming.py#L569-L610 |
245,967 | readbeyond/aeneas | aeneas/exacttiming.py | TimeInterval.is_non_zero_before_non_zero | def is_non_zero_before_non_zero(self, other):
"""
Return ``True`` if this time interval ends
when the given other time interval begins,
and both have non zero length.
:param other: the other interval
:type other: :class:`~aeneas.exacttiming.TimeInterval`
:raises TypeError: if ``other`` is not an instance of ``TimeInterval``
:rtype: bool
"""
return self.is_adjacent_before(other) and (not self.has_zero_length) and (not other.has_zero_length) | python | def is_non_zero_before_non_zero(self, other):
return self.is_adjacent_before(other) and (not self.has_zero_length) and (not other.has_zero_length) | [
"def",
"is_non_zero_before_non_zero",
"(",
"self",
",",
"other",
")",
":",
"return",
"self",
".",
"is_adjacent_before",
"(",
"other",
")",
"and",
"(",
"not",
"self",
".",
"has_zero_length",
")",
"and",
"(",
"not",
"other",
".",
"has_zero_length",
")"
] | Return ``True`` if this time interval ends
when the given other time interval begins,
and both have non zero length.
:param other: the other interval
:type other: :class:`~aeneas.exacttiming.TimeInterval`
:raises TypeError: if ``other`` is not an instance of ``TimeInterval``
:rtype: bool | [
"Return",
"True",
"if",
"this",
"time",
"interval",
"ends",
"when",
"the",
"given",
"other",
"time",
"interval",
"begins",
"and",
"both",
"have",
"non",
"zero",
"length",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/exacttiming.py#L623-L634 |
245,968 | readbeyond/aeneas | aeneas/exacttiming.py | TimeInterval.is_adjacent_before | def is_adjacent_before(self, other):
"""
Return ``True`` if this time interval ends
when the given other time interval begins.
:param other: the other interval
:type other: :class:`~aeneas.exacttiming.TimeInterval`
:raises TypeError: if ``other`` is not an instance of ``TimeInterval``
:rtype: bool
"""
if not isinstance(other, TimeInterval):
raise TypeError(u"other is not an instance of TimeInterval")
return (self.end == other.begin) | python | def is_adjacent_before(self, other):
if not isinstance(other, TimeInterval):
raise TypeError(u"other is not an instance of TimeInterval")
return (self.end == other.begin) | [
"def",
"is_adjacent_before",
"(",
"self",
",",
"other",
")",
":",
"if",
"not",
"isinstance",
"(",
"other",
",",
"TimeInterval",
")",
":",
"raise",
"TypeError",
"(",
"u\"other is not an instance of TimeInterval\"",
")",
"return",
"(",
"self",
".",
"end",
"==",
... | Return ``True`` if this time interval ends
when the given other time interval begins.
:param other: the other interval
:type other: :class:`~aeneas.exacttiming.TimeInterval`
:raises TypeError: if ``other`` is not an instance of ``TimeInterval``
:rtype: bool | [
"Return",
"True",
"if",
"this",
"time",
"interval",
"ends",
"when",
"the",
"given",
"other",
"time",
"interval",
"begins",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/exacttiming.py#L649-L661 |
245,969 | readbeyond/aeneas | aeneas/tools/convert_syncmap.py | ConvertSyncMapCLI.check_format | def check_format(self, sm_format):
"""
Return ``True`` if the given sync map format is allowed,
and ``False`` otherwise.
:param sm_format: the sync map format to be checked
:type sm_format: Unicode string
:rtype: bool
"""
if sm_format not in SyncMapFormat.ALLOWED_VALUES:
self.print_error(u"Sync map format '%s' is not allowed" % (sm_format))
self.print_info(u"Allowed formats:")
self.print_generic(u" ".join(SyncMapFormat.ALLOWED_VALUES))
return False
return True | python | def check_format(self, sm_format):
if sm_format not in SyncMapFormat.ALLOWED_VALUES:
self.print_error(u"Sync map format '%s' is not allowed" % (sm_format))
self.print_info(u"Allowed formats:")
self.print_generic(u" ".join(SyncMapFormat.ALLOWED_VALUES))
return False
return True | [
"def",
"check_format",
"(",
"self",
",",
"sm_format",
")",
":",
"if",
"sm_format",
"not",
"in",
"SyncMapFormat",
".",
"ALLOWED_VALUES",
":",
"self",
".",
"print_error",
"(",
"u\"Sync map format '%s' is not allowed\"",
"%",
"(",
"sm_format",
")",
")",
"self",
"."... | Return ``True`` if the given sync map format is allowed,
and ``False`` otherwise.
:param sm_format: the sync map format to be checked
:type sm_format: Unicode string
:rtype: bool | [
"Return",
"True",
"if",
"the",
"given",
"sync",
"map",
"format",
"is",
"allowed",
"and",
"False",
"otherwise",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/convert_syncmap.py#L163-L177 |
245,970 | readbeyond/aeneas | aeneas/syncmap/smfbase.py | SyncMapFormatBase._add_fragment | def _add_fragment(cls, syncmap, identifier, lines, begin, end, language=None):
"""
Add a new fragment to ``syncmap``.
:param syncmap: the syncmap to append to
:type syncmap: :class:`~aeneas.syncmap.SyncMap`
:param identifier: the identifier
:type identifier: string
:param lines: the lines of the text
:type lines: list of string
:param begin: the begin time
:type begin: :class:`~aeneas.exacttiming.TimeValue`
:param end: the end time
:type end: :class:`~aeneas.exacttiming.TimeValue`
:param language: the language
:type language: string
"""
syncmap.add_fragment(
SyncMapFragment(
text_fragment=TextFragment(
identifier=identifier,
lines=lines,
language=language
),
begin=begin,
end=end
)
) | python | def _add_fragment(cls, syncmap, identifier, lines, begin, end, language=None):
syncmap.add_fragment(
SyncMapFragment(
text_fragment=TextFragment(
identifier=identifier,
lines=lines,
language=language
),
begin=begin,
end=end
)
) | [
"def",
"_add_fragment",
"(",
"cls",
",",
"syncmap",
",",
"identifier",
",",
"lines",
",",
"begin",
",",
"end",
",",
"language",
"=",
"None",
")",
":",
"syncmap",
".",
"add_fragment",
"(",
"SyncMapFragment",
"(",
"text_fragment",
"=",
"TextFragment",
"(",
"... | Add a new fragment to ``syncmap``.
:param syncmap: the syncmap to append to
:type syncmap: :class:`~aeneas.syncmap.SyncMap`
:param identifier: the identifier
:type identifier: string
:param lines: the lines of the text
:type lines: list of string
:param begin: the begin time
:type begin: :class:`~aeneas.exacttiming.TimeValue`
:param end: the end time
:type end: :class:`~aeneas.exacttiming.TimeValue`
:param language: the language
:type language: string | [
"Add",
"a",
"new",
"fragment",
"to",
"syncmap",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/syncmap/smfbase.py#L53-L80 |
245,971 | readbeyond/aeneas | aeneas/syncmap/smfbase.py | SyncMapFormatBase.parse | def parse(self, input_text, syncmap):
"""
Parse the given ``input_text`` and
append the extracted fragments to ``syncmap``.
:param input_text: the input text as a Unicode string (read from file)
:type input_text: string
:param syncmap: the syncmap to append to
:type syncmap: :class:`~aeneas.syncmap.SyncMap`
"""
self.log_exc(u"%s is abstract and cannot be called directly" % (self.TAG), None, True, NotImplementedError) | python | def parse(self, input_text, syncmap):
self.log_exc(u"%s is abstract and cannot be called directly" % (self.TAG), None, True, NotImplementedError) | [
"def",
"parse",
"(",
"self",
",",
"input_text",
",",
"syncmap",
")",
":",
"self",
".",
"log_exc",
"(",
"u\"%s is abstract and cannot be called directly\"",
"%",
"(",
"self",
".",
"TAG",
")",
",",
"None",
",",
"True",
",",
"NotImplementedError",
")"
] | Parse the given ``input_text`` and
append the extracted fragments to ``syncmap``.
:param input_text: the input text as a Unicode string (read from file)
:type input_text: string
:param syncmap: the syncmap to append to
:type syncmap: :class:`~aeneas.syncmap.SyncMap` | [
"Parse",
"the",
"given",
"input_text",
"and",
"append",
"the",
"extracted",
"fragments",
"to",
"syncmap",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/syncmap/smfbase.py#L82-L92 |
245,972 | readbeyond/aeneas | aeneas/syncmap/smfbase.py | SyncMapFormatBase.format | def format(self, syncmap):
"""
Format the given ``syncmap`` as a Unicode string.
:param syncmap: the syncmap to output
:type syncmap: :class:`~aeneas.syncmap.SyncMap`
:rtype: string
"""
self.log_exc(u"%s is abstract and cannot be called directly" % (self.TAG), None, True, NotImplementedError) | python | def format(self, syncmap):
self.log_exc(u"%s is abstract and cannot be called directly" % (self.TAG), None, True, NotImplementedError) | [
"def",
"format",
"(",
"self",
",",
"syncmap",
")",
":",
"self",
".",
"log_exc",
"(",
"u\"%s is abstract and cannot be called directly\"",
"%",
"(",
"self",
".",
"TAG",
")",
",",
"None",
",",
"True",
",",
"NotImplementedError",
")"
] | Format the given ``syncmap`` as a Unicode string.
:param syncmap: the syncmap to output
:type syncmap: :class:`~aeneas.syncmap.SyncMap`
:rtype: string | [
"Format",
"the",
"given",
"syncmap",
"as",
"a",
"Unicode",
"string",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/syncmap/smfbase.py#L94-L102 |
245,973 | readbeyond/aeneas | aeneas/tools/execute_task.py | ExecuteTaskCLI.print_examples | def print_examples(self, full=False):
"""
Print the examples and exit.
:param bool full: if ``True``, print all examples; otherwise,
print only selected ones
"""
msg = []
i = 1
for key in sorted(self.DEMOS.keys()):
example = self.DEMOS[key]
if full or example["show"]:
msg.append(u"Example %d (%s)" % (i, example[u"description"]))
msg.append(u" $ %s %s" % (self.invoke, key))
msg.append(u"")
i += 1
self.print_generic(u"\n" + u"\n".join(msg) + u"\n")
return self.HELP_EXIT_CODE | python | def print_examples(self, full=False):
msg = []
i = 1
for key in sorted(self.DEMOS.keys()):
example = self.DEMOS[key]
if full or example["show"]:
msg.append(u"Example %d (%s)" % (i, example[u"description"]))
msg.append(u" $ %s %s" % (self.invoke, key))
msg.append(u"")
i += 1
self.print_generic(u"\n" + u"\n".join(msg) + u"\n")
return self.HELP_EXIT_CODE | [
"def",
"print_examples",
"(",
"self",
",",
"full",
"=",
"False",
")",
":",
"msg",
"=",
"[",
"]",
"i",
"=",
"1",
"for",
"key",
"in",
"sorted",
"(",
"self",
".",
"DEMOS",
".",
"keys",
"(",
")",
")",
":",
"example",
"=",
"self",
".",
"DEMOS",
"[",... | Print the examples and exit.
:param bool full: if ``True``, print all examples; otherwise,
print only selected ones | [
"Print",
"the",
"examples",
"and",
"exit",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/execute_task.py#L682-L699 |
245,974 | readbeyond/aeneas | aeneas/tools/execute_task.py | ExecuteTaskCLI.print_values | def print_values(self, parameter):
"""
Print the list of values for the given parameter and exit.
If ``parameter`` is invalid, print the list of
parameter names that have allowed values.
:param parameter: the parameter name
:type parameter: Unicode string
"""
if parameter in self.VALUES:
self.print_info(u"Available values for parameter '%s':" % parameter)
self.print_generic(u"\n".join(self.VALUES[parameter]))
return self.HELP_EXIT_CODE
if parameter not in [u"?", u""]:
self.print_error(u"Invalid parameter name '%s'" % parameter)
self.print_info(u"Parameters for which values can be listed:")
self.print_generic(u"\n".join(sorted(self.VALUES.keys())))
return self.HELP_EXIT_CODE | python | def print_values(self, parameter):
if parameter in self.VALUES:
self.print_info(u"Available values for parameter '%s':" % parameter)
self.print_generic(u"\n".join(self.VALUES[parameter]))
return self.HELP_EXIT_CODE
if parameter not in [u"?", u""]:
self.print_error(u"Invalid parameter name '%s'" % parameter)
self.print_info(u"Parameters for which values can be listed:")
self.print_generic(u"\n".join(sorted(self.VALUES.keys())))
return self.HELP_EXIT_CODE | [
"def",
"print_values",
"(",
"self",
",",
"parameter",
")",
":",
"if",
"parameter",
"in",
"self",
".",
"VALUES",
":",
"self",
".",
"print_info",
"(",
"u\"Available values for parameter '%s':\"",
"%",
"parameter",
")",
"self",
".",
"print_generic",
"(",
"u\"\\n\""... | Print the list of values for the given parameter and exit.
If ``parameter`` is invalid, print the list of
parameter names that have allowed values.
:param parameter: the parameter name
:type parameter: Unicode string | [
"Print",
"the",
"list",
"of",
"values",
"for",
"the",
"given",
"parameter",
"and",
"exit",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/execute_task.py#L711-L729 |
245,975 | readbeyond/aeneas | setup.py | prepare_cew_for_windows | def prepare_cew_for_windows():
"""
Copy files needed to compile the ``cew`` Python C extension on Windows.
A glorious day, when Microsoft will offer a decent support
for Python and shared libraries,
all this mess will be unnecessary and it should be removed.
May that day come soon.
Return ``True`` if successful, ``False`` otherwise.
:rtype: bool
"""
try:
# copy espeak_sapi.dll to C:\Windows\System32\espeak.dll
espeak_dll_win_path = "C:\\Windows\\System32\\espeak.dll"
espeak_dll_dst_path = "aeneas\\cew\\espeak.dll"
espeak_dll_src_paths = [
"C:\\aeneas\\eSpeak\\espeak_sapi.dll",
"C:\\sync\\eSpeak\\espeak_sapi.dll",
"C:\\Program Files\\eSpeak\\espeak_sapi.dll",
"C:\\Program Files (x86)\\eSpeak\\espeak_sapi.dll",
]
if os.path.exists(espeak_dll_dst_path):
print("[INFO] Found eSpeak DLL in %s" % espeak_dll_dst_path)
else:
found = False
copied = False
for src_path in espeak_dll_src_paths:
if os.path.exists(src_path):
found = True
print("[INFO] Copying eSpeak DLL from %s into %s" % (src_path, espeak_dll_dst_path))
try:
shutil.copyfile(src_path, espeak_dll_dst_path)
copied = True
print("[INFO] Copied eSpeak DLL")
except:
pass
break
if not found:
print("[WARN] Unable to find the eSpeak DLL, probably because you installed eSpeak in a non-standard location.")
print("[WARN] If you want to run aeneas with the C extension cew,")
print("[WARN] please copy espeak_sapi.dll from your eSpeak directory to %s" % espeak_dll_win_path)
# print("[WARN] and run the aeneas setup again.")
# return False
elif not copied:
print("[WARN] Unable to copy the eSpeak DLL, probably because you are not running with admin privileges.")
print("[WARN] If you want to run aeneas with the C extension cew,")
print("[WARN] please copy espeak_sapi.dll from your eSpeak directory to %s" % espeak_dll_win_path)
# print("[WARN] and run the aeneas setup again.")
# return False
# NOTE: espeak.lib is needed only while compiling the C extension, not when using it
# so, we copy it in the current working directory from the included thirdparty\ directory
# NOTE: PREV: copy thirdparty\espeak.lib to $PYTHON\libs\espeak.lib
# NOTE: PREV: espeak_lib_dst_path = os.path.join(sys.prefix, "libs", "espeak.lib")
espeak_lib_src_path = os.path.join(os.path.dirname(__file__), "thirdparty", "espeak.lib")
espeak_lib_dst_path = os.path.join(os.path.dirname(__file__), "espeak.lib")
if os.path.exists(espeak_lib_dst_path):
print("[INFO] Found eSpeak LIB in %s" % espeak_lib_dst_path)
else:
try:
print("[INFO] Copying eSpeak LIB into %s" % espeak_lib_dst_path)
shutil.copyfile(espeak_lib_src_path, espeak_lib_dst_path)
print("[INFO] Copied eSpeak LIB")
except:
print("[WARN] Unable to copy the eSpeak LIB, probably because you are not running with admin privileges.")
print("[WARN] If you want to compile the C extension cew,")
print("[WARN] please copy espeak.lib from the thirdparty directory into %s" % espeak_lib_dst_path)
print("[WARN] and run the aeneas setup again.")
return False
# if here, we have completed the setup, return True
return True
except Exception as e:
print("[WARN] Unexpected exception while preparing cew: %s" % e)
return False | python | def prepare_cew_for_windows():
try:
# copy espeak_sapi.dll to C:\Windows\System32\espeak.dll
espeak_dll_win_path = "C:\\Windows\\System32\\espeak.dll"
espeak_dll_dst_path = "aeneas\\cew\\espeak.dll"
espeak_dll_src_paths = [
"C:\\aeneas\\eSpeak\\espeak_sapi.dll",
"C:\\sync\\eSpeak\\espeak_sapi.dll",
"C:\\Program Files\\eSpeak\\espeak_sapi.dll",
"C:\\Program Files (x86)\\eSpeak\\espeak_sapi.dll",
]
if os.path.exists(espeak_dll_dst_path):
print("[INFO] Found eSpeak DLL in %s" % espeak_dll_dst_path)
else:
found = False
copied = False
for src_path in espeak_dll_src_paths:
if os.path.exists(src_path):
found = True
print("[INFO] Copying eSpeak DLL from %s into %s" % (src_path, espeak_dll_dst_path))
try:
shutil.copyfile(src_path, espeak_dll_dst_path)
copied = True
print("[INFO] Copied eSpeak DLL")
except:
pass
break
if not found:
print("[WARN] Unable to find the eSpeak DLL, probably because you installed eSpeak in a non-standard location.")
print("[WARN] If you want to run aeneas with the C extension cew,")
print("[WARN] please copy espeak_sapi.dll from your eSpeak directory to %s" % espeak_dll_win_path)
# print("[WARN] and run the aeneas setup again.")
# return False
elif not copied:
print("[WARN] Unable to copy the eSpeak DLL, probably because you are not running with admin privileges.")
print("[WARN] If you want to run aeneas with the C extension cew,")
print("[WARN] please copy espeak_sapi.dll from your eSpeak directory to %s" % espeak_dll_win_path)
# print("[WARN] and run the aeneas setup again.")
# return False
# NOTE: espeak.lib is needed only while compiling the C extension, not when using it
# so, we copy it in the current working directory from the included thirdparty\ directory
# NOTE: PREV: copy thirdparty\espeak.lib to $PYTHON\libs\espeak.lib
# NOTE: PREV: espeak_lib_dst_path = os.path.join(sys.prefix, "libs", "espeak.lib")
espeak_lib_src_path = os.path.join(os.path.dirname(__file__), "thirdparty", "espeak.lib")
espeak_lib_dst_path = os.path.join(os.path.dirname(__file__), "espeak.lib")
if os.path.exists(espeak_lib_dst_path):
print("[INFO] Found eSpeak LIB in %s" % espeak_lib_dst_path)
else:
try:
print("[INFO] Copying eSpeak LIB into %s" % espeak_lib_dst_path)
shutil.copyfile(espeak_lib_src_path, espeak_lib_dst_path)
print("[INFO] Copied eSpeak LIB")
except:
print("[WARN] Unable to copy the eSpeak LIB, probably because you are not running with admin privileges.")
print("[WARN] If you want to compile the C extension cew,")
print("[WARN] please copy espeak.lib from the thirdparty directory into %s" % espeak_lib_dst_path)
print("[WARN] and run the aeneas setup again.")
return False
# if here, we have completed the setup, return True
return True
except Exception as e:
print("[WARN] Unexpected exception while preparing cew: %s" % e)
return False | [
"def",
"prepare_cew_for_windows",
"(",
")",
":",
"try",
":",
"# copy espeak_sapi.dll to C:\\Windows\\System32\\espeak.dll",
"espeak_dll_win_path",
"=",
"\"C:\\\\Windows\\\\System32\\\\espeak.dll\"",
"espeak_dll_dst_path",
"=",
"\"aeneas\\\\cew\\\\espeak.dll\"",
"espeak_dll_src_paths",
... | Copy files needed to compile the ``cew`` Python C extension on Windows.
A glorious day, when Microsoft will offer a decent support
for Python and shared libraries,
all this mess will be unnecessary and it should be removed.
May that day come soon.
Return ``True`` if successful, ``False`` otherwise.
:rtype: bool | [
"Copy",
"files",
"needed",
"to",
"compile",
"the",
"cew",
"Python",
"C",
"extension",
"on",
"Windows",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/setup.py#L69-L145 |
245,976 | readbeyond/aeneas | aeneas/validator.py | Validator.check_file_encoding | def check_file_encoding(self, input_file_path):
"""
Check whether the given file is UTF-8 encoded.
:param string input_file_path: the path of the file to be checked
:rtype: :class:`~aeneas.validator.ValidatorResult`
"""
self.log([u"Checking encoding of file '%s'", input_file_path])
self.result = ValidatorResult()
if self._are_safety_checks_disabled(u"check_file_encoding"):
return self.result
if not gf.file_can_be_read(input_file_path):
self._failed(u"File '%s' cannot be read." % (input_file_path))
return self.result
with io.open(input_file_path, "rb") as file_object:
bstring = file_object.read()
self._check_utf8_encoding(bstring)
return self.result | python | def check_file_encoding(self, input_file_path):
self.log([u"Checking encoding of file '%s'", input_file_path])
self.result = ValidatorResult()
if self._are_safety_checks_disabled(u"check_file_encoding"):
return self.result
if not gf.file_can_be_read(input_file_path):
self._failed(u"File '%s' cannot be read." % (input_file_path))
return self.result
with io.open(input_file_path, "rb") as file_object:
bstring = file_object.read()
self._check_utf8_encoding(bstring)
return self.result | [
"def",
"check_file_encoding",
"(",
"self",
",",
"input_file_path",
")",
":",
"self",
".",
"log",
"(",
"[",
"u\"Checking encoding of file '%s'\"",
",",
"input_file_path",
"]",
")",
"self",
".",
"result",
"=",
"ValidatorResult",
"(",
")",
"if",
"self",
".",
"_ar... | Check whether the given file is UTF-8 encoded.
:param string input_file_path: the path of the file to be checked
:rtype: :class:`~aeneas.validator.ValidatorResult` | [
"Check",
"whether",
"the",
"given",
"file",
"is",
"UTF",
"-",
"8",
"encoded",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/validator.py#L259-L276 |
245,977 | readbeyond/aeneas | aeneas/validator.py | Validator.check_config_xml | def check_config_xml(self, contents):
"""
Check whether the given XML config file contents
is well-formed and it has all the required parameters.
:param string contents: the XML config file contents or XML config string
:param bool is_config_string: if ``True``, contents is a config string
:rtype: :class:`~aeneas.validator.ValidatorResult`
"""
self.log(u"Checking contents XML config file")
self.result = ValidatorResult()
if self._are_safety_checks_disabled(u"check_config_xml"):
return self.result
contents = gf.safe_bytes(contents)
self.log(u"Checking that contents is well formed")
self.check_raw_string(contents, is_bstring=True)
if not self.result.passed:
return self.result
self.log(u"Checking required parameters for job")
job_parameters = gf.config_xml_to_dict(contents, self.result, parse_job=True)
self._check_required_parameters(self.XML_JOB_REQUIRED_PARAMETERS, job_parameters)
if not self.result.passed:
return self.result
self.log(u"Checking required parameters for task")
tasks_parameters = gf.config_xml_to_dict(contents, self.result, parse_job=False)
for parameters in tasks_parameters:
self.log([u"Checking required parameters for task: '%s'", parameters])
self._check_required_parameters(self.XML_TASK_REQUIRED_PARAMETERS, parameters)
if not self.result.passed:
return self.result
return self.result | python | def check_config_xml(self, contents):
self.log(u"Checking contents XML config file")
self.result = ValidatorResult()
if self._are_safety_checks_disabled(u"check_config_xml"):
return self.result
contents = gf.safe_bytes(contents)
self.log(u"Checking that contents is well formed")
self.check_raw_string(contents, is_bstring=True)
if not self.result.passed:
return self.result
self.log(u"Checking required parameters for job")
job_parameters = gf.config_xml_to_dict(contents, self.result, parse_job=True)
self._check_required_parameters(self.XML_JOB_REQUIRED_PARAMETERS, job_parameters)
if not self.result.passed:
return self.result
self.log(u"Checking required parameters for task")
tasks_parameters = gf.config_xml_to_dict(contents, self.result, parse_job=False)
for parameters in tasks_parameters:
self.log([u"Checking required parameters for task: '%s'", parameters])
self._check_required_parameters(self.XML_TASK_REQUIRED_PARAMETERS, parameters)
if not self.result.passed:
return self.result
return self.result | [
"def",
"check_config_xml",
"(",
"self",
",",
"contents",
")",
":",
"self",
".",
"log",
"(",
"u\"Checking contents XML config file\"",
")",
"self",
".",
"result",
"=",
"ValidatorResult",
"(",
")",
"if",
"self",
".",
"_are_safety_checks_disabled",
"(",
"u\"check_con... | Check whether the given XML config file contents
is well-formed and it has all the required parameters.
:param string contents: the XML config file contents or XML config string
:param bool is_config_string: if ``True``, contents is a config string
:rtype: :class:`~aeneas.validator.ValidatorResult` | [
"Check",
"whether",
"the",
"given",
"XML",
"config",
"file",
"contents",
"is",
"well",
"-",
"formed",
"and",
"it",
"has",
"all",
"the",
"required",
"parameters",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/validator.py#L380-L410 |
245,978 | readbeyond/aeneas | aeneas/validator.py | Validator.check_container | def check_container(self, container_path, container_format=None, config_string=None):
"""
Check whether the given container is well-formed.
:param string container_path: the path of the container to be checked
:param container_format: the format of the container
:type container_format: :class:`~aeneas.container.ContainerFormat`
:param string config_string: the configuration string generated by the wizard
:rtype: :class:`~aeneas.validator.ValidatorResult`
"""
self.log([u"Checking container '%s'", container_path])
self.result = ValidatorResult()
if self._are_safety_checks_disabled(u"check_container"):
return self.result
if not (gf.file_exists(container_path) or gf.directory_exists(container_path)):
self._failed(u"Container '%s' not found." % container_path)
return self.result
container = Container(container_path, container_format)
try:
self.log(u"Checking container has config file")
if config_string is not None:
self.log(u"Container with config string from wizard")
self.check_config_txt(config_string, is_config_string=True)
elif container.has_config_xml:
self.log(u"Container has XML config file")
contents = container.read_entry(container.entry_config_xml)
if contents is None:
self._failed(u"Unable to read the contents of XML config file.")
return self.result
self.check_config_xml(contents)
elif container.has_config_txt:
self.log(u"Container has TXT config file")
contents = container.read_entry(container.entry_config_txt)
if contents is None:
self._failed(u"Unable to read the contents of TXT config file.")
return self.result
self.check_config_txt(contents, is_config_string=False)
else:
self._failed(u"Container does not have a TXT or XML configuration file.")
self.log(u"Checking we have a valid job in the container")
if not self.result.passed:
return self.result
self.log(u"Analyze the contents of the container")
analyzer = AnalyzeContainer(container)
if config_string is not None:
job = analyzer.analyze(config_string=config_string)
else:
job = analyzer.analyze()
self._check_analyzed_job(job, container)
except OSError:
self._failed(u"Unable to read the contents of the container.")
return self.result | python | def check_container(self, container_path, container_format=None, config_string=None):
self.log([u"Checking container '%s'", container_path])
self.result = ValidatorResult()
if self._are_safety_checks_disabled(u"check_container"):
return self.result
if not (gf.file_exists(container_path) or gf.directory_exists(container_path)):
self._failed(u"Container '%s' not found." % container_path)
return self.result
container = Container(container_path, container_format)
try:
self.log(u"Checking container has config file")
if config_string is not None:
self.log(u"Container with config string from wizard")
self.check_config_txt(config_string, is_config_string=True)
elif container.has_config_xml:
self.log(u"Container has XML config file")
contents = container.read_entry(container.entry_config_xml)
if contents is None:
self._failed(u"Unable to read the contents of XML config file.")
return self.result
self.check_config_xml(contents)
elif container.has_config_txt:
self.log(u"Container has TXT config file")
contents = container.read_entry(container.entry_config_txt)
if contents is None:
self._failed(u"Unable to read the contents of TXT config file.")
return self.result
self.check_config_txt(contents, is_config_string=False)
else:
self._failed(u"Container does not have a TXT or XML configuration file.")
self.log(u"Checking we have a valid job in the container")
if not self.result.passed:
return self.result
self.log(u"Analyze the contents of the container")
analyzer = AnalyzeContainer(container)
if config_string is not None:
job = analyzer.analyze(config_string=config_string)
else:
job = analyzer.analyze()
self._check_analyzed_job(job, container)
except OSError:
self._failed(u"Unable to read the contents of the container.")
return self.result | [
"def",
"check_container",
"(",
"self",
",",
"container_path",
",",
"container_format",
"=",
"None",
",",
"config_string",
"=",
"None",
")",
":",
"self",
".",
"log",
"(",
"[",
"u\"Checking container '%s'\"",
",",
"container_path",
"]",
")",
"self",
".",
"result... | Check whether the given container is well-formed.
:param string container_path: the path of the container to be checked
:param container_format: the format of the container
:type container_format: :class:`~aeneas.container.ContainerFormat`
:param string config_string: the configuration string generated by the wizard
:rtype: :class:`~aeneas.validator.ValidatorResult` | [
"Check",
"whether",
"the",
"given",
"container",
"is",
"well",
"-",
"formed",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/validator.py#L412-L468 |
245,979 | readbeyond/aeneas | aeneas/validator.py | Validator._are_safety_checks_disabled | def _are_safety_checks_disabled(self, caller=u"unknown_function"):
"""
Return ``True`` if safety checks are disabled.
:param string caller: the name of the caller function
:rtype: bool
"""
if self.rconf.safety_checks:
return False
self.log_warn([u"Safety checks disabled => %s passed", caller])
return True | python | def _are_safety_checks_disabled(self, caller=u"unknown_function"):
if self.rconf.safety_checks:
return False
self.log_warn([u"Safety checks disabled => %s passed", caller])
return True | [
"def",
"_are_safety_checks_disabled",
"(",
"self",
",",
"caller",
"=",
"u\"unknown_function\"",
")",
":",
"if",
"self",
".",
"rconf",
".",
"safety_checks",
":",
"return",
"False",
"self",
".",
"log_warn",
"(",
"[",
"u\"Safety checks disabled => %s passed\"",
",",
... | Return ``True`` if safety checks are disabled.
:param string caller: the name of the caller function
:rtype: bool | [
"Return",
"True",
"if",
"safety",
"checks",
"are",
"disabled",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/validator.py#L470-L480 |
245,980 | readbeyond/aeneas | aeneas/validator.py | Validator._failed | def _failed(self, msg):
"""
Log a validation failure.
:param string msg: the error message
"""
self.log(msg)
self.result.passed = False
self.result.add_error(msg)
self.log(u"Failed") | python | def _failed(self, msg):
self.log(msg)
self.result.passed = False
self.result.add_error(msg)
self.log(u"Failed") | [
"def",
"_failed",
"(",
"self",
",",
"msg",
")",
":",
"self",
".",
"log",
"(",
"msg",
")",
"self",
".",
"result",
".",
"passed",
"=",
"False",
"self",
".",
"result",
".",
"add_error",
"(",
"msg",
")",
"self",
".",
"log",
"(",
"u\"Failed\"",
")"
] | Log a validation failure.
:param string msg: the error message | [
"Log",
"a",
"validation",
"failure",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/validator.py#L482-L491 |
245,981 | readbeyond/aeneas | aeneas/validator.py | Validator._check_utf8_encoding | def _check_utf8_encoding(self, bstring):
"""
Check whether the given sequence of bytes
is properly encoded in UTF-8.
:param bytes bstring: the byte string to be checked
"""
if not gf.is_bytes(bstring):
self._failed(u"The given string is not a sequence of bytes")
return
if not gf.is_utf8_encoded(bstring):
self._failed(u"The given string is not encoded in UTF-8.") | python | def _check_utf8_encoding(self, bstring):
if not gf.is_bytes(bstring):
self._failed(u"The given string is not a sequence of bytes")
return
if not gf.is_utf8_encoded(bstring):
self._failed(u"The given string is not encoded in UTF-8.") | [
"def",
"_check_utf8_encoding",
"(",
"self",
",",
"bstring",
")",
":",
"if",
"not",
"gf",
".",
"is_bytes",
"(",
"bstring",
")",
":",
"self",
".",
"_failed",
"(",
"u\"The given string is not a sequence of bytes\"",
")",
"return",
"if",
"not",
"gf",
".",
"is_utf8... | Check whether the given sequence of bytes
is properly encoded in UTF-8.
:param bytes bstring: the byte string to be checked | [
"Check",
"whether",
"the",
"given",
"sequence",
"of",
"bytes",
"is",
"properly",
"encoded",
"in",
"UTF",
"-",
"8",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/validator.py#L493-L504 |
245,982 | readbeyond/aeneas | aeneas/validator.py | Validator._check_reserved_characters | def _check_reserved_characters(self, ustring):
"""
Check whether the given Unicode string contains reserved characters.
:param string ustring: the string to be checked
"""
forbidden = [c for c in gc.CONFIG_RESERVED_CHARACTERS if c in ustring]
if len(forbidden) > 0:
self._failed(u"The given string contains the reserved characters '%s'." % u" ".join(forbidden)) | python | def _check_reserved_characters(self, ustring):
forbidden = [c for c in gc.CONFIG_RESERVED_CHARACTERS if c in ustring]
if len(forbidden) > 0:
self._failed(u"The given string contains the reserved characters '%s'." % u" ".join(forbidden)) | [
"def",
"_check_reserved_characters",
"(",
"self",
",",
"ustring",
")",
":",
"forbidden",
"=",
"[",
"c",
"for",
"c",
"in",
"gc",
".",
"CONFIG_RESERVED_CHARACTERS",
"if",
"c",
"in",
"ustring",
"]",
"if",
"len",
"(",
"forbidden",
")",
">",
"0",
":",
"self",... | Check whether the given Unicode string contains reserved characters.
:param string ustring: the string to be checked | [
"Check",
"whether",
"the",
"given",
"Unicode",
"string",
"contains",
"reserved",
"characters",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/validator.py#L515-L523 |
245,983 | readbeyond/aeneas | aeneas/validator.py | Validator._check_allowed_values | def _check_allowed_values(self, parameters):
"""
Check whether the given parameter value is allowed.
Log messages into ``self.result``.
:param dict parameters: the given parameters
"""
for key, allowed_values in self.ALLOWED_VALUES:
self.log([u"Checking allowed values for parameter '%s'", key])
if key in parameters:
value = parameters[key]
if value not in allowed_values:
self._failed(u"Parameter '%s' has value '%s' which is not allowed." % (key, value))
return
self.log(u"Passed") | python | def _check_allowed_values(self, parameters):
for key, allowed_values in self.ALLOWED_VALUES:
self.log([u"Checking allowed values for parameter '%s'", key])
if key in parameters:
value = parameters[key]
if value not in allowed_values:
self._failed(u"Parameter '%s' has value '%s' which is not allowed." % (key, value))
return
self.log(u"Passed") | [
"def",
"_check_allowed_values",
"(",
"self",
",",
"parameters",
")",
":",
"for",
"key",
",",
"allowed_values",
"in",
"self",
".",
"ALLOWED_VALUES",
":",
"self",
".",
"log",
"(",
"[",
"u\"Checking allowed values for parameter '%s'\"",
",",
"key",
"]",
")",
"if",
... | Check whether the given parameter value is allowed.
Log messages into ``self.result``.
:param dict parameters: the given parameters | [
"Check",
"whether",
"the",
"given",
"parameter",
"value",
"is",
"allowed",
".",
"Log",
"messages",
"into",
"self",
".",
"result",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/validator.py#L525-L539 |
245,984 | readbeyond/aeneas | aeneas/validator.py | Validator._check_implied_parameters | def _check_implied_parameters(self, parameters):
"""
Check whether at least one of the keys in implied_keys
is in ``parameters``,
when a given ``key=value`` is present in ``parameters``,
for some value in values.
Log messages into ``self.result``.
:param dict parameters: the given parameters
"""
for key, values, implied_keys in self.IMPLIED_PARAMETERS:
self.log([u"Checking implied parameters by '%s'='%s'", key, values])
if (key in parameters) and (parameters[key] in values):
found = False
for implied_key in implied_keys:
if implied_key in parameters:
found = True
if not found:
if len(implied_keys) == 1:
msg = u"Parameter '%s' is required when '%s'='%s'." % (implied_keys[0], key, parameters[key])
else:
msg = u"At least one of [%s] is required when '%s'='%s'." % (",".join(implied_keys), key, parameters[key])
self._failed(msg)
return
self.log(u"Passed") | python | def _check_implied_parameters(self, parameters):
for key, values, implied_keys in self.IMPLIED_PARAMETERS:
self.log([u"Checking implied parameters by '%s'='%s'", key, values])
if (key in parameters) and (parameters[key] in values):
found = False
for implied_key in implied_keys:
if implied_key in parameters:
found = True
if not found:
if len(implied_keys) == 1:
msg = u"Parameter '%s' is required when '%s'='%s'." % (implied_keys[0], key, parameters[key])
else:
msg = u"At least one of [%s] is required when '%s'='%s'." % (",".join(implied_keys), key, parameters[key])
self._failed(msg)
return
self.log(u"Passed") | [
"def",
"_check_implied_parameters",
"(",
"self",
",",
"parameters",
")",
":",
"for",
"key",
",",
"values",
",",
"implied_keys",
"in",
"self",
".",
"IMPLIED_PARAMETERS",
":",
"self",
".",
"log",
"(",
"[",
"u\"Checking implied parameters by '%s'='%s'\"",
",",
"key",... | Check whether at least one of the keys in implied_keys
is in ``parameters``,
when a given ``key=value`` is present in ``parameters``,
for some value in values.
Log messages into ``self.result``.
:param dict parameters: the given parameters | [
"Check",
"whether",
"at",
"least",
"one",
"of",
"the",
"keys",
"in",
"implied_keys",
"is",
"in",
"parameters",
"when",
"a",
"given",
"key",
"=",
"value",
"is",
"present",
"in",
"parameters",
"for",
"some",
"value",
"in",
"values",
".",
"Log",
"messages",
... | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/validator.py#L541-L565 |
245,985 | readbeyond/aeneas | aeneas/validator.py | Validator._check_required_parameters | def _check_required_parameters(
self,
required_parameters,
parameters
):
"""
Check whether the given parameter dictionary contains
all the required paramenters.
Log messages into ``self.result``.
:param list required_parameters: required parameters
:param dict parameters: parameters specified by the user
"""
self.log([u"Checking required parameters '%s'", required_parameters])
self.log(u"Checking input parameters are not empty")
if (parameters is None) or (len(parameters) == 0):
self._failed(u"No parameters supplied.")
return
self.log(u"Checking no required parameter is missing")
for req_param in required_parameters:
if req_param not in parameters:
self._failed(u"Required parameter '%s' not set." % req_param)
return
self.log(u"Checking all parameter values are allowed")
self._check_allowed_values(parameters)
self.log(u"Checking all implied parameters are present")
self._check_implied_parameters(parameters)
return self.result | python | def _check_required_parameters(
self,
required_parameters,
parameters
):
self.log([u"Checking required parameters '%s'", required_parameters])
self.log(u"Checking input parameters are not empty")
if (parameters is None) or (len(parameters) == 0):
self._failed(u"No parameters supplied.")
return
self.log(u"Checking no required parameter is missing")
for req_param in required_parameters:
if req_param not in parameters:
self._failed(u"Required parameter '%s' not set." % req_param)
return
self.log(u"Checking all parameter values are allowed")
self._check_allowed_values(parameters)
self.log(u"Checking all implied parameters are present")
self._check_implied_parameters(parameters)
return self.result | [
"def",
"_check_required_parameters",
"(",
"self",
",",
"required_parameters",
",",
"parameters",
")",
":",
"self",
".",
"log",
"(",
"[",
"u\"Checking required parameters '%s'\"",
",",
"required_parameters",
"]",
")",
"self",
".",
"log",
"(",
"u\"Checking input paramet... | Check whether the given parameter dictionary contains
all the required paramenters.
Log messages into ``self.result``.
:param list required_parameters: required parameters
:param dict parameters: parameters specified by the user | [
"Check",
"whether",
"the",
"given",
"parameter",
"dictionary",
"contains",
"all",
"the",
"required",
"paramenters",
".",
"Log",
"messages",
"into",
"self",
".",
"result",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/validator.py#L567-L594 |
245,986 | readbeyond/aeneas | aeneas/validator.py | Validator._check_analyzed_job | def _check_analyzed_job(self, job, container):
"""
Check that the job object generated from the given container
is well formed, that it has at least one task,
and that the text file of each task has the correct encoding.
Log messages into ``self.result``.
:param job: the Job object generated from container
:type job: :class:`~aeneas.job.Job`
:param container: the Container object
:type container: :class:`~aeneas.container.Container`
"""
self.log(u"Checking the Job object generated from container")
self.log(u"Checking that the Job is not None")
if job is None:
self._failed(u"Unable to create a Job from the container.")
return
self.log(u"Checking that the Job has at least one Task")
if len(job) == 0:
self._failed(u"Unable to create at least one Task from the container.")
return
if self.rconf[RuntimeConfiguration.JOB_MAX_TASKS] > 0:
self.log(u"Checking that the Job does not have too many Tasks")
if len(job) > self.rconf[RuntimeConfiguration.JOB_MAX_TASKS]:
self._failed(u"The Job has %d Tasks, more than the maximum allowed (%d)." % (
len(job),
self.rconf[RuntimeConfiguration.JOB_MAX_TASKS]
))
return
self.log(u"Checking that each Task text file is well formed")
for task in job.tasks:
self.log([u"Checking Task text file '%s'", task.text_file_path])
text_file_bstring = container.read_entry(task.text_file_path)
if (text_file_bstring is None) or (len(text_file_bstring) == 0):
self._failed(u"Text file '%s' is empty" % task.text_file_path)
return
self._check_utf8_encoding(text_file_bstring)
if not self.result.passed:
self._failed(u"Text file '%s' is not encoded in UTF-8" % task.text_file_path)
return
self._check_not_empty(text_file_bstring)
if not self.result.passed:
self._failed(u"Text file '%s' is empty" % task.text_file_path)
return
self.log([u"Checking Task text file '%s': passed", task.text_file_path])
self.log(u"Checking each Task text file is well formed: passed") | python | def _check_analyzed_job(self, job, container):
self.log(u"Checking the Job object generated from container")
self.log(u"Checking that the Job is not None")
if job is None:
self._failed(u"Unable to create a Job from the container.")
return
self.log(u"Checking that the Job has at least one Task")
if len(job) == 0:
self._failed(u"Unable to create at least one Task from the container.")
return
if self.rconf[RuntimeConfiguration.JOB_MAX_TASKS] > 0:
self.log(u"Checking that the Job does not have too many Tasks")
if len(job) > self.rconf[RuntimeConfiguration.JOB_MAX_TASKS]:
self._failed(u"The Job has %d Tasks, more than the maximum allowed (%d)." % (
len(job),
self.rconf[RuntimeConfiguration.JOB_MAX_TASKS]
))
return
self.log(u"Checking that each Task text file is well formed")
for task in job.tasks:
self.log([u"Checking Task text file '%s'", task.text_file_path])
text_file_bstring = container.read_entry(task.text_file_path)
if (text_file_bstring is None) or (len(text_file_bstring) == 0):
self._failed(u"Text file '%s' is empty" % task.text_file_path)
return
self._check_utf8_encoding(text_file_bstring)
if not self.result.passed:
self._failed(u"Text file '%s' is not encoded in UTF-8" % task.text_file_path)
return
self._check_not_empty(text_file_bstring)
if not self.result.passed:
self._failed(u"Text file '%s' is empty" % task.text_file_path)
return
self.log([u"Checking Task text file '%s': passed", task.text_file_path])
self.log(u"Checking each Task text file is well formed: passed") | [
"def",
"_check_analyzed_job",
"(",
"self",
",",
"job",
",",
"container",
")",
":",
"self",
".",
"log",
"(",
"u\"Checking the Job object generated from container\"",
")",
"self",
".",
"log",
"(",
"u\"Checking that the Job is not None\"",
")",
"if",
"job",
"is",
"None... | Check that the job object generated from the given container
is well formed, that it has at least one task,
and that the text file of each task has the correct encoding.
Log messages into ``self.result``.
:param job: the Job object generated from container
:type job: :class:`~aeneas.job.Job`
:param container: the Container object
:type container: :class:`~aeneas.container.Container` | [
"Check",
"that",
"the",
"job",
"object",
"generated",
"from",
"the",
"given",
"container",
"is",
"well",
"formed",
"that",
"it",
"has",
"at",
"least",
"one",
"task",
"and",
"that",
"the",
"text",
"file",
"of",
"each",
"task",
"has",
"the",
"correct",
"en... | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/validator.py#L596-L645 |
245,987 | readbeyond/aeneas | aeneas/validator.py | ValidatorResult.pretty_print | def pretty_print(self, warnings=False):
"""
Pretty print warnings and errors.
:param bool warnings: if ``True``, also print warnings.
:rtype: string
"""
msg = []
if (warnings) and (len(self.warnings) > 0):
msg.append(u"Warnings:")
for warning in self.warnings:
msg.append(u" %s" % warning)
if len(self.errors) > 0:
msg.append(u"Errors:")
for error in self.errors:
msg.append(u" %s" % error)
return u"\n".join(msg) | python | def pretty_print(self, warnings=False):
msg = []
if (warnings) and (len(self.warnings) > 0):
msg.append(u"Warnings:")
for warning in self.warnings:
msg.append(u" %s" % warning)
if len(self.errors) > 0:
msg.append(u"Errors:")
for error in self.errors:
msg.append(u" %s" % error)
return u"\n".join(msg) | [
"def",
"pretty_print",
"(",
"self",
",",
"warnings",
"=",
"False",
")",
":",
"msg",
"=",
"[",
"]",
"if",
"(",
"warnings",
")",
"and",
"(",
"len",
"(",
"self",
".",
"warnings",
")",
">",
"0",
")",
":",
"msg",
".",
"append",
"(",
"u\"Warnings:\"",
... | Pretty print warnings and errors.
:param bool warnings: if ``True``, also print warnings.
:rtype: string | [
"Pretty",
"print",
"warnings",
"and",
"errors",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/validator.py#L670-L686 |
245,988 | readbeyond/aeneas | aeneas/ffmpegwrapper.py | FFMPEGWrapper.convert | def convert(
self,
input_file_path,
output_file_path,
head_length=None,
process_length=None
):
"""
Convert the audio file at ``input_file_path``
into ``output_file_path``,
using the parameters set in the constructor
or through the ``parameters`` property.
You can skip the beginning of the audio file
by specifying ``head_length`` seconds to skip
(if it is ``None``, start at time zero),
and you can specify to convert
only ``process_length`` seconds
(if it is ``None``, process the entire input file length).
By specifying both ``head_length`` and ``process_length``,
you can skip a portion at the beginning and at the end
of the original input file.
:param string input_file_path: the path of the audio file to convert
:param string output_file_path: the path of the converted audio file
:param float head_length: skip these many seconds
from the beginning of the audio file
:param float process_length: process these many seconds of the audio file
:raises: :class:`~aeneas.ffmpegwrapper.FFMPEGPathError`: if the path to the ``ffmpeg`` executable cannot be called
:raises: OSError: if ``input_file_path`` does not exist
or ``output_file_path`` cannot be written
"""
# test if we can read the input file
if not gf.file_can_be_read(input_file_path):
self.log_exc(u"Input file '%s' cannot be read" % (input_file_path), None, True, OSError)
# test if we can write the output file
if not gf.file_can_be_written(output_file_path):
self.log_exc(u"Output file '%s' cannot be written" % (output_file_path), None, True, OSError)
# call ffmpeg
arguments = [self.rconf[RuntimeConfiguration.FFMPEG_PATH]]
arguments.extend(["-i", input_file_path])
if head_length is not None:
arguments.extend(["-ss", head_length])
if process_length is not None:
arguments.extend(["-t", process_length])
if self.rconf.sample_rate in self.FFMPEG_PARAMETERS_MAP:
arguments.extend(self.FFMPEG_PARAMETERS_MAP[self.rconf.sample_rate])
else:
arguments.extend(self.FFMPEG_PARAMETERS_DEFAULT)
arguments.append(output_file_path)
self.log([u"Calling with arguments '%s'", arguments])
try:
proc = subprocess.Popen(
arguments,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE
)
proc.communicate()
proc.stdout.close()
proc.stdin.close()
proc.stderr.close()
except OSError as exc:
self.log_exc(u"Unable to call the '%s' ffmpeg executable" % (self.rconf[RuntimeConfiguration.FFMPEG_PATH]), exc, True, FFMPEGPathError)
self.log(u"Call completed")
# check if the output file exists
if not gf.file_exists(output_file_path):
self.log_exc(u"Output file '%s' was not written" % (output_file_path), None, True, OSError)
# returning the output file path
self.log([u"Returning output file path '%s'", output_file_path])
return output_file_path | python | def convert(
self,
input_file_path,
output_file_path,
head_length=None,
process_length=None
):
# test if we can read the input file
if not gf.file_can_be_read(input_file_path):
self.log_exc(u"Input file '%s' cannot be read" % (input_file_path), None, True, OSError)
# test if we can write the output file
if not gf.file_can_be_written(output_file_path):
self.log_exc(u"Output file '%s' cannot be written" % (output_file_path), None, True, OSError)
# call ffmpeg
arguments = [self.rconf[RuntimeConfiguration.FFMPEG_PATH]]
arguments.extend(["-i", input_file_path])
if head_length is not None:
arguments.extend(["-ss", head_length])
if process_length is not None:
arguments.extend(["-t", process_length])
if self.rconf.sample_rate in self.FFMPEG_PARAMETERS_MAP:
arguments.extend(self.FFMPEG_PARAMETERS_MAP[self.rconf.sample_rate])
else:
arguments.extend(self.FFMPEG_PARAMETERS_DEFAULT)
arguments.append(output_file_path)
self.log([u"Calling with arguments '%s'", arguments])
try:
proc = subprocess.Popen(
arguments,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE
)
proc.communicate()
proc.stdout.close()
proc.stdin.close()
proc.stderr.close()
except OSError as exc:
self.log_exc(u"Unable to call the '%s' ffmpeg executable" % (self.rconf[RuntimeConfiguration.FFMPEG_PATH]), exc, True, FFMPEGPathError)
self.log(u"Call completed")
# check if the output file exists
if not gf.file_exists(output_file_path):
self.log_exc(u"Output file '%s' was not written" % (output_file_path), None, True, OSError)
# returning the output file path
self.log([u"Returning output file path '%s'", output_file_path])
return output_file_path | [
"def",
"convert",
"(",
"self",
",",
"input_file_path",
",",
"output_file_path",
",",
"head_length",
"=",
"None",
",",
"process_length",
"=",
"None",
")",
":",
"# test if we can read the input file",
"if",
"not",
"gf",
".",
"file_can_be_read",
"(",
"input_file_path",... | Convert the audio file at ``input_file_path``
into ``output_file_path``,
using the parameters set in the constructor
or through the ``parameters`` property.
You can skip the beginning of the audio file
by specifying ``head_length`` seconds to skip
(if it is ``None``, start at time zero),
and you can specify to convert
only ``process_length`` seconds
(if it is ``None``, process the entire input file length).
By specifying both ``head_length`` and ``process_length``,
you can skip a portion at the beginning and at the end
of the original input file.
:param string input_file_path: the path of the audio file to convert
:param string output_file_path: the path of the converted audio file
:param float head_length: skip these many seconds
from the beginning of the audio file
:param float process_length: process these many seconds of the audio file
:raises: :class:`~aeneas.ffmpegwrapper.FFMPEGPathError`: if the path to the ``ffmpeg`` executable cannot be called
:raises: OSError: if ``input_file_path`` does not exist
or ``output_file_path`` cannot be written | [
"Convert",
"the",
"audio",
"file",
"at",
"input_file_path",
"into",
"output_file_path",
"using",
"the",
"parameters",
"set",
"in",
"the",
"constructor",
"or",
"through",
"the",
"parameters",
"property",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/ffmpegwrapper.py#L163-L238 |
245,989 | readbeyond/aeneas | aeneas/syncmap/fragment.py | SyncMapFragment.rate_lack | def rate_lack(self, max_rate):
"""
The time interval that this fragment lacks
to respect the given max rate.
A positive value means that the current fragment
is faster than the max rate (bad).
A negative or zero value means that the current fragment
has rate slower or equal to the max rate (good).
Always return ``0.000`` for fragments that are not ``REGULAR``.
:param max_rate: the maximum rate (characters/second)
:type max_rate: :class:`~aeneas.exacttiming.Decimal`
:rtype: :class:`~aeneas.exacttiming.TimeValue`
.. versionadded:: 1.7.0
"""
if self.fragment_type == self.REGULAR:
return self.chars / max_rate - self.length
return TimeValue("0.000") | python | def rate_lack(self, max_rate):
if self.fragment_type == self.REGULAR:
return self.chars / max_rate - self.length
return TimeValue("0.000") | [
"def",
"rate_lack",
"(",
"self",
",",
"max_rate",
")",
":",
"if",
"self",
".",
"fragment_type",
"==",
"self",
".",
"REGULAR",
":",
"return",
"self",
".",
"chars",
"/",
"max_rate",
"-",
"self",
".",
"length",
"return",
"TimeValue",
"(",
"\"0.000\"",
")"
] | The time interval that this fragment lacks
to respect the given max rate.
A positive value means that the current fragment
is faster than the max rate (bad).
A negative or zero value means that the current fragment
has rate slower or equal to the max rate (good).
Always return ``0.000`` for fragments that are not ``REGULAR``.
:param max_rate: the maximum rate (characters/second)
:type max_rate: :class:`~aeneas.exacttiming.Decimal`
:rtype: :class:`~aeneas.exacttiming.TimeValue`
.. versionadded:: 1.7.0 | [
"The",
"time",
"interval",
"that",
"this",
"fragment",
"lacks",
"to",
"respect",
"the",
"given",
"max",
"rate",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/syncmap/fragment.py#L341-L361 |
245,990 | readbeyond/aeneas | aeneas/syncmap/fragment.py | SyncMapFragment.rate_slack | def rate_slack(self, max_rate):
"""
The maximum time interval that can be stolen to this fragment
while keeping it respecting the given max rate.
For ``REGULAR`` fragments this value is
the opposite of the ``rate_lack``.
For ``NONSPEECH`` fragments this value is equal to
the length of the fragment.
For ``HEAD`` and ``TAIL`` fragments this value is ``0.000``,
meaning that they cannot be stolen.
:param max_rate: the maximum rate (characters/second)
:type max_rate: :class:`~aeneas.exacttiming.Decimal`
:rtype: :class:`~aeneas.exacttiming.TimeValue`
.. versionadded:: 1.7.0
"""
if self.fragment_type == self.REGULAR:
return -self.rate_lack(max_rate)
elif self.fragment_type == self.NONSPEECH:
return self.length
else:
return TimeValue("0.000") | python | def rate_slack(self, max_rate):
if self.fragment_type == self.REGULAR:
return -self.rate_lack(max_rate)
elif self.fragment_type == self.NONSPEECH:
return self.length
else:
return TimeValue("0.000") | [
"def",
"rate_slack",
"(",
"self",
",",
"max_rate",
")",
":",
"if",
"self",
".",
"fragment_type",
"==",
"self",
".",
"REGULAR",
":",
"return",
"-",
"self",
".",
"rate_lack",
"(",
"max_rate",
")",
"elif",
"self",
".",
"fragment_type",
"==",
"self",
".",
... | The maximum time interval that can be stolen to this fragment
while keeping it respecting the given max rate.
For ``REGULAR`` fragments this value is
the opposite of the ``rate_lack``.
For ``NONSPEECH`` fragments this value is equal to
the length of the fragment.
For ``HEAD`` and ``TAIL`` fragments this value is ``0.000``,
meaning that they cannot be stolen.
:param max_rate: the maximum rate (characters/second)
:type max_rate: :class:`~aeneas.exacttiming.Decimal`
:rtype: :class:`~aeneas.exacttiming.TimeValue`
.. versionadded:: 1.7.0 | [
"The",
"maximum",
"time",
"interval",
"that",
"can",
"be",
"stolen",
"to",
"this",
"fragment",
"while",
"keeping",
"it",
"respecting",
"the",
"given",
"max",
"rate",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/syncmap/fragment.py#L363-L386 |
245,991 | readbeyond/aeneas | aeneas/tools/run_vad.py | RunVADCLI.write_to_file | def write_to_file(self, output_file_path, intervals, template):
"""
Write intervals to file.
:param output_file_path: path of the output file to be written;
if ``None``, print to stdout
:type output_file_path: string (path)
:param intervals: a list of tuples, each representing an interval
:type intervals: list of tuples
"""
msg = [template % (interval) for interval in intervals]
if output_file_path is None:
self.print_info(u"Intervals detected:")
for line in msg:
self.print_generic(line)
else:
with io.open(output_file_path, "w", encoding="utf-8") as output_file:
output_file.write(u"\n".join(msg))
self.print_success(u"Created file '%s'" % output_file_path) | python | def write_to_file(self, output_file_path, intervals, template):
msg = [template % (interval) for interval in intervals]
if output_file_path is None:
self.print_info(u"Intervals detected:")
for line in msg:
self.print_generic(line)
else:
with io.open(output_file_path, "w", encoding="utf-8") as output_file:
output_file.write(u"\n".join(msg))
self.print_success(u"Created file '%s'" % output_file_path) | [
"def",
"write_to_file",
"(",
"self",
",",
"output_file_path",
",",
"intervals",
",",
"template",
")",
":",
"msg",
"=",
"[",
"template",
"%",
"(",
"interval",
")",
"for",
"interval",
"in",
"intervals",
"]",
"if",
"output_file_path",
"is",
"None",
":",
"self... | Write intervals to file.
:param output_file_path: path of the output file to be written;
if ``None``, print to stdout
:type output_file_path: string (path)
:param intervals: a list of tuples, each representing an interval
:type intervals: list of tuples | [
"Write",
"intervals",
"to",
"file",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/run_vad.py#L145-L163 |
245,992 | readbeyond/aeneas | aeneas/tools/execute_job.py | ExecuteJobCLI.print_parameters | def print_parameters(self):
"""
Print the list of parameters and exit.
"""
self.print_info(u"Available parameters:")
self.print_generic(u"\n" + u"\n".join(self.PARAMETERS) + u"\n")
return self.HELP_EXIT_CODE | python | def print_parameters(self):
self.print_info(u"Available parameters:")
self.print_generic(u"\n" + u"\n".join(self.PARAMETERS) + u"\n")
return self.HELP_EXIT_CODE | [
"def",
"print_parameters",
"(",
"self",
")",
":",
"self",
".",
"print_info",
"(",
"u\"Available parameters:\"",
")",
"self",
".",
"print_generic",
"(",
"u\"\\n\"",
"+",
"u\"\\n\"",
".",
"join",
"(",
"self",
".",
"PARAMETERS",
")",
"+",
"u\"\\n\"",
")",
"retu... | Print the list of parameters and exit. | [
"Print",
"the",
"list",
"of",
"parameters",
"and",
"exit",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/tools/execute_job.py#L148-L154 |
245,993 | readbeyond/aeneas | aeneas/cewsubprocess.py | main | def main():
"""
Run ``aeneas.cew``, reading input text from file and writing audio and interval data to file.
"""
# make sure we have enough parameters
if len(sys.argv) < 6:
print("You must pass five arguments: QUIT_AFTER BACKWARDS TEXT_FILE_PATH AUDIO_FILE_PATH DATA_FILE_PATH")
return 1
# read parameters
c_quit_after = float(sys.argv[1]) # NOTE: cew needs float, not TimeValue
c_backwards = int(sys.argv[2])
text_file_path = sys.argv[3]
audio_file_path = sys.argv[4]
data_file_path = sys.argv[5]
# read (voice_code, text) from file
s_text = []
with io.open(text_file_path, "r", encoding="utf-8") as text:
for line in text.readlines():
# NOTE: not using strip() to avoid removing trailing blank characters
line = line.replace(u"\n", u"").replace(u"\r", u"")
idx = line.find(" ")
if idx > 0:
f_voice_code = line[:idx]
f_text = line[(idx + 1):]
s_text.append((f_voice_code, f_text))
# convert to bytes/unicode as required by subprocess
c_text = []
if gf.PY2:
for f_voice_code, f_text in s_text:
c_text.append((gf.safe_bytes(f_voice_code), gf.safe_bytes(f_text)))
else:
for f_voice_code, f_text in s_text:
c_text.append((gf.safe_unicode(f_voice_code), gf.safe_unicode(f_text)))
try:
import aeneas.cew.cew
sr, sf, intervals = aeneas.cew.cew.synthesize_multiple(
audio_file_path,
c_quit_after,
c_backwards,
c_text
)
with io.open(data_file_path, "w", encoding="utf-8") as data:
data.write(u"%d\n" % (sr))
data.write(u"%d\n" % (sf))
data.write(u"\n".join([u"%.3f %.3f" % (i[0], i[1]) for i in intervals]))
except Exception as exc:
print(u"Unexpected error: %s" % str(exc)) | python | def main():
# make sure we have enough parameters
if len(sys.argv) < 6:
print("You must pass five arguments: QUIT_AFTER BACKWARDS TEXT_FILE_PATH AUDIO_FILE_PATH DATA_FILE_PATH")
return 1
# read parameters
c_quit_after = float(sys.argv[1]) # NOTE: cew needs float, not TimeValue
c_backwards = int(sys.argv[2])
text_file_path = sys.argv[3]
audio_file_path = sys.argv[4]
data_file_path = sys.argv[5]
# read (voice_code, text) from file
s_text = []
with io.open(text_file_path, "r", encoding="utf-8") as text:
for line in text.readlines():
# NOTE: not using strip() to avoid removing trailing blank characters
line = line.replace(u"\n", u"").replace(u"\r", u"")
idx = line.find(" ")
if idx > 0:
f_voice_code = line[:idx]
f_text = line[(idx + 1):]
s_text.append((f_voice_code, f_text))
# convert to bytes/unicode as required by subprocess
c_text = []
if gf.PY2:
for f_voice_code, f_text in s_text:
c_text.append((gf.safe_bytes(f_voice_code), gf.safe_bytes(f_text)))
else:
for f_voice_code, f_text in s_text:
c_text.append((gf.safe_unicode(f_voice_code), gf.safe_unicode(f_text)))
try:
import aeneas.cew.cew
sr, sf, intervals = aeneas.cew.cew.synthesize_multiple(
audio_file_path,
c_quit_after,
c_backwards,
c_text
)
with io.open(data_file_path, "w", encoding="utf-8") as data:
data.write(u"%d\n" % (sr))
data.write(u"%d\n" % (sf))
data.write(u"\n".join([u"%.3f %.3f" % (i[0], i[1]) for i in intervals]))
except Exception as exc:
print(u"Unexpected error: %s" % str(exc)) | [
"def",
"main",
"(",
")",
":",
"# make sure we have enough parameters",
"if",
"len",
"(",
"sys",
".",
"argv",
")",
"<",
"6",
":",
"print",
"(",
"\"You must pass five arguments: QUIT_AFTER BACKWARDS TEXT_FILE_PATH AUDIO_FILE_PATH DATA_FILE_PATH\"",
")",
"return",
"1",
"# re... | Run ``aeneas.cew``, reading input text from file and writing audio and interval data to file. | [
"Run",
"aeneas",
".",
"cew",
"reading",
"input",
"text",
"from",
"file",
"and",
"writing",
"audio",
"and",
"interval",
"data",
"to",
"file",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/cewsubprocess.py#L137-L188 |
245,994 | readbeyond/aeneas | aeneas/syncmap/smfsmil.py | SyncMapFormatSMIL.parse | def parse(self, input_text, syncmap):
"""
Read from SMIL file.
Limitations:
1. parses only ``<par>`` elements, in order
2. timings must have ``hh:mm:ss.mmm`` or ``ss.mmm`` format (autodetected)
3. both ``clipBegin`` and ``clipEnd`` attributes of ``<audio>`` must be populated
"""
from lxml import etree
smil_ns = "{http://www.w3.org/ns/SMIL}"
root = etree.fromstring(gf.safe_bytes(input_text))
for par in root.iter(smil_ns + "par"):
for child in par:
if child.tag == (smil_ns + "text"):
identifier = gf.safe_unicode(gf.split_url(child.get("src"))[1])
elif child.tag == (smil_ns + "audio"):
begin_text = child.get("clipBegin")
if ":" in begin_text:
begin = gf.time_from_hhmmssmmm(begin_text)
else:
begin = gf.time_from_ssmmm(begin_text)
end_text = child.get("clipEnd")
if ":" in end_text:
end = gf.time_from_hhmmssmmm(end_text)
else:
end = gf.time_from_ssmmm(end_text)
# TODO read text from additional text_file?
self._add_fragment(
syncmap=syncmap,
identifier=identifier,
lines=[u""],
begin=begin,
end=end
) | python | def parse(self, input_text, syncmap):
from lxml import etree
smil_ns = "{http://www.w3.org/ns/SMIL}"
root = etree.fromstring(gf.safe_bytes(input_text))
for par in root.iter(smil_ns + "par"):
for child in par:
if child.tag == (smil_ns + "text"):
identifier = gf.safe_unicode(gf.split_url(child.get("src"))[1])
elif child.tag == (smil_ns + "audio"):
begin_text = child.get("clipBegin")
if ":" in begin_text:
begin = gf.time_from_hhmmssmmm(begin_text)
else:
begin = gf.time_from_ssmmm(begin_text)
end_text = child.get("clipEnd")
if ":" in end_text:
end = gf.time_from_hhmmssmmm(end_text)
else:
end = gf.time_from_ssmmm(end_text)
# TODO read text from additional text_file?
self._add_fragment(
syncmap=syncmap,
identifier=identifier,
lines=[u""],
begin=begin,
end=end
) | [
"def",
"parse",
"(",
"self",
",",
"input_text",
",",
"syncmap",
")",
":",
"from",
"lxml",
"import",
"etree",
"smil_ns",
"=",
"\"{http://www.w3.org/ns/SMIL}\"",
"root",
"=",
"etree",
".",
"fromstring",
"(",
"gf",
".",
"safe_bytes",
"(",
"input_text",
")",
")"... | Read from SMIL file.
Limitations:
1. parses only ``<par>`` elements, in order
2. timings must have ``hh:mm:ss.mmm`` or ``ss.mmm`` format (autodetected)
3. both ``clipBegin`` and ``clipEnd`` attributes of ``<audio>`` must be populated | [
"Read",
"from",
"SMIL",
"file",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/syncmap/smfsmil.py#L55-L89 |
245,995 | readbeyond/aeneas | aeneas/syncmap/fragmentlist.py | SyncMapFragmentList._is_valid_index | def _is_valid_index(self, index):
"""
Return ``True`` if and only if the given ``index``
is valid.
"""
if isinstance(index, int):
return (index >= 0) and (index < len(self))
if isinstance(index, list):
valid = True
for i in index:
valid = valid or self._is_valid_index(i)
return valid
return False | python | def _is_valid_index(self, index):
if isinstance(index, int):
return (index >= 0) and (index < len(self))
if isinstance(index, list):
valid = True
for i in index:
valid = valid or self._is_valid_index(i)
return valid
return False | [
"def",
"_is_valid_index",
"(",
"self",
",",
"index",
")",
":",
"if",
"isinstance",
"(",
"index",
",",
"int",
")",
":",
"return",
"(",
"index",
">=",
"0",
")",
"and",
"(",
"index",
"<",
"len",
"(",
"self",
")",
")",
"if",
"isinstance",
"(",
"index",... | Return ``True`` if and only if the given ``index``
is valid. | [
"Return",
"True",
"if",
"and",
"only",
"if",
"the",
"given",
"index",
"is",
"valid",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/syncmap/fragmentlist.py#L105-L117 |
245,996 | readbeyond/aeneas | aeneas/syncmap/fragmentlist.py | SyncMapFragmentList._check_boundaries | def _check_boundaries(self, fragment):
"""
Check that the interval of the given fragment
is within the boundaries of the list.
Raises an error if not OK.
"""
if not isinstance(fragment, SyncMapFragment):
raise TypeError(u"fragment is not an instance of SyncMapFragment")
interval = fragment.interval
if not isinstance(interval, TimeInterval):
raise TypeError(u"interval is not an instance of TimeInterval")
if (self.begin is not None) and (interval.begin < self.begin):
raise ValueError(u"interval.begin is before self.begin")
if (self.end is not None) and (interval.end > self.end):
raise ValueError(u"interval.end is after self.end") | python | def _check_boundaries(self, fragment):
if not isinstance(fragment, SyncMapFragment):
raise TypeError(u"fragment is not an instance of SyncMapFragment")
interval = fragment.interval
if not isinstance(interval, TimeInterval):
raise TypeError(u"interval is not an instance of TimeInterval")
if (self.begin is not None) and (interval.begin < self.begin):
raise ValueError(u"interval.begin is before self.begin")
if (self.end is not None) and (interval.end > self.end):
raise ValueError(u"interval.end is after self.end") | [
"def",
"_check_boundaries",
"(",
"self",
",",
"fragment",
")",
":",
"if",
"not",
"isinstance",
"(",
"fragment",
",",
"SyncMapFragment",
")",
":",
"raise",
"TypeError",
"(",
"u\"fragment is not an instance of SyncMapFragment\"",
")",
"interval",
"=",
"fragment",
".",... | Check that the interval of the given fragment
is within the boundaries of the list.
Raises an error if not OK. | [
"Check",
"that",
"the",
"interval",
"of",
"the",
"given",
"fragment",
"is",
"within",
"the",
"boundaries",
"of",
"the",
"list",
".",
"Raises",
"an",
"error",
"if",
"not",
"OK",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/syncmap/fragmentlist.py#L119-L133 |
245,997 | readbeyond/aeneas | aeneas/syncmap/fragmentlist.py | SyncMapFragmentList.remove | def remove(self, indices):
"""
Remove the fragments corresponding to the given list of indices.
:param indices: the list of indices to be removed
:type indices: list of int
:raises ValueError: if one of the indices is not valid
"""
if not self._is_valid_index(indices):
self.log_exc(u"The given list of indices is not valid", None, True, ValueError)
new_fragments = []
sorted_indices = sorted(indices)
i = 0
j = 0
while (i < len(self)) and (j < len(sorted_indices)):
if i != sorted_indices[j]:
new_fragments.append(self[i])
else:
j += 1
i += 1
while i < len(self):
new_fragments.append(self[i])
i += 1
self.__fragments = new_fragments | python | def remove(self, indices):
if not self._is_valid_index(indices):
self.log_exc(u"The given list of indices is not valid", None, True, ValueError)
new_fragments = []
sorted_indices = sorted(indices)
i = 0
j = 0
while (i < len(self)) and (j < len(sorted_indices)):
if i != sorted_indices[j]:
new_fragments.append(self[i])
else:
j += 1
i += 1
while i < len(self):
new_fragments.append(self[i])
i += 1
self.__fragments = new_fragments | [
"def",
"remove",
"(",
"self",
",",
"indices",
")",
":",
"if",
"not",
"self",
".",
"_is_valid_index",
"(",
"indices",
")",
":",
"self",
".",
"log_exc",
"(",
"u\"The given list of indices is not valid\"",
",",
"None",
",",
"True",
",",
"ValueError",
")",
"new_... | Remove the fragments corresponding to the given list of indices.
:param indices: the list of indices to be removed
:type indices: list of int
:raises ValueError: if one of the indices is not valid | [
"Remove",
"the",
"fragments",
"corresponding",
"to",
"the",
"given",
"list",
"of",
"indices",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/syncmap/fragmentlist.py#L223-L246 |
245,998 | readbeyond/aeneas | aeneas/syncmap/fragmentlist.py | SyncMapFragmentList.sort | def sort(self):
"""
Sort the fragments in the list.
:raises ValueError: if there is a fragment which violates
the list constraints
"""
if self.is_guaranteed_sorted:
self.log(u"Already sorted, returning")
return
self.log(u"Sorting...")
self.__fragments = sorted(self.__fragments)
self.log(u"Sorting... done")
self.log(u"Checking relative positions...")
for i in range(len(self) - 1):
current_interval = self[i].interval
next_interval = self[i + 1].interval
if current_interval.relative_position_of(next_interval) not in self.ALLOWED_POSITIONS:
self.log(u"Found overlapping fragments:")
self.log([u" Index %d => %s", i, current_interval])
self.log([u" Index %d => %s", i + 1, next_interval])
self.log_exc(u"The list contains two fragments overlapping in a forbidden way", None, True, ValueError)
self.log(u"Checking relative positions... done")
self.__sorted = True | python | def sort(self):
if self.is_guaranteed_sorted:
self.log(u"Already sorted, returning")
return
self.log(u"Sorting...")
self.__fragments = sorted(self.__fragments)
self.log(u"Sorting... done")
self.log(u"Checking relative positions...")
for i in range(len(self) - 1):
current_interval = self[i].interval
next_interval = self[i + 1].interval
if current_interval.relative_position_of(next_interval) not in self.ALLOWED_POSITIONS:
self.log(u"Found overlapping fragments:")
self.log([u" Index %d => %s", i, current_interval])
self.log([u" Index %d => %s", i + 1, next_interval])
self.log_exc(u"The list contains two fragments overlapping in a forbidden way", None, True, ValueError)
self.log(u"Checking relative positions... done")
self.__sorted = True | [
"def",
"sort",
"(",
"self",
")",
":",
"if",
"self",
".",
"is_guaranteed_sorted",
":",
"self",
".",
"log",
"(",
"u\"Already sorted, returning\"",
")",
"return",
"self",
".",
"log",
"(",
"u\"Sorting...\"",
")",
"self",
".",
"__fragments",
"=",
"sorted",
"(",
... | Sort the fragments in the list.
:raises ValueError: if there is a fragment which violates
the list constraints | [
"Sort",
"the",
"fragments",
"in",
"the",
"list",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/syncmap/fragmentlist.py#L248-L271 |
245,999 | readbeyond/aeneas | aeneas/syncmap/fragmentlist.py | SyncMapFragmentList.remove_nonspeech_fragments | def remove_nonspeech_fragments(self, zero_length_only=False):
"""
Remove ``NONSPEECH`` fragments from the list.
If ``zero_length_only`` is ``True``, remove only
those fragments with zero length,
and make all the others ``REGULAR``.
:param bool zero_length_only: remove only zero length NONSPEECH fragments
"""
self.log(u"Removing nonspeech fragments...")
nonspeech = list(self.nonspeech_fragments)
if zero_length_only:
nonspeech = [(i, f) for i, f in nonspeech if f.has_zero_length]
nonspeech_indices = [i for i, f in nonspeech]
self.remove(nonspeech_indices)
if zero_length_only:
for i, f in list(self.nonspeech_fragments):
f.fragment_type = SyncMapFragment.REGULAR
self.log(u"Removing nonspeech fragments... done") | python | def remove_nonspeech_fragments(self, zero_length_only=False):
self.log(u"Removing nonspeech fragments...")
nonspeech = list(self.nonspeech_fragments)
if zero_length_only:
nonspeech = [(i, f) for i, f in nonspeech if f.has_zero_length]
nonspeech_indices = [i for i, f in nonspeech]
self.remove(nonspeech_indices)
if zero_length_only:
for i, f in list(self.nonspeech_fragments):
f.fragment_type = SyncMapFragment.REGULAR
self.log(u"Removing nonspeech fragments... done") | [
"def",
"remove_nonspeech_fragments",
"(",
"self",
",",
"zero_length_only",
"=",
"False",
")",
":",
"self",
".",
"log",
"(",
"u\"Removing nonspeech fragments...\"",
")",
"nonspeech",
"=",
"list",
"(",
"self",
".",
"nonspeech_fragments",
")",
"if",
"zero_length_only",... | Remove ``NONSPEECH`` fragments from the list.
If ``zero_length_only`` is ``True``, remove only
those fragments with zero length,
and make all the others ``REGULAR``.
:param bool zero_length_only: remove only zero length NONSPEECH fragments | [
"Remove",
"NONSPEECH",
"fragments",
"from",
"the",
"list",
"."
] | 9d95535ad63eef4a98530cfdff033b8c35315ee1 | https://github.com/readbeyond/aeneas/blob/9d95535ad63eef4a98530cfdff033b8c35315ee1/aeneas/syncmap/fragmentlist.py#L273-L292 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.