def test_delete_tasks(self):
job = Job()
task1 = Task()
job.tasks.append(task1)
self.assertEqual(len(job), 1)
job.tasks = []
self.assertEqual(len(job), 0)
def test_job_clear_tasks(self):
job = Job()
task1 = Task()
job.tasks.append(task1)
self.assertEqual(len(job), 1)
job.clear_tasks()
self.assertEqual(len(job), 0)
def test_job_clear_tasks(self):
job = Job()
task1 = Task()
job.tasks.append(task1)
self.assertEqual(len(job), 1)
job.clear_tasks()
self.assertEqual(len(job), 0)
def test_job_add_task(self):
job = Job()
self.assertEqual(len(job), 0)
task1 = Task()
job.add_task(task1)
self.assertEqual(len(job), 1)
task2 = Task()
job.add_task(task2)
self.assertEqual(len(job), 2)
task3 = Task()
job.add_task(task3)
self.assertEqual(len(job), 3)
def test_job_add_task(self):
job = Job()
self.assertEqual(len(job), 0)
task1 = Task()
job.add_task(task1)
self.assertEqual(len(job), 1)
task2 = Task()
job.add_task(task2)
self.assertEqual(len(job), 2)
task3 = Task()
job.add_task(task3)
self.assertEqual(len(job), 3)
def test_job_string_configuration_unicode(self):
job = Job(u"job_language=eng")
self.assertIsNotNone(job.configuration)
def test_job_string_configuration_bytes(self):
with self.assertRaises(TypeError):
job = Job(b"job_language=eng")
def test_job_string_configuration_invalid(self):
with self.assertRaises(TypeError):
job = Job(1)
def test_job_empty_configuration(self):
job = Job()
self.assertIsNone(job.configuration)
def test_job_empty_on_creation(self):
job = Job()
self.assertEqual(len(job), 0)
def test_job_identifier(self):
job = Job()
self.assertEqual(len(job.identifier), 36)
def _analyze_xml_config(self, config_contents=None):
"""
Analyze the given container and return the corresponding job.
If ``config_contents`` is ``None``,
try reading it from the XML config file inside the container.
:param string config_contents: the contents of the XML config file
:rtype: :class:`~aeneas.job.Job`
"""
self.log(u"Analyzing container with XML config string")
if config_contents is None:
self.log(u"Analyzing container with XML config file")
config_entry = self.container.entry_config_xml
self.log([u"Found XML config entry '%s'", config_entry])
config_dir = os.path.dirname(config_entry)
self.log([u"Directory of XML config entry: '%s'", config_dir])
self.log([u"Reading XML config entry: '%s'", config_entry])
config_contents = self.container.read_entry(config_entry)
else:
self.log(u"Analyzing container with XML config contents")
config_dir = ""
self.log(u"Converting config contents into job config dict")
job_parameters = gf.config_xml_to_dict(config_contents,
result=None,
parse_job=True)
self.log(u"Converting config contents into tasks config dict")
tasks_parameters = gf.config_xml_to_dict(config_contents,
result=None,
parse_job=False)
self.log(u"Calculating the path of the sync map root directory")
sync_map_root_directory = gf.norm_join(
config_dir, job_parameters[gc.PPN_JOB_OS_HIERARCHY_PREFIX])
job_os_hierarchy_type = job_parameters[gc.PPN_JOB_OS_HIERARCHY_TYPE]
self.log([
u"Path of the sync map root directory: '%s'",
sync_map_root_directory
])
self.log(u"Converting job config dict into job config string")
config_string = gf.config_dict_to_string(job_parameters)
job = Job(config_string)
for task_parameters in tasks_parameters:
self.log(u"Converting task config dict into task config string")
config_string = gf.config_dict_to_string(task_parameters)
self.log([u"Creating task with config string '%s'", config_string])
try:
custom_id = task_parameters[gc.PPN_TASK_CUSTOM_ID]
except KeyError:
custom_id = ""
task_info = [
custom_id,
gf.norm_join(config_dir,
task_parameters[gc.PPN_TASK_IS_TEXT_FILE_XML]),
gf.norm_join(config_dir,
task_parameters[gc.PPN_TASK_IS_AUDIO_FILE_XML])
]
self.log([u"Creating task: '%s'", str(task_info)])
task = self._create_task(task_info, config_string,
sync_map_root_directory,
job_os_hierarchy_type)
job.add_task(task)
return job
def _analyze_xml_config(self, config_contents=None):
"""
Analyze the given container and return the corresponding job.
If ``config_contents`` is ``None``,
try reading it from the XML config file inside the container.
:param string config_contents: the contents of the XML config file
:rtype: :class:`~aeneas.job.Job`
"""
self.log(u"Analyzing container with XML config string")
if config_contents is None:
self.log(u"Analyzing container with XML config file")
config_entry = self.container.entry_config_xml
self.log([u"Found XML config entry '%s'", config_entry])
config_dir = os.path.dirname(config_entry)
self.log([u"Directory of XML config entry: '%s'", config_dir])
self.log([u"Reading XML config entry: '%s'", config_entry])
config_contents = self.container.read_entry(config_entry)
else:
self.log(u"Analyzing container with XML config contents")
config_dir = ""
self.log(u"Converting config contents into job config dict")
job_parameters = gf.config_xml_to_dict(
config_contents,
result=None,
parse_job=True
)
self.log(u"Converting config contents into tasks config dict")
tasks_parameters = gf.config_xml_to_dict(
config_contents,
result=None,
parse_job=False
)
self.log(u"Calculating the path of the sync map root directory")
sync_map_root_directory = gf.norm_join(
config_dir,
job_parameters[gc.PPN_JOB_OS_HIERARCHY_PREFIX]
)
job_os_hierarchy_type = job_parameters[gc.PPN_JOB_OS_HIERARCHY_TYPE]
self.log([u"Path of the sync map root directory: '%s'", sync_map_root_directory])
self.log(u"Converting job config dict into job config string")
config_string = gf.config_dict_to_string(job_parameters)
job = Job(config_string)
for task_parameters in tasks_parameters:
self.log(u"Converting task config dict into task config string")
config_string = gf.config_dict_to_string(task_parameters)
self.log([u"Creating task with config string '%s'", config_string])
try:
custom_id = task_parameters[gc.PPN_TASK_CUSTOM_ID]
except KeyError:
custom_id = ""
task_info = [
custom_id,
gf.norm_join(
config_dir,
task_parameters[gc.PPN_TASK_IS_TEXT_FILE_XML]
),
gf.norm_join(
config_dir,
task_parameters[gc.PPN_TASK_IS_AUDIO_FILE_XML]
)
]
self.log([u"Creating task: '%s'", str(task_info)])
task = self._create_task(
task_info,
config_string,
sync_map_root_directory,
job_os_hierarchy_type
)
job.add_task(task)
return job
def test_job_empty_configuration(self):
job = Job()
self.assertEqual(job.configuration, None)
def test_job_set_configuration(self):
job = Job()
jobconf = JobConfiguration()
job.configuration = jobconf
self.assertIsNotNone(job.configuration)
def test_job_string_configuration(self):
job = Job("job_language=en")
self.assertNotEqual(job.configuration, None)
def test_set_configuration(self):
job = Job()
jobconf = JobConfiguration()
job.configuration = jobconf
self.assertNotEqual(job.configuration, None)
def _analyze_txt_config(self, config_string=None):
"""
Analyze the given container and return the corresponding job.
If ``config_string`` is ``None``,
try reading it from the TXT config file inside the container.
:param string config_string: the configuration string
:rtype: :class:`~aeneas.job.Job`
"""
self.log(u"Analyzing container with TXT config string")
if config_string is None:
self.log(u"Analyzing container with TXT config file")
config_entry = self.container.entry_config_txt
self.log([u"Found TXT config entry '%s'", config_entry])
config_dir = os.path.dirname(config_entry)
self.log([u"Directory of TXT config entry: '%s'", config_dir])
self.log([u"Reading TXT config entry: '%s'", config_entry])
config_contents = self.container.read_entry(config_entry)
self.log(u"Converting config contents to config string")
config_contents = gf.safe_unicode(config_contents)
config_string = gf.config_txt_to_string(config_contents)
else:
self.log([
u"Analyzing container with TXT config string '%s'",
config_string
])
config_dir = ""
self.log(u"Creating the Job object")
job = Job(config_string)
self.log(u"Getting entries")
entries = self.container.entries
self.log(u"Converting config string into config dict")
parameters = gf.config_string_to_dict(config_string)
self.log(u"Calculating the path of the tasks root directory")
tasks_root_directory = gf.norm_join(
config_dir, parameters[gc.PPN_JOB_IS_HIERARCHY_PREFIX])
self.log(
[u"Path of the tasks root directory: '%s'", tasks_root_directory])
self.log(u"Calculating the path of the sync map root directory")
sync_map_root_directory = gf.norm_join(
config_dir, parameters[gc.PPN_JOB_OS_HIERARCHY_PREFIX])
job_os_hierarchy_type = parameters[gc.PPN_JOB_OS_HIERARCHY_TYPE]
self.log([
u"Path of the sync map root directory: '%s'",
sync_map_root_directory
])
text_file_relative_path = parameters[
gc.PPN_JOB_IS_TEXT_FILE_RELATIVE_PATH]
self.log(
[u"Relative path for text file: '%s'", text_file_relative_path])
text_file_name_regex = re.compile(
r"" + parameters[gc.PPN_JOB_IS_TEXT_FILE_NAME_REGEX])
self.log([
u"Regex for text file: '%s'",
parameters[gc.PPN_JOB_IS_TEXT_FILE_NAME_REGEX]
])
audio_file_relative_path = parameters[
gc.PPN_JOB_IS_AUDIO_FILE_RELATIVE_PATH]
self.log(
[u"Relative path for audio file: '%s'", audio_file_relative_path])
audio_file_name_regex = re.compile(
r"" + parameters[gc.PPN_JOB_IS_AUDIO_FILE_NAME_REGEX])
self.log([
u"Regex for audio file: '%s'",
parameters[gc.PPN_JOB_IS_AUDIO_FILE_NAME_REGEX]
])
if parameters[gc.PPN_JOB_IS_HIERARCHY_TYPE] == HierarchyType.FLAT:
self.log(u"Looking for text/audio pairs in flat hierarchy")
text_files = self._find_files(entries, tasks_root_directory,
text_file_relative_path,
text_file_name_regex)
self.log([u"Found text files: '%s'", text_files])
audio_files = self._find_files(entries, tasks_root_directory,
audio_file_relative_path,
audio_file_name_regex)
self.log([u"Found audio files: '%s'", audio_files])
self.log(u"Matching files in flat hierarchy...")
matched_tasks = self._match_files_flat_hierarchy(
text_files, audio_files)
self.log(u"Matching files in flat hierarchy... done")
for task_info in matched_tasks:
self.log([u"Creating task: '%s'", str(task_info)])
task = self._create_task(task_info, config_string,
sync_map_root_directory,
job_os_hierarchy_type)
job.add_task(task)
if parameters[gc.PPN_JOB_IS_HIERARCHY_TYPE] == HierarchyType.PAGED:
self.log(u"Looking for text/audio pairs in paged hierarchy")
# find all subdirectories of tasks_root_directory
# that match gc.PPN_JOB_IS_TASK_DIRECTORY_NAME_REGEX
matched_directories = self._match_directories(
entries, tasks_root_directory,
parameters[gc.PPN_JOB_IS_TASK_DIRECTORY_NAME_REGEX])
for matched_directory in matched_directories:
# rebuild the full path
matched_directory_full_path = gf.norm_join(
tasks_root_directory, matched_directory)
self.log([
u"Looking for text/audio pairs in directory '%s'",
matched_directory_full_path
])
# look for text and audio files there
text_files = self._find_files(entries,
matched_directory_full_path,
text_file_relative_path,
text_file_name_regex)
self.log([u"Found text files: '%s'", text_files])
audio_files = self._find_files(entries,
matched_directory_full_path,
audio_file_relative_path,
audio_file_name_regex)
self.log([u"Found audio files: '%s'", audio_files])
# if we have found exactly one text and one audio file,
# create a Task
if (len(text_files) == 1) and (len(audio_files) == 1):
self.log([
u"Exactly one text file and one audio file in '%s'",
matched_directory
])
task_info = [
matched_directory, text_files[0], audio_files[0]
]
self.log([u"Creating task: '%s'", str(task_info)])
task = self._create_task(task_info, config_string,
sync_map_root_directory,
job_os_hierarchy_type)
job.add_task(task)
elif len(text_files) > 1:
self.log([
u"More than one text file in '%s'", matched_directory
])
elif len(audio_files) > 1:
self.log([
u"More than one audio file in '%s'", matched_directory
])
else:
self.log(
[u"No text nor audio file in '%s'", matched_directory])
return job
def test_job_set_configuration(self):
job = Job()
jobconf = JobConfiguration()
job.configuration = jobconf
self.assertIsNotNone(job.configuration)
def _analyze_xml_config(self, config_contents=None):
"""
Analyze the given container and return the corresponding job.
If ``config_contents`` is ``None``,
try reading it from the XML config file inside the container.
:param config_contents: the contents of the XML config file
:type config_contents: string
:rtype: :class:`aeneas.job.Job`
"""
# TODO break this function down into smaller functions
self._log("Analyzing container with XML config string")
if config_contents is None:
self._log("Analyzing container with XML config file")
config_entry = self.container.entry_config_xml
self._log(["Found XML config entry '%s'", config_entry])
config_dir = os.path.dirname(config_entry)
self._log(["Directory of XML config entry: '%s'", config_dir])
self._log(["Reading XML config entry: '%s'", config_entry])
config_contents = self.container.read_entry(config_entry)
else:
self._log("Analyzing container with XML config contents")
config_dir = ""
# remove BOM
#self._log("Removing BOM")
#config_contents = gf.remove_bom(config_contents)
# get the job parameters and tasks parameters
self._log("Converting config contents into job config dict")
job_parameters = gf.config_xml_to_dict(config_contents,
result=None,
parse_job=True)
self._log("Converting config contents into tasks config dict")
tasks_parameters = gf.config_xml_to_dict(config_contents,
result=None,
parse_job=False)
# compute the root directory for the sync map files
self._log("Calculating the path of the sync map root directory")
sync_map_root_directory = gf.norm_join(
config_dir, job_parameters[gc.PPN_JOB_OS_HIERARCHY_PREFIX])
job_os_hierarchy_type = job_parameters[gc.PPN_JOB_OS_HIERARCHY_TYPE]
self._log([
"Path of the sync map root directory: '%s'",
sync_map_root_directory
])
# create the Job object to be returned
self._log("Converting job config dict into job config string")
config_string = gf.config_dict_to_string(job_parameters)
job = Job(config_string)
# create the Task objects
for task_parameters in tasks_parameters:
self._log("Converting task config dict into task config string")
config_string = gf.config_dict_to_string(task_parameters)
self._log(["Creating task with config string '%s'", config_string])
try:
custom_id = task_parameters[gc.PPN_TASK_CUSTOM_ID]
except KeyError:
custom_id = ""
task_info = [
custom_id,
gf.norm_join(config_dir,
task_parameters[gc.PPN_TASK_IS_TEXT_FILE_XML]),
gf.norm_join(config_dir,
task_parameters[gc.PPN_TASK_IS_AUDIO_FILE_XML])
]
self._log(["Creating task: '%s'", str(task_info)])
task = self._create_task(task_info, config_string,
sync_map_root_directory,
job_os_hierarchy_type)
job.add_task(task)
# return the Job
return job
def test_job_set_configuration(self):
job = Job()
jobconf = JobConfiguration()
job.configuration = jobconf
self.assertNotEqual(job.configuration, None)
def _analyze_xml_config(self, config_contents=None):
"""
Analyze the given container and return the corresponding job.
If ``config_contents`` is ``None``,
try reading it from the XML config file inside the container.
:param config_contents: the contents of the XML config file
:type config_contents: string
:rtype: :class:`aeneas.job.Job`
"""
# TODO break this function down into smaller functions
self._log("Analyzing container with XML config string")
if config_contents is None:
self._log("Analyzing container with XML config file")
config_entry = self.container.entry_config_xml
self._log(["Found XML config entry '%s'", config_entry])
config_dir = os.path.dirname(config_entry)
self._log(["Directory of XML config entry: '%s'", config_dir])
self._log(["Reading XML config entry: '%s'", config_entry])
config_contents = self.container.read_entry(config_entry)
else:
self._log("Analyzing container with XML config contents")
config_dir = ""
# remove BOM
#self._log("Removing BOM")
#config_contents = gf.remove_bom(config_contents)
# get the job parameters and tasks parameters
self._log("Converting config contents into job config dict")
job_parameters = gf.config_xml_to_dict(
config_contents,
result=None,
parse_job=True
)
self._log("Converting config contents into tasks config dict")
tasks_parameters = gf.config_xml_to_dict(
config_contents,
result=None,
parse_job=False
)
# compute the root directory for the sync map files
self._log("Calculating the path of the sync map root directory")
sync_map_root_directory = gf.norm_join(
config_dir,
job_parameters[gc.PPN_JOB_OS_HIERARCHY_PREFIX]
)
job_os_hierarchy_type = job_parameters[gc.PPN_JOB_OS_HIERARCHY_TYPE]
self._log(["Path of the sync map root directory: '%s'", sync_map_root_directory])
# create the Job object to be returned
self._log("Converting job config dict into job config string")
config_string = gf.config_dict_to_string(job_parameters)
job = Job(config_string)
# create the Task objects
for task_parameters in tasks_parameters:
self._log("Converting task config dict into task config string")
config_string = gf.config_dict_to_string(task_parameters)
self._log(["Creating task with config string '%s'", config_string])
try:
custom_id = task_parameters[gc.PPN_TASK_CUSTOM_ID]
except KeyError:
custom_id = ""
task_info = [
custom_id,
gf.norm_join(
config_dir,
task_parameters[gc.PPN_TASK_IS_TEXT_FILE_XML]
),
gf.norm_join(
config_dir,
task_parameters[gc.PPN_TASK_IS_AUDIO_FILE_XML]
)
]
self._log(["Creating task: '%s'", str(task_info)])
task = self._create_task(
task_info,
config_string,
sync_map_root_directory,
job_os_hierarchy_type
)
job.add_task(task)
# return the Job
return job
def test_job_logger(self):
logger = Logger()
job = Job(logger=logger)
def _analyze_txt_config(self, config_string=None):
"""
Analyze the given container and return the corresponding job.
If ``config_string`` is ``None``,
try reading it from the TXT config file inside the container.
:param string config_string: the configuration string
:rtype: :class:`~aeneas.job.Job`
"""
self.log(u"Analyzing container with TXT config string")
if config_string is None:
self.log(u"Analyzing container with TXT config file")
config_entry = self.container.entry_config_txt
self.log([u"Found TXT config entry '%s'", config_entry])
config_dir = os.path.dirname(config_entry)
self.log([u"Directory of TXT config entry: '%s'", config_dir])
self.log([u"Reading TXT config entry: '%s'", config_entry])
config_contents = self.container.read_entry(config_entry)
self.log(u"Converting config contents to config string")
config_contents = gf.safe_unicode(config_contents)
config_string = gf.config_txt_to_string(config_contents)
else:
self.log([u"Analyzing container with TXT config string '%s'", config_string])
config_dir = ""
self.log(u"Creating the Job object")
job = Job(config_string)
self.log(u"Getting entries")
entries = self.container.entries
self.log(u"Converting config string into config dict")
parameters = gf.config_string_to_dict(config_string)
self.log(u"Calculating the path of the tasks root directory")
tasks_root_directory = gf.norm_join(
config_dir,
parameters[gc.PPN_JOB_IS_HIERARCHY_PREFIX]
)
self.log([u"Path of the tasks root directory: '%s'", tasks_root_directory])
self.log(u"Calculating the path of the sync map root directory")
sync_map_root_directory = gf.norm_join(
config_dir,
parameters[gc.PPN_JOB_OS_HIERARCHY_PREFIX]
)
job_os_hierarchy_type = parameters[gc.PPN_JOB_OS_HIERARCHY_TYPE]
self.log([u"Path of the sync map root directory: '%s'", sync_map_root_directory])
text_file_relative_path = parameters[gc.PPN_JOB_IS_TEXT_FILE_RELATIVE_PATH]
self.log([u"Relative path for text file: '%s'", text_file_relative_path])
text_file_name_regex = re.compile(r"" + parameters[gc.PPN_JOB_IS_TEXT_FILE_NAME_REGEX])
self.log([u"Regex for text file: '%s'", parameters[gc.PPN_JOB_IS_TEXT_FILE_NAME_REGEX]])
audio_file_relative_path = parameters[gc.PPN_JOB_IS_AUDIO_FILE_RELATIVE_PATH]
self.log([u"Relative path for audio file: '%s'", audio_file_relative_path])
audio_file_name_regex = re.compile(r"" + parameters[gc.PPN_JOB_IS_AUDIO_FILE_NAME_REGEX])
self.log([u"Regex for audio file: '%s'", parameters[gc.PPN_JOB_IS_AUDIO_FILE_NAME_REGEX]])
if parameters[gc.PPN_JOB_IS_HIERARCHY_TYPE] == HierarchyType.FLAT:
self.log(u"Looking for text/audio pairs in flat hierarchy")
text_files = self._find_files(
entries,
tasks_root_directory,
text_file_relative_path,
text_file_name_regex
)
self.log([u"Found text files: '%s'", text_files])
audio_files = self._find_files(
entries,
tasks_root_directory,
audio_file_relative_path,
audio_file_name_regex
)
self.log([u"Found audio files: '%s'", audio_files])
self.log(u"Matching files in flat hierarchy...")
matched_tasks = self._match_files_flat_hierarchy(
text_files,
audio_files
)
self.log(u"Matching files in flat hierarchy... done")
for task_info in matched_tasks:
self.log([u"Creating task: '%s'", str(task_info)])
task = self._create_task(
task_info,
config_string,
sync_map_root_directory,
job_os_hierarchy_type
)
job.add_task(task)
if parameters[gc.PPN_JOB_IS_HIERARCHY_TYPE] == HierarchyType.PAGED:
self.log(u"Looking for text/audio pairs in paged hierarchy")
# find all subdirectories of tasks_root_directory
# that match gc.PPN_JOB_IS_TASK_DIRECTORY_NAME_REGEX
matched_directories = self._match_directories(
entries,
tasks_root_directory,
parameters[gc.PPN_JOB_IS_TASK_DIRECTORY_NAME_REGEX]
)
for matched_directory in matched_directories:
# rebuild the full path
matched_directory_full_path = gf.norm_join(
tasks_root_directory,
matched_directory
)
self.log([u"Looking for text/audio pairs in directory '%s'", matched_directory_full_path])
# look for text and audio files there
text_files = self._find_files(
entries,
matched_directory_full_path,
text_file_relative_path,
text_file_name_regex
)
self.log([u"Found text files: '%s'", text_files])
audio_files = self._find_files(
entries,
matched_directory_full_path,
audio_file_relative_path,
audio_file_name_regex
)
self.log([u"Found audio files: '%s'", audio_files])
# if we have found exactly one text and one audio file,
# create a Task
if (len(text_files) == 1) and (len(audio_files) == 1):
self.log([u"Exactly one text file and one audio file in '%s'", matched_directory])
task_info = [
matched_directory,
text_files[0],
audio_files[0]
]
self.log([u"Creating task: '%s'", str(task_info)])
task = self._create_task(
task_info,
config_string,
sync_map_root_directory,
job_os_hierarchy_type
)
job.add_task(task)
elif len(text_files) > 1:
self.log([u"More than one text file in '%s'", matched_directory])
elif len(audio_files) > 1:
self.log([u"More than one audio file in '%s'", matched_directory])
else:
self.log([u"No text nor audio file in '%s'", matched_directory])
return job
def _analyze_txt_config(self, config_string=None):
"""
Analyze the given container and return the corresponding job.
If ``config_string`` is ``None``,
try reading it from the TXT config file inside the container.
:param config_string: the configuration string
:type config_string: string
:rtype: :class:`aeneas.job.Job`
"""
# TODO break this function down into smaller functions
self._log("Analyzing container with TXT config string")
if config_string == None:
self._log("Analyzing container with TXT config file")
config_entry = self.container.entry_config_txt
self._log("Found TXT config entry '%s'" % config_entry)
config_dir = os.path.dirname(config_entry)
self._log("Directory of TXT config entry: '%s'" % config_dir)
self._log("Reading TXT config entry: '%s'" % config_entry)
config_contents = self.container.read_entry(config_entry)
#self._log("Removing BOM")
#config_contents = gf.remove_bom(config_contents)
self._log("Converting config contents to config string")
config_string = gf.config_txt_to_string(config_contents)
else:
self._log("Analyzing container with TXT config string '%s'" % config_string)
config_dir = ""
#self._log("Removing BOM")
#config_string = gf.remove_bom(config_string)
# create the Job object to be returned
self._log("Creating the Job object")
job = Job(config_string)
# get the entries in this container
self._log("Getting entries")
entries = self.container.entries()
# convert the config string to dict
self._log("Converting config string into config dict")
parameters = gf.config_string_to_dict(config_string)
# compute the root directory for the task assets
self._log("Calculating the path of the tasks root directory")
tasks_root_directory = gf.norm_join(
config_dir,
parameters[gc.PPN_JOB_IS_HIERARCHY_PREFIX]
)
self._log("Path of the tasks root directory: '%s'" % tasks_root_directory)
# compute the root directory for the sync map files
self._log("Calculating the path of the sync map root directory")
sync_map_root_directory = gf.norm_join(
config_dir,
parameters[gc.PPN_JOB_OS_HIERARCHY_PREFIX]
)
job_os_hierarchy_type = parameters[gc.PPN_JOB_OS_HIERARCHY_TYPE]
self._log("Path of the sync map root directory: '%s'" % sync_map_root_directory)
# prepare relative path and file name regex for text and audio files
text_file_relative_path = parameters[gc.PPN_JOB_IS_TEXT_FILE_RELATIVE_PATH]
self._log("Relative path for text file: '%s'" % text_file_relative_path)
text_file_name_regex = re.compile(r"" + parameters[gc.PPN_JOB_IS_TEXT_FILE_NAME_REGEX])
self._log("Regex for text file: '%s'" % parameters[gc.PPN_JOB_IS_TEXT_FILE_NAME_REGEX])
audio_file_relative_path = parameters[gc.PPN_JOB_IS_AUDIO_FILE_RELATIVE_PATH]
self._log("Relative path for audio file: '%s'" % audio_file_relative_path)
audio_file_name_regex = re.compile(r"" + parameters[gc.PPN_JOB_IS_AUDIO_FILE_NAME_REGEX])
self._log("Regex for audio file: '%s'" % parameters[gc.PPN_JOB_IS_AUDIO_FILE_NAME_REGEX])
# flat hierarchy
if parameters[gc.PPN_JOB_IS_HIERARCHY_TYPE] == HierarchyType.FLAT:
self._log("Looking for text/audio pairs in flat hierarchy")
text_files = self._find_files(
entries,
tasks_root_directory,
text_file_relative_path,
text_file_name_regex
)
self._log("Found text files: '%s'" % str(text_files))
audio_files = self._find_files(
entries,
tasks_root_directory,
audio_file_relative_path,
audio_file_name_regex
)
self._log("Found audio files: '%s'" % str(audio_files))
self._log("Matching files in flat hierarchy...")
matched_tasks = self._match_files_flat_hierarchy(
text_files,
audio_files
)
self._log("Matching files in flat hierarchy... done")
for task_info in matched_tasks:
self._log("Creating task: '%s'" % str(task_info))
task = self._create_task(
task_info,
config_string,
sync_map_root_directory,
job_os_hierarchy_type
)
job.add_task(task)
# paged hierarchy
if parameters[gc.PPN_JOB_IS_HIERARCHY_TYPE] == HierarchyType.PAGED:
self._log("Looking for text/audio pairs in paged hierarchy")
# find all subdirectories of tasks_root_directory
# that match gc.PPN_JOB_IS_TASK_DIRECTORY_NAME_REGEX
matched_directories = self._match_directories(
entries,
tasks_root_directory,
parameters[gc.PPN_JOB_IS_TASK_DIRECTORY_NAME_REGEX]
)
for matched_directory in matched_directories:
# rebuild the full path
matched_directory_full_path = gf.norm_join(
tasks_root_directory,
matched_directory
)
self._log("Looking for text/audio pairs in directory '%s'" % matched_directory_full_path)
# look for text and audio files there
text_files = self._find_files(
entries,
matched_directory_full_path,
text_file_relative_path,
text_file_name_regex
)
self._log("Found text files: '%s'" % str(text_files))
audio_files = self._find_files(
entries,
matched_directory_full_path,
audio_file_relative_path,
audio_file_name_regex
)
self._log("Found audio files: '%s'" % str(audio_files))
# if we have found exactly one text and one audio file,
# create a Task
if (len(text_files) == 1) and (len(audio_files) == 1):
self._log("Exactly one text file and one audio file in '%s'" % matched_directory)
task_info = [
matched_directory,
text_files[0],
audio_files[0]
]
self._log("Creating task: '%s'" % str(task_info))
task = self._create_task(
task_info,
config_string,
sync_map_root_directory,
job_os_hierarchy_type
)
job.add_task(task)
elif len(text_files) > 1:
self._log("More than one text file in '%s'" % matched_directory)
elif len(audio_files) > 1:
self._log("More than one audio file in '%s'" % matched_directory)
else:
self._log("No text nor audio file in '%s'" % matched_directory)
# return the Job
return job