local M = {}

local mkutils = require "mkutils"

local task_template = [[
<task>
   <task_language>${lang}</task_language>
   <task_description>${file_desc}</task_description>
   <task_custom_id>${file_id}</task_custom_id>
   <is_text_file>${prefix}${html_file}</is_text_file>
   <is_text_type>${text_type}</is_text_type>
   <is_audio_file>${prefix}${audio_file}</is_audio_file>
   <is_text_unparsed_id_sort>${id_sort}</is_text_unparsed_id_sort>
   <is_text_unparsed_id_regex>${id_regex}</is_text_unparsed_id_regex>
   <os_task_file_name>${sub_file}</os_task_file_name>
   <os_task_file_format>${sub_format}</os_task_file_format>
   <os_task_file_smil_page_ref>${html_file}</os_task_file_smil_page_ref>
   <os_task_file_smil_audio_ref>${audio_file}</os_task_file_smil_audio_ref>
</task>
]]

-- get html files
local function get_html_files(config)
 local config = config or {}
 local files = {}
 local filematch = config.file_match or  "html$"
 -- this is a trick to get list of files from the LG file
 for _, file in ipairs(Make.lgfile.files) do
   if file:match(filematch) then table.insert(files, file) end
 end
 return files
end

-- prepare filename for the audio
local function get_audio_file(filename, config)
 local extension = config.audio_extension or "mp3"
 local base = mkutils.remove_extension(filename)
 return base .. "." .. extension
end

local function get_sub_file(filename, config)
 local extension = config.sub_format or "smil"
 local base = mkutils.remove_extension(filename)
 return base .. "." .. extension
end


-- create task record for each HTML file
local function prepare_tasks(files, configuration)
 local tasks = {}
 --  the map can contain info for particular files, otherwise we will interfere default values
 local map = configuration.map or {}
 -- task_template should be configurable
 local task_template = configuration.task_template or task_template
 for i, filename in ipairs(files) do
   local filemap = map[filename]
   if filemap ~= false then
     filemap = filemap or {}
     local taskconfig = configuration
     taskconfig.html_file = filename
     taskconfig.prefix = filemap.prefix or configuration.prefix
     taskconfig.file_desc = filemap.description or configuration.description .. " " .. i
     taskconfig.file_id = filemap.id or filename:gsub("[%/%.]", "_")
     taskconfig.text_type = filemap.text_type or configuration.text_type
     taskconfig.audio_file = filemap.audio_file or get_audio_file(filename, configuration)
     taskconfig.sub_file = filemap.sub_file or get_sub_file(filename, configuration)
     taskconfig.id_sort= filemap.id_sort  or configuration.id_sort
     taskconfig.id_prefix = filemap.id_regex or configuration.id_regex
     taskconfig.sub_format = filemap.sub_format or configuration.sub_format
     tasks[#tasks+1] = task_template % taskconfig
     Make:add_file(taskconfig.audio_file)
     Make:add_file(taskconfig.sub_file)
   end
 end
 return tasks --table.concat(tasks, "\n")
end
-- from https://www.readbeyond.it/aeneas/docs/clitutorial.html#xml-config-file-config-xml
local config_template = [[
<job>
   <job_language>${lang}</job_language>
   <job_description>${description}</job_description>
   <tasks>
   ${tasks}
   </tasks>
   <os_job_file_name>output_example4</os_job_file_name>
   <os_job_file_container>zip</os_job_file_container>
   <os_job_file_hierarchy_type>flat</os_job_file_hierarchy_type>
   <os_job_file_hierarchy_prefix>${prefix}</os_job_file_hierarchy_prefix>
</job>
]]

-- check if the config file exists
local function is_config(filename)
 return mkutils.file_exists(filename)
end

-- prepare Aeneas configuration
local function prepare_configuration(parameters)
 local config = parameters or {}
 config.lang = parameters.lang
 config.tasks = table.concat(prepare_tasks(parameters.files, config), "\n")
 return config
end

-- write Aeneeas configuration file in the XML format
local function write_config(filename, configuration)
 local cfg = config_template % configuration
 print(cfg)
 local f = io.open(filename, "w")
 f:write(cfg)
 f:close()
end


local function make_default_options(options)
 local configuration = {}
 local par = get_filter_settings "aeneas-config"
 configuration.lang = options.lang or par.lang or "en"
 configuration.description = options.description or par.description or "Aeneas job"
 configuration.map = options.map or par.map or {}
 configuration.text_type = options.text_type or par.text_type or "unparsed"
 configuration.id_sort = options.id_sort or par.id_sort or "numeric"
 configuration.id_regex = options.id_regex or par.id_regex or par.id_prefix .. "[0-9]+"
 configuration.sub_format = options.sub_format or par.sub_format or "smil"
 configuration.prefix = options.prefix or par.prefix or "./"
 configuration.config_name = options.config_name or par.config_name or "config.xml"
 configuration.keep_config = options.keep_config or par.keep_config
 return configuration
end


local function configure_job(options)
 local configuration = make_default_options(options)
 local config_name = configuration.config_name
 -- prepare the configuration in every case
 configuration.files = get_html_files()
 local configuration = prepare_configuration(configuration)
 -- write the configuration only if the config file doesn't exist
 -- and keep_config option is set to true
 if is_config(config_name) and configuration.keep_config==true then
 else
   write_config(config_name, configuration)
 end
end

local function execute_job(options)
 local par = get_filter_settings "aeneas-config"
 local configuration = make_default_options(options)
 configuration.files = get_html_files()
 -- we need to configure prepare_tasks to return calls to aeneas task convertor
 configuration.python = options.python or par.python or "python3"
 configuration.module = options.module or par.module or "aeneas.tools.execute_task"
 configuration.task_template = '${python} -m "${module}" "${audio_file}" "${html_file}" "is_text_type=${text_type}|os_task_file_smil_audio_ref=${audio_file}|os_task_file_smil_page_ref=${html_file}|task_language=${lang}|is_text_unparsed_id_sort=${id_sort}|is_text_unparsed_id_regex=${id_regex}|os_task_file_format=${sub_format}" "${sub_file}"'
 local tasks = prepare_tasks(configuration.files, configuration)
 -- execute the tasks
 for _, v in ipairs(tasks) do
   print("task", v)
   local proc = io.popen(v, "r")
   local result = proc:read("*all")
   proc:close()
   print(result)
 end
end

-- the aeneas configuration must be executed at last processed file, after all filters
-- have been executed
local function get_last_lg_file()
 local t = Make.lgfile.files
 for i = #t, 1, -1 do
   --  find last html file or the tmp file
   local x = t[i]
   if x:match "html$" or x:match "tmp$" then
     return x
   end
 end
 return t[#t]
end

-- write Aeneas job configuration file
-- it doesn't execute Aeneas
function M.write_job(par)
 -- configuration table for Aeneas job
 Make:match("tmp$", function()
   configure_job(par)
 end)
end

-- execute Aeneas directly
function M.execute(par)
 Make:match("tmp$", function(current_name)
   -- there may be html files after the .tmp file
   -- the aeneas must be executed after the Aeneas filter inserts the id
   -- attributes, so it is necessary to execute this code as very last one
   local last = get_last_lg_file()
   -- execute the job if there are no HTML files after the tmp file
   if current_name == last then
     execute_job(par)
   end
   Make:match(last, function()
     execute_job(par)
   end)
 end)
end

-- only register the audio and smil files as processed files
function M.process_files(par)
 Make:match("tmp$", function()
   local configuration = make_default_options(par)
   local files = get_html_files()
   prepare_tasks(files, configuration)
 end)
end


return M

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.