azure_stt 0.1.0

data/lib/azure_stt/models/word.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module AzureSTT
+  module Models
+    #
+    # Model for a word. A word is optional in a sentence
+    #
+    class Word < Base
+      #
+      # The word
+      #
+      # @!attribute [r] word
+      #   @return [Types::Coercible::String]
+      attribute :word, Types::Coercible::String
+
+      #
+      # The offset of the word in the audio. Ex: 'PT0.13S' means that the
+      # phrase begins at 13 seconds on the audio file
+      #
+      # @!attribute [r] offset
+      #   @return [Types::Coercible::String]
+      attribute? :offset, Types::Coercible::String
+
+      #
+      # The duration of the word. Ex: 'PT0.13S' means that the phrase lasts 13
+      # seconds
+      #
+      # @!attribute [r] duration
+      #   @return [Types::Coercible::String]
+      attribute? :duration, Types::Coercible::String
+
+      #
+      # The offset of the word in the audio in ticks.
+      #
+      # @!attribute [r] offset_in_ticks
+      #   @return [Types::Coercible::Integer]
+      attribute? :offset_in_ticks, Types::Coercible::Integer
+
+      #
+      # The duration of the word in ticks
+      #
+      # @!attribute [r] duration_in_ticks
+      #   @return [Types::Coercible::Integer]
+      attribute? :duration_in_ticks, Types::Coercible::Integer
+
+      #
+      # The confidence score of the transcripted word.
+      #
+      # @!attribute [r] confidence
+      #   @return [Types::Coercible::Float]
+      attribute :confidence, Types::Coercible::Float
+    end
+  end
+end

data/lib/azure_stt/parsers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AzureSTT
+  #
+  # Module for the parsers
+  #
+  module Parsers
+  end
+end
+
+require_relative 'parsers/base'
+require_relative 'parsers/transcription'
+require_relative 'parsers/file'
+require_relative 'parsers/report'
+require_relative 'parsers/result'
+require_relative 'parsers/combined_recognized_phrases'
+require_relative 'parsers/recognized_phrase'
+require_relative 'parsers/sentence'
+require_relative 'parsers/word'

data/lib/azure_stt/parsers/base.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module AzureSTT
+  module Parsers
+    #
+    # Base class for the parsers
+    #
+    class Base
+      attr_reader :hash
+
+      #
+      # Initialize the parser
+      #
+      # @param [Hash] hash The hash containing the information from the API
+      #
+      def initialize(hash)
+        @hash = hash
+      end
+
+      #
+      # Get the attributes parsed to be able to build the model
+      #
+      # @return [Hash]
+      #
+      def attributes
+        @attributes ||= build_attributes
+      end
+
+      protected
+
+      #
+      # This method must be overriden in the children
+      #
+      # @return [Hash] The attributes parsed to be able to build the model
+      #
+      def build_attributes
+        raise NoMethodError, 'Implement method #build_attributes in your' \
+                             'custom parser'
+      end
+    end
+  end
+end

data/lib/azure_stt/parsers/combined_recognized_phrases.rb

@@ -0,0 +1,28 @@
+# frozen_String_literal: true
+
+module AzureSTT
+  module Parsers
+    #
+    # Parse the CombinedRecognizedPhrases from the result file to a
+    # Models::CombinedRecognizedPhrases
+    #
+    class CombinedRecognizedPhrases < Base
+      protected
+
+      #
+      # Build a hash to instantiate a Models::CombinedRecognizedPhrase
+      #
+      # @return [Hash]
+      #
+      def build_attributes
+        {
+          channel: hash['channel'],
+          lexical: hash['lexical'],
+          itn: hash['itn'],
+          masked_itn: hash['maskedITN'],
+          transcript: hash['display']
+        }.compact
+      end
+    end
+  end
+end

data/lib/azure_stt/parsers/file.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module AzureSTT
+  module Parsers
+    #
+    # Parse a file from the call to the API to a Models::File
+    #
+    class File < Base
+      protected
+
+      #
+      # Build a hash which can create a Models::File
+      #
+      # @return [Hash] file's initializer parameters
+      #
+      def build_attributes
+        {
+          id: hash['self'].split('/').last,
+          name: hash['name'],
+          kind: hash['kind'],
+          properties: hash['properties'],
+          created_date_time: Date.parse(hash['createdDateTime']),
+          content_url: hash.dig('links', 'contentUrl')
+        }
+      end
+    end
+  end
+end

data/lib/azure_stt/parsers/recognized_phrase.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module AzureSTT
+  module Parsers
+    #
+    # Parse a recognized phrase from a result file to Models::RecognizedPhrase
+    #
+    class RecognizedPhrase < Base
+      protected
+
+      #
+      # Build a hash to instantiate a Models::RecognizedPhrase
+      #
+      # @return [Hash]
+      #
+      def build_attributes
+        {
+          recognition_status: hash['recognitionStatus'],
+          channel: hash['channel'],
+          speaker: hash['speaker'],
+          offset: hash['offset'],
+          duration: hash['duration'],
+          offset_in_ticks: hash['offsetInTicks'],
+          duration_in_ticks: hash['durationInTicks'],
+          n_best: build_n_best
+        }.compact
+      end
+
+      private
+
+      #
+      # Build the n_best fiels if the RecognizedPhrase.
+      #
+      # @return [Array[Models::Sentence]]
+      #
+      def build_n_best
+        hash['nBest'].map do |sentence_hash|
+          Models::Sentence.new(
+            Sentence.new(sentence_hash).attributes
+          )
+        end
+      end
+    end
+  end
+end

data/lib/azure_stt/parsers/report.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module AzureSTT
+  module Parsers
+    #
+    # Parse a report from a contentUrl to a Models::Report
+    #
+    class Report < Base
+      protected
+
+      #
+      # Build a hash which can create a Models::Report
+      #
+      # @return [Hash] report's initializer parameters
+      #
+      def build_attributes
+        {
+          successful_transcriptions_count: hash['successfulTranscriptionsCount'],
+          failed_transcriptions_count: hash['failedTranscriptionsCount'],
+          details: hash['details']
+        }
+      end
+    end
+  end
+end

data/lib/azure_stt/parsers/result.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module AzureSTT
+  module Parsers
+    #
+    # Parse a result file from the API to a Models::Result
+    #
+    class Result < Base
+      protected
+
+      #
+      # Build a hash which can create a Models::Result
+      #
+      # @return [Hash] report's initializer parameters
+      #
+      def build_attributes
+        {
+          source: hash['source'],
+          timestamp: Date.parse(hash['timestamp']),
+          duration_in_ticks: hash['durationInTicks'],
+          duration: hash['dureation'],
+          combined_recognized_phrases: build_combined_recognized_phrases,
+          recognized_phrases: build_recognized_phrases
+        }
+      end
+
+      private
+
+      #
+      # Build the array of Models::CombinedRecognizedPhrases
+      #
+      # @return [Array[Models::CombinedRecognizedPhrases]]
+      #
+      def build_combined_recognized_phrases
+        hash['combinedRecognizedPhrases'].map do |combined_phrases_hash|
+          Models::CombinedRecognizedPhrases.new(
+            CombinedRecognizedPhrases.new(combined_phrases_hash).attributes
+          )
+        end
+      end
+
+      #
+      # Build the array of Models::RecognizedPhrase in a Models::Result
+      #
+      # @return [Array[RecognizedPhrase]]
+      #
+      def build_recognized_phrases
+        hash['recognizedPhrases'].map do |recognized_phrase_hash|
+          Models::RecognizedPhrase.new(
+            RecognizedPhrase.new(recognized_phrase_hash).attributes
+          )
+        end
+      end
+    end
+  end
+end

data/lib/azure_stt/parsers/sentence.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# frozen_string_literal
+
+module AzureSTT
+  module Parsers
+    #
+    # Parse the "nBest" field from the result file to a Models::Sentence
+    #
+    class Sentence < Base
+      protected
+
+      #
+      # Build the attributes needed to instantiate a Models::Sentence
+      #
+      # @return [Hash]
+      #
+      def build_attributes
+        {
+          confidence: hash['confidence'],
+          lexical: hash['lexical'],
+          itn: hash['itn'],
+          masked_itn: hash['maskedITN'],
+          transcript: hash['display'],
+          words: build_words
+        }.compact
+      end
+
+      private
+
+      #
+      # Build the words. Returns nil if they are not defined
+      #
+      # @return [Array[Word]]
+      #
+      def build_words
+        hash['words']&.map do |word_hash|
+          Models::Word.new(
+            Word.new(word_hash).attributes
+          )
+        end
+      end
+    end
+  end
+end

data/lib/azure_stt/parsers/transcription.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AzureSTT
+  module Parsers
+    #
+    # Parse a transcription from the call to the API to a Models::Transcription
+    #
+    class Transcription < Base
+      protected
+
+      # rubocop:disable Metrics/AbcSize
+
+      #
+      # Build a hash which can create a Models::Transcription
+      #
+      # @return [Hash] transcription's initializer parameters
+      #
+      def build_attributes
+        {
+          id: hash['self'].split('/').last,
+          model: hash.dig('model', 'self'),
+          links: hash['links'],
+          properties: hash['properties'],
+          last_action_date_time: Date.parse(hash['lastActionDateTime']),
+          created_date_time: Date.parse(hash['createdDateTime']),
+          status: hash['status'],
+          locale: hash['locale'],
+          display_name: hash['displayName']
+        }
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/azure_stt/parsers/word.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module AzureSTT
+  module Parsers
+    #
+    # Parse the words in the result file to Models::Word
+    #
+    class Word < Base
+      protected
+
+      #
+      # Build the attributes needed to instantiate a Models::Word
+      #
+      # @return [Hash]
+      #
+      def build_attributes
+        {
+          word: hash['word'],
+          offset: hash['offset'],
+          duration: hash['duration'],
+          offset_in_ticks: hash['offsetInTicks'],
+          duration_in_ticks: hash['durationInTicks'],
+          confidence: hash['confidence']
+        }.compact
+      end
+    end
+  end
+end

data/lib/azure_stt/session.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module AzureSTT
+  #
+  # A session is the class the end user uses to retrieve the Transcription.
+  # It contains a client.
+  #
+  class Session
+    attr_reader :client
+
+    #
+    # Create a session. If you don't provide any subscription_key or region, the
+    # value is read from configuration.
+    #
+    # @param [String] region The region, optional, default is read from
+    # configuration
+    # @param [String] subscription_key The subscription, optional, default is
+    # read from configuration
+    #
+    def initialize(region: AzureSTT.configuration.region,
+                   subscription_key: AzureSTT.configuration.subscription_key)
+      @client = Client.new(region: region, subscription_key: subscription_key)
+    end
+
+    #
+    # Create a transcription by calling the API.
+    #
+    # @see https://centralus.dev.cognitive.microsoft.com/docs/services/speech-to-text-api-v3-0/operations/CreateTranscription
+    #
+    # @param [Array[String]] content_urls The urls of your files
+    # @param [Hash] properties The properties you want to use for the
+    # transcription
+    # @param [String] locale The locale of the contained data
+    # @param [String] display_name The name of the transcription (can be
+    # left empty)
+    #
+    # @return [Models::Transcription] The transcription
+    #
+    def create_transcription(content_urls:, properties:, locale:, display_name:)
+      transcription_hash = client.create_transcription(
+        {
+          contentUrls: content_urls,
+          properties: properties,
+          locale: locale,
+          displayName: display_name
+        }
+      )
+      build_transcription_from_hash(transcription_hash)
+    end
+
+    #
+    # Get a transcription identified by an id.
+    #
+    # @see https://centralus.dev.cognitive.microsoft.com/docs/services/speech-to-text-api-v3-0/operations/GetTranscription
+    #
+    # @param [String] id The identifier of the transcription
+    #
+    # @return [Models::Transcription] the transcription
+    #
+    def get_transcription(id)
+      transcription_hash = client.get_transcription(id)
+      build_transcription_from_hash(transcription_hash)
+    end
+
+    #
+    # Get multiple transcriptions.
+    #
+    # @see https://centralus.dev.cognitive.microsoft.com/docs/services/speech-to-text-api-v3-0/operations/GetTranscriptions
+    #
+    # @param [Integer] skip Number of transcriptions that will be skipped (optional)
+    # @param [Integer] top Number of transcriptions that will be included after skipping
+    # (optional)
+    #
+    # @return [Array[Models::Transcription]]
+    #
+    def get_transcriptions(skip: nil, top: nil)
+      transcriptions_array = client.get_transcriptions(skip: skip, top: top)
+      transcriptions_array.map do |transcription_hash|
+        build_transcription_from_hash(transcription_hash)
+      end
+    end
+
+    private
+
+    #
+    # Build a transcription from a hash returned by the client. This hash
+    # contains the information from the JSON. It is then parsed and the
+    # transcription is intantiated.
+    #
+    # @param [Hash] hash The hash that the client returned
+    #
+    # @return [Models::Transcription] the created transcription
+    #
+    def build_transcription_from_hash(hash)
+      Models::Transcription.new(
+        Parsers::Transcription.new(hash).attributes.merge({ client: client })
+      )
+    end
+  end
+end