subtitle 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49e45fb2713aedd5d6d7d6d290fe4874a292df3249cfad7259913e90b0cb7fd8
-  data.tar.gz: 7f4535875a19028db4ec08de90903daba7b906b659571c5a921850071bf3154c
+  metadata.gz: bd5a110529cb49076b699028d4aba501f92d1b9af517363ecf9d0066ca67bfcd
+  data.tar.gz: 6e499c8e56be6748699f1e9210eaa14c982eac3ea6c425460e75e45ee941a1dc
 SHA512:
-  metadata.gz: 0b53144f0a627a545c0a989d664f3611078a7afc11e9f00b479065a0d3a1b2bc9bf68e10706bd89b85c0e73ff53d7c4627a2c5e29d38867ec2882c99ea56eda0
-  data.tar.gz: 6999ae152b2f5904a2061944522b11387280df6e02cbf4d36d7d5ae27ba12eb3b6c36357bba791c5a7b4f06575531ce76df904dcbb76b0e5f79bd62b05988704
+  metadata.gz: 027ee941cfd582de1c98f7d7aae4a7673bcaf51b7af4cba9df0bef0f3fb16437ad90e760bd61adcea0a4487094d3f7ade675635aff69e40881b36240ec17253c
+  data.tar.gz: b0b3763969201e7f98883463292f59c9583b103251a14879853ae923a5a22259e2d677c175fefbfd25f45ecfe589eb157fec5d7b891364b30cb9714f8ec65e36

data/lib/allfather.rb

@@ -63,17 +63,18 @@ module AllFather
   #
   # * +translator+  - Instance of translation engine. Refer to `engines/aws` for example
   #
+  # ==== Raises
+  # * `InvalidInputException` when the argument `translator` is not an instance of Translator class
+  #
   def set_translator(translator)
     if translator && !(translator.is_a? Translator)
-      raise "Argument is not an instance of Translator"
+      raise InvalidInputException.new("Argument is not an instance of Translator")
     end
   end
 
   #
   # Method to translate the caption from one language to another
   #
-  # :args: src_lang, target_lang, output_file
-  #
   # * +src_lang+        - can be inferred using #infer_language method
   # * +target_lang+     - Target 2 letter ISO language code to which the source needs to be translated in to.
   # * +output_file+     - Output file. Can be a fully qualified path or just file name
@@ -114,6 +115,9 @@ module AllFather
   # If no target_lang is provided, no translations are applied. output_file is created using
   # without any need for any language translation services. Hence doesn't incur any cost !!
   #
+  # Note: +src_lang+ makes sense only for caption types that can hold multi lingual captions
+  # like dfxp and ttml. For other caption sources this field is ignored
+  #
   # * +types+           - An array of Valid input caption type(s). Refer to `#CaptionType`
   # * +src_lang+        - can be inferred using #infer_language method
   # * +target_lang+     - Target 2 letter ISO language code to which the source needs to be translated in to.
@@ -140,18 +144,31 @@ module AllFather
         raise InvalidInputException.new("SCC can be generated only in en. #{target_lang} is unsupported")
       end
     end
-    if target_lang && !target_lang.empty?
-      raise InvalidInputException.new("Translation to other language as part of transform is yet to be implemented")
-    end
   end
 
   # 
   # Method to report on the supported transformations. Each implementor is free to return
   # the types to which it can convert itself to
   #
-  # Returns an array of one or more types defined as +TYPE_+ constants here 
+  # ==== Returns 
+  # 
+  # * An array of one or more types defined as +TYPE_+ constants here 
   #
   def supported_transformations
     raise "Not Implemented. Class #{self.class.name} doesn't implement supported_transformations"
   end
+
+  #
+  # While the logic of abstracting stuff to callers has it's benefits, sometimes it's required
+  # to identify which instance are we specifically operate on. This method returns the instance
+  # currently being operated on and returns one of the +TYPE_+ constants defined here
+  # Implement this unless and absolutely it's necessary and there is no other easy way to do things 
+  #
+  # ===== Returns
+  #
+  # * the call sign of the instance
+  #
+  def callsign
+    raise "Not Implemented. Class #{self.class.name} doesn't implement callsign"
+  end
 end

data/lib/dfxp.rb

@@ -5,16 +5,17 @@ require_relative "ttml"
 #
 # Library to handle DFXP Files
 #
-# Uses the translator available to do the necessary language operations
-# as defined by the AllFather
+# Extends the TTML Class as except for namespace differences there isn't
+# much to call between ttml and dfxp
 #
 class DFXP < TTML
 
-	def initialize(cc_file)
+  SUPPORTED_TRANSFORMATIONS = [TYPE_SCC, TYPE_SRT, TYPE_VTT, TYPE_TTML]
+
+	def initialize(cc_file, opts=nil)
     @cc_file = cc_file
-    #@translator = translator
-    #@force_detect = opts[:force_detect] || false
-    raise "Invalid TTML file provided" unless is_valid?
+    @force_detect = opts ? (opts[:force_detect] || false) : false
+    raise "Invalid DFXP file provided" unless is_valid?
   end
 
   def is_valid?
@@ -26,5 +27,12 @@ class DFXP < TTML
     # a well-formed XML. Another is to see if lang is available in each div
     return false
   end
-  
+
+  def callsign
+    TYPE_DFXP
+  end
+
+  def supported_transformations
+    return SUPPORTED_TRANSFORMATIONS
+  end  
 end

data/lib/engines/aws.rb

@@ -11,8 +11,8 @@ require_relative 'translator'
 #
 # * [Arguments]             - Pass the credentials access_key_id and secret_access_key as arguments
 # * [Environment route]     - AWS_ACCESS_KEY_ID & AWS_SECRET_ACCESS_KEY can be exposed as environment variables
-# * [Profile Name]          - The application uses the credentials of the system and picks the
-#  credentials referred to by the profile
+# * [Profile Name]          - The application uses the credentials of the system and picks the credentials 
+#                             referred to by the profile
 #
 class AwsEngine
   include Translator

data/lib/srt.rb

@@ -94,11 +94,21 @@ class SRT
 
     # Suffix output dir with File seperator
     output_dir = "#{output_dir}#{File::Separator}" unless output_dir.end_with?(File::Separator)
+
+    translate = false
+    if target_lang && !target_lang.empty?
+      translate = true
+      if @translator.nil?
+        raise StandardError.new("Cannot infer language as engine options are not provided")
+      end
+    end
     
     # Prepare the output files for each type
     file_map = {}
     types.each do |type|
-      output_file = File.basename(@cc_file, File.extname(@cc_file)) + extension_from_type(type)
+      output_file = File.basename(@cc_file, File.extname(@cc_file))
+      output_file << "_#{target_lang}" if translate
+      output_file << extension_from_type(type)
       out_file = "#{output_dir}#{output_file}"
       if create_file(TYPE_SRT, type, out_file, target_lang)
         file_map[type] = out_file
@@ -119,7 +129,7 @@ class SRT
         # This is not a time point
         seq = line.strip
         if seq.to_i > 0
-          cue_info.message = message unless message.empty?
+          cue_info.message = translated_msg(translate, message, src_lang, target_lang) unless message.empty?
           write_cue(cue_info, file_map) if cue_info
           cue_info = CueInfo.new(TYPE_SRT)
           cue_info.sequence = seq
@@ -140,12 +150,42 @@ class SRT
         cue_info.end_time_units = end_units
       end
     end
-    cue_info.message = message unless message.empty?
+    cue_info.message = translated_msg(translate, message, src_lang, target_lang) unless message.empty?
     write_cue(cue_info, file_map, true)
   end
 
   private 
 
+  #
+  # Method to translate a given text message based on following conditions
+  #
+  # * If translate is false, the message is returned as is
+  # * If +src_lang+ and +target_lang+ are same then the message is returned as is
+  # * If +src_lang+ is nil or empty then this caption file will be inspected to infer language
+  #   and if it's same as target_lang, then again the message shall be returned as is
+  # * Otherwise, returns a translated text
+  #
+  # ==== Raise
+  # * LangDetectionFailureException - If failed to infer the language
+  #
+  def translated_msg(translate, message, src_lang, target_lang)
+    return message unless translate 
+    use_src = nil 
+    if (src_lang.nil? || src_lang.empty?)
+      # We don't need to infer again and again
+      begin
+        @inferred_src_lang ||= infer_languages.first
+      rescue StandardError => e 
+        raise LangDetectionFailureException.new("Failed to infer language due to #{e.message}")
+      end
+      use_src = @inferred_src_lang
+    else
+      use_src = src_lang
+    end
+    return message if use_src.eql?(target_lang)
+    @translator.translate(message, use_src, target_lang)
+  end
+
   # 
   # Method to get a minimal amount of key text that excludes any tags
   # or control information for the engine to meaninfully and 

data/lib/subtitle.rb

@@ -58,7 +58,7 @@ class Subtitle
     end
     # Translator not required if target_lang is nil
     if @handler.nil?
-      if target_lang.nil?
+      if target_lang.nil? && src_lang.nil?
         @handler = get_caption_handler(options, nil) 
       else
         initialize_handler(options)
@@ -146,9 +146,9 @@ class Subtitle
     when ".vtt"
       handler = VTT.new(caption_file)
     when ".ttml"
-      handler = TTML.new(caption_file)
+      handler = TTML.new(caption_file, options)
     when ".dfxp"
-      handler = DFXP.new(caption_file)
+      handler = DFXP.new(caption_file, options)
     else
       raise "Cannot handle file type .#{extension}"
     end

data/lib/ttml.rb

@@ -1,4 +1,6 @@
 require_relative "engines/translator"
+require_relative "utils/common_utils"
+require_relative "utils/cue_info"
 require_relative "allfather"
 
 require "nokogiri"
@@ -12,12 +14,20 @@ require "nokogiri"
 class TTML
 
   include AllFather
+  include CommonUtils
 
-  def initialize(cc_file)
+  SUPPORTED_TRANSFORMATIONS = [TYPE_SCC, TYPE_SRT, TYPE_VTT, TYPE_DFXP]
+
+  def initialize(cc_file, opts=nil)
     @cc_file = cc_file
+    @force_detect = opts ? (opts[:force_detect] || false) : false
     raise "Invalid TTML file provided" unless is_valid?
   end
 
+  def callsign
+    TYPE_TTML
+  end
+
   def is_valid?
     # Do any VTT specific validations here
     if @cc_file =~ /^.*\.(ttml)$/
@@ -33,12 +43,12 @@ class TTML
   end
 
   def infer_languages
-    force_detect =  false
     lang = []
     begin
       xml_file = File.open(@cc_file)
       xml_doc  = Nokogiri::XML(xml_file)
       div_objects = xml_doc.css("/tt/body/div")
+      local_force_detect = false
       div_objects.each_with_index do |div, index|
         # By default, return the lang if specified in the div and 
         # force detect is false
@@ -46,9 +56,10 @@ class TTML
         if inferred_lang.nil?
           # If lang is not provided in the caption, then override
           # force detect for inferrence
-          force_detect = true
+          local_force_detect = true
         end
-        if force_detect
+        if @force_detect || local_force_detect
+          local_force_detect = false
           sample_text = get_text(div, 100)
           inferred_lang = @translator.infer_language(sample_text) rescue nil
           if inferred_lang.nil?
@@ -115,8 +126,165 @@ class TTML
     out_file
   end
 
+  def supported_transformations
+    return SUPPORTED_TRANSFORMATIONS
+  end
+
+  def transform_to(types, src_lang, target_lang, output_dir)
+    # Let's start off with some validations
+    super(types, src_lang, target_lang, output_dir)
+
+    # Suffix output dir with File seperator
+    output_dir = "#{output_dir}#{File::Separator}" unless output_dir.end_with?(File::Separator)
+    
+    begin
+      xml_file = File.open(@cc_file, 'r')
+      xml_doc = Nokogiri::XML(xml_file)
+      div_objects = xml_doc.css("/tt/body/div")
+      langs = div_objects.map {|div| div.attributes['lang'].value rescue nil}
+      translate = false
+      matching_divs = []
+      inferred_src_lang = nil
+      if src_lang.nil? || src_lang.empty?
+        if target_lang && !target_lang.empty?
+          # Find if any of our div matches this. Else pick first and translate to target lang
+          div_objects.each_with_index do |div, j|
+            if matching_lang?(div, target_lang)
+              matching_divs << div 
+              break
+            end
+          end
+          if matching_divs.empty?
+            # Let's pick the first div for target translation
+            selected_div = div_objects.first
+            inferred_src_lang = selected_div.lang
+            matching_divs << selected_div
+            translate = true
+          end
+        else
+          # Then we will have to create output files for each lang
+          matching_divs = div_objects
+        end
+      else
+        # Find the matching lang div and create the outputs
+        available_divs = langs.select { |lang| lang.eql?(src_lang) }
+        if available_divs.length > 1
+          raise InvalidInputException.new("More than one section in Caption file specifies lang as #{src_lang}. This file is unsupported")
+        end
+        div_objects.each_with_index do |div, j|
+          if matching_lang?(div, src_lang)
+            matching_divs << div 
+            break
+          end
+        end
+        if matching_divs.empty?
+          raise InvalidInputException.new("Given Caption file #{@cc_file} doesn't contain #{src_lang} lang. Available langs are #{langs}")
+        end
+        if matching_divs.length > 1
+          raise InvalidInputException.new("More than one section in Caption file specifies lang as #{src_lang}. This file is unsupported")
+        end
+        if target_lang && !target_lang.empty? && !src_lang.eql?(target_lang)
+          translate = true
+        end
+      end
+
+      div_index = 1
+      multiple_outputs = matching_divs.size > 1
+      matching_divs.each do |div|
+        div_lang = div.attributes['lang'].value rescue nil
+        # Override div lang if translate is required
+        div_lang = target_lang if translate
+        file_map = {}
+        # Prepare the output files for each type and for each lang in the file
+        types.each do |type|
+          output_file = File.basename(@cc_file, File.extname(@cc_file))
+          # Suffix div index when multiple outputs are created
+          output_file << "_#{div_index}" if multiple_outputs
+          if target_lang.nil? && !src_lang.nil?
+            output_file << "_#{src_lang}"
+          end
+          # Suffix lang to filename if provideds 
+          if target_lang && !target_lang.empty?
+            output_file << "_#{target_lang}"
+          end
+          output_file << extension_from_type(type)
+          out_file = "#{output_dir}#{output_file}"
+          if create_file(TYPE_TTML, type, out_file, div_lang)
+            file_map[type] = out_file
+          else
+            raise StandardError.new("Failed to create output file for type #{type}")
+          end
+        end
+        blocks = div.css("p")
+        cue_index = 1
+        total_blocks = blocks.size
+        blocks.each_with_index do |block, index|
+          start_time = block.attributes['begin'].value
+          end_time = block.attributes['end'].value
+          text = block.inner_html.strip.gsub(/(\s){2,}/, '')
+          message = ""
+          text_blocks = get_block_text(text)
+          text_blocks.each do |text_block|
+            next if text_block.start_with?('<') || text_block.empty?
+            message << text_block
+          end
+          cue_info = CueInfo.new(callsign)
+          cue_info.index = cue_index
+          cue_index += 1
+          cue_info.message = translated_msg(translate, message, src_lang, inferred_src_lang, target_lang)
+          cue_info.start = start_time
+          cue_info.end = end_time
+          cue_info.start_time_units = time_details(start_time, callsign)
+          cue_info.end_time_units = time_details(end_time, callsign)
+          write_cue(cue_info, file_map, index == (total_blocks - 1))
+        end
+        div_index += 1
+      end
+    ensure
+      xml_file.close if xml_file
+    end
+  end
+
   private
 
+  def translated_msg(translate, message, src_lang, inferred_src_lang, target_lang)
+    return message unless translate 
+    use_src = nil 
+    if (src_lang.nil? || src_lang.empty?)
+      if inferred_src_lang.nil?
+        raise LangDetectionFailureException.new("Unable to deduce source lang for translation")
+      end
+      use_src = inferred_src_lang
+    else
+      use_src = src_lang
+    end
+    return message if use_src.eql?(target_lang)
+    @translator.translate(message, use_src, target_lang)
+  end
+
+  def matching_lang?(div, target_lang)
+    lang = div.attributes['lang'].value rescue nil
+    if lang.nil?
+      # Let's infer the lang
+      if @translator.nil?
+        raise StandardError.new("Cannot infer language as engine options are not provided")
+      end
+      reference_text = get_text(div, 100)
+      inferred_lang = @translator.infer_language(reference_text) rescue nil
+      if inferred_lang.nil?
+        raise LangDetectionFailureException.new("Failed to infer language for div block #{j} of caption file")
+      end
+      # Store this lang in the div
+      div.lang = inferred_lang
+      if inferred_lang.eql?(target_lang)
+        return true
+      end
+    elsif lang.eql?(target_lang)
+      return true
+    end
+    return false
+  end
+
   #
   # Method to segregate the data from markups as markups don't need
   # translations.

data/lib/vtt.rb

@@ -104,10 +104,19 @@ class VTT
     # Suffix output dir with File seperator
     output_dir = "#{output_dir}#{File::Separator}" unless output_dir.end_with?(File::Separator)
     
+    translate = false
+    if target_lang && !target_lang.empty?
+      translate = true
+      if @translator.nil?
+        raise StandardError.new("Cannot infer language as engine options are not provided")
+      end
+    end
     # Prepare the output files for each type
     file_map = {}
     types.each do |type|
-      output_file = File.basename(@cc_file, File.extname(@cc_file)) + extension_from_type(type)
+      output_file = File.basename(@cc_file, File.extname(@cc_file))
+      output_file << "_#{target_lang}" if translate
+      output_file << extension_from_type(type)
       out_file = "#{output_dir}#{output_file}"
       if create_file(TYPE_VTT, type, out_file, target_lang)
         file_map[type] = out_file
@@ -135,7 +144,7 @@ class VTT
       else
         collect_msg = false
         unless message.empty?
-          cue_info.message = message 
+          cue_info.message = translated_msg(translate, message, src_lang, target_lang)
           write_cue(cue_info, file_map)
           message = ""
           cue_index += 1
@@ -152,11 +161,41 @@ class VTT
         collect_msg = true
       end
     end
-    cue_info.message = message unless message.empty?
+    cue_info.message = translated_msg(translate, message, src_lang, target_lang) unless message.empty?
     write_cue(cue_info, file_map, true)
   end
 
-  private 
+  private
+
+  #
+  # Method to translate a given text message based on following conditions
+  #
+  # * If translate is false, the message is returned as is
+  # * If +src_lang+ and +target_lang+ are same then the message is returned as is
+  # * If +src_lang+ is nil or empty then this caption file will be inspected to infer language
+  #   and if it's same as target_lang, then again the message shall be returned as is
+  # * Otherwise, returns a translated text
+  #
+  # ==== Raise
+  # * LangDetectionFailureException - If failed to infer the language
+  #
+  def translated_msg(translate, message, src_lang, target_lang)
+    return message unless translate 
+    use_src = nil 
+    if (src_lang.nil? || src_lang.empty?)
+      # We don't need to infer again and again
+      begin
+        @inferred_src_lang ||= infer_languages.first
+      rescue StandardError => e 
+        raise LangDetectionFailureException.new("Failed to infer language due to #{e.message}")
+      end
+      use_src = @inferred_src_lang
+    else
+      use_src = src_lang
+    end
+    return message if use_src.eql?(target_lang)
+    @translator.translate(message, use_src, target_lang)
+  end 
 
   # 
   # Method to get a minimal amount of key text that excludes any tags

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: subtitle
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Maheshwaran G
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-13 00:00:00.000000000 Z
+date: 2019-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,8 +95,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Subtitle gem helps you to detect language and translate closed caption
-  to required language.
+description: "                       Subtitle gem helps you to detect the language(s)
+  of the caption file, translate closed caption \n                       to another
+  language and also supports transforming from one format to another. \n                       Say
+  for example from dfxp to srt or vtt or to all supported formats.\"\n"
 email:
 - pgmaheshwaran@gmail.com
 - arunjeyaprasad@gmail.com