deepl-rb 3.2.0 → 3.4.0

data/lib/deepl/requests/glossary/create.rb

@@ -1,59 +0,0 @@
-# Copyright 2022 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Requests
-    module Glossary
-      class Create < Base
-        attr_reader :name, :source_lang, :target_lang, :entries, :entries_format
-
-        def initialize(api, name, source_lang, target_lang, entries, options = {})
-          super(api, options)
-          @name = name
-          @source_lang = source_lang
-          @target_lang = target_lang
-          @entries = entries
-          @entries_format = delete_option(:entries_format) || 'tsv'
-        end
-
-        def request
-          payload = {
-            name: name, source_lang: source_lang, target_lang: target_lang, entries: entries_to_tsv,
-            entries_format: entries_format
-          }
-          build_glossary(*execute_request_with_retries(post_request(payload)))
-        end
-
-        def details
-          "HTTP Headers: #{headers}\nPayload #{{
-            name: name, source_lang: source_lang, target_lang: target_lang, entries: entries_to_tsv,
-            entries_format: entries_format
-          }}"
-        end
-
-        def to_s
-          "POST #{uri.request_uri}"
-        end
-
-        private
-
-        def entries_to_tsv
-          return entries if entries.is_a?(String)
-
-          entries.reduce('') { |tsv, entry| "#{tsv}#{entry.first}\t#{entry.last}\n" }
-        end
-
-        def build_glossary(request, response)
-          glossary = JSON.parse(response.body)
-          Resources::Glossary.new(glossary, request, response)
-        end
-
-        def path
-          'glossaries'
-        end
-      end
-    end
-  end
-end

data/lib/deepl/requests/glossary/destroy.rb

@@ -1,37 +0,0 @@
-# Copyright 2022 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Requests
-    module Glossary
-      class Destroy < Base
-        attr_reader :id
-
-        def initialize(api, id, options = {})
-          super(api, options)
-          @id = id
-        end
-
-        def request
-          build_response(*execute_request_with_retries(delete_request))
-        end
-
-        def to_s
-          "DELETE #{uri.request_uri}"
-        end
-
-        private
-
-        def build_response(_, _)
-          id
-        end
-
-        def path
-          "glossaries/#{id}"
-        end
-      end
-    end
-  end
-end

data/lib/deepl/requests/glossary/entries.rb

@@ -1,37 +0,0 @@
-# Copyright 2022 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Requests
-    module Glossary
-      class Entries < Base
-        attr_reader :id
-
-        def initialize(api, id, options = {})
-          super(api, options)
-          @id = id
-        end
-
-        def request
-          build_entries(*execute_request_with_retries(get_request))
-        end
-
-        def to_s
-          "GET #{uri.request_uri}"
-        end
-
-        private
-
-        def build_entries(_, response)
-          response.body.split("\n").map { |entry| entry.split("\t") }
-        end
-
-        def path
-          "glossaries/#{id}/entries"
-        end
-      end
-    end
-  end
-end

data/lib/deepl/requests/glossary/find.rb

@@ -1,38 +0,0 @@
-# Copyright 2022 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Requests
-    module Glossary
-      class Find < Base
-        attr_reader :id
-
-        def initialize(api, id, options = {})
-          super(api, options)
-          @id = id
-        end
-
-        def request
-          build_glossary(*execute_request_with_retries(get_request))
-        end
-
-        def to_s
-          "GET #{uri.request_uri}"
-        end
-
-        private
-
-        def build_glossary(request, response)
-          glossary = JSON.parse(response.body)
-          Resources::Glossary.new(glossary, request, response)
-        end
-
-        def path
-          "glossaries/#{id}"
-        end
-      end
-    end
-  end
-end

data/lib/deepl/requests/glossary/language_pairs.rb

@@ -1,38 +0,0 @@
-# Copyright 2022 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Requests
-    module Glossary
-      class LanguagePairs < Base
-        def initialize(api, options = {})
-          super
-        end
-
-        def request
-          build_language_pair_list(*execute_request_with_retries(get_request))
-        end
-
-        def to_s
-          "GET #{uri.request_uri}"
-        end
-
-        private
-
-        def build_language_pair_list(request, response)
-          data = JSON.parse(response.body)
-          data['supported_languages'].map do |language_pair|
-            Resources::LanguagePair.new(language_pair['source_lang'], language_pair['target_lang'],
-                                        request, response)
-          end
-        end
-
-        def path
-          'glossary-language-pairs'
-        end
-      end
-    end
-  end
-end

data/lib/deepl/requests/glossary/list.rb

@@ -1,37 +0,0 @@
-# Copyright 2022 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Requests
-    module Glossary
-      class List < Base
-        def initialize(api, options = {})
-          super
-        end
-
-        def request
-          build_glossary_list(*execute_request_with_retries(get_request))
-        end
-
-        def to_s
-          "GET #{uri.request_uri}"
-        end
-
-        private
-
-        def build_glossary_list(request, response)
-          data = JSON.parse(response.body)
-          data['glossaries'].map do |glossary|
-            Resources::Glossary.new(glossary, request, response)
-          end
-        end
-
-        def path
-          'glossaries'
-        end
-      end
-    end
-  end
-end

data/lib/deepl/requests/languages.rb

@@ -1,37 +0,0 @@
-# Copyright 2021 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Requests
-    class Languages < Base
-      def initialize(api, options = {})
-        super
-      end
-
-      def request
-        build_languages(*execute_request_with_retries(get_request))
-      end
-
-      def to_s
-        "GET #{uri.request_uri}"
-      end
-
-      private
-
-      def build_languages(request, response)
-        data = JSON.parse(response.body)
-        data.map do |language|
-          Resources::Language.new(language['language'], language['name'],
-                                  language['supports_formality'],
-                                  request, response)
-        end
-      end
-
-      def path
-        'languages'
-      end
-    end
-  end
-end

data/lib/deepl/requests/rephrase.rb

@@ -1,54 +0,0 @@
-# Copyright 2025 DeepL SE (https://www.deepl.com)
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Requests
-    class Rephrase < Base
-      attr_reader :text, :target_lang, :writing_style, :tone
-
-      def initialize(api, text, target_lang, writing_style = nil, tone = nil, options = {})
-        super(api, options)
-        @text = text
-        @target_lang = target_lang
-        @writing_style = writing_style
-        @tone = tone
-      end
-
-      def request
-        text_arrayified = text.is_a?(Array) ? text : [text]
-        payload = { text: text_arrayified, target_lang: target_lang }
-        payload[:writing_style] = writing_style unless writing_style.nil?
-        payload[:tone] = tone unless tone.nil?
-        build_texts(*execute_request_with_retries(post_request(payload)))
-      end
-
-      def details
-        "HTTP Headers: #{headers}\nPayload #{{ text: text, target_lang: target_lang,
-                                               writing_style: writing_style, tone: tone }}"
-      end
-
-      def to_s
-        "POST #{uri.request_uri}"
-      end
-
-      private
-
-      def build_texts(request, response)
-        data = JSON.parse(response.body)
-
-        texts = data['improvements'].map do |improvement|
-          Resources::Text.new(improvement['text'], improvement['detected_source_language'], nil,
-                              request, response)
-        end
-
-        texts.size == 1 ? texts.first : texts
-      end
-
-      def path
-        'write/rephrase'
-      end
-    end
-  end
-end

data/lib/deepl/requests/translate.rb

@@ -1,82 +0,0 @@
-# Copyright 2018 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Requests
-    class Translate < Base
-      STRING_TO_BOOLEAN_MAP = { '1' => true, '0' => false }.freeze
-      BOOLEAN_TO_STRING_MAP = { true => '1', false => '0' }.freeze
-      STRING_TO_BOOLEAN_CONVERSION = ->(value) { STRING_TO_BOOLEAN_MAP[value] }
-      BOOLEAN_TO_STRING_CONVERSION = ->(value) { BOOLEAN_TO_STRING_MAP[value] }
-      STRING_TO_ARRAY_CONVERSION = lambda { |value|
-        if value.nil?
-          nil
-        else
-          (value.is_a?(Array) ? value : value.split(','))
-        end
-      }.freeze
-      OPTIONS_CONVERSIONS = {
-        split_sentences: BOOLEAN_TO_STRING_CONVERSION,
-        preserve_formatting: STRING_TO_BOOLEAN_CONVERSION,
-        outline_detection: STRING_TO_BOOLEAN_CONVERSION,
-        splitting_tags: STRING_TO_ARRAY_CONVERSION,
-        non_splitting_tags: STRING_TO_ARRAY_CONVERSION,
-        ignore_tags: STRING_TO_ARRAY_CONVERSION
-      }.freeze
-
-      attr_reader :text, :source_lang, :target_lang, :ignore_tags, :splitting_tags,
-                  :non_splitting_tags, :model_type
-
-      def initialize(api, text, source_lang, target_lang, options = {})
-        super(api, options)
-        @text = text
-        @source_lang = source_lang
-        @target_lang = target_lang
-
-        tweak_parameters!
-      end
-
-      def request
-        text_arrayified = text.is_a?(Array) ? text : [text]
-        payload = { text: text_arrayified, source_lang: source_lang, target_lang: target_lang }
-        build_texts(*execute_request_with_retries(post_request(payload)))
-      end
-
-      def details
-        "HTTP Headers: #{headers}\nPayload #{{ text: text, source_lang: source_lang,
-                                               target_lang: target_lang }}"
-      end
-
-      def to_s
-        "POST #{uri.request_uri}"
-      end
-
-      private
-
-      def tweak_parameters!
-        OPTIONS_CONVERSIONS.each do |param, converter|
-          next unless option?(param) && !converter[option(param)].nil?
-
-          set_option(param, converter[option(param)])
-        end
-      end
-
-      def build_texts(request, response)
-        data = JSON.parse(response.body)
-
-        texts = data['translations'].map do |translation|
-          Resources::Text.new(translation['text'], translation['detected_source_language'],
-                              translation['model_type_used'], request, response)
-        end
-
-        texts.size == 1 ? texts.first : texts
-      end
-
-      def path
-        'translate'
-      end
-    end
-  end
-end

data/lib/deepl/requests/usage.rb

@@ -1,33 +0,0 @@
-# Copyright 2018 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Requests
-    class Usage < Base
-      def initialize(api, options = {})
-        super
-      end
-
-      def request
-        build_usage(*execute_request_with_retries(get_request))
-      end
-
-      def to_s
-        "GET #{uri.request_uri}"
-      end
-
-      private
-
-      def build_usage(request, response)
-        data = JSON.parse(response.body)
-        Resources::Usage.new(data['character_count'], data['character_limit'], request, response)
-      end
-
-      def path
-        'usage'
-      end
-    end
-  end
-end

data/lib/deepl/resources/base.rb

@@ -1,17 +0,0 @@
-# Copyright 2018 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Resources
-    class Base
-      attr_reader :request, :response
-
-      def initialize(request, response)
-        @request = request
-        @response = response
-      end
-    end
-  end
-end

data/lib/deepl/resources/document_handle.rb

@@ -1,57 +0,0 @@
-# Copyright 2024 DeepL SE (https://www.deepl.com)
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE file.
-# frozen_string_literal: true
-
-module DeepL
-  module Resources
-    class DocumentHandle < Base
-      attr_reader :document_id, :document_key
-
-      def initialize(document_id, document_key, *args)
-        super(*args)
-
-        @document_id = document_id
-        @document_key = document_key
-      end
-
-      def to_s
-        "DocumentHandle: ID: #{document_id} - Key: #{document_key}"
-      end
-
-      ##
-      # For this DocumentHandle, waits until the document translation is finished and returns the
-      # final status of the document.
-      #
-      # @return [DeepL::Resources::DocumentTranslationStatus] Final status of the document
-      #                                                       translation.
-
-      def wait_until_document_translation_finished
-        doc_status = nil
-        max_tries = max_doc_status_queries
-        num_tries = 0
-        loop do
-          num_tries += 1
-          sleep(calculate_waiting_time(doc_status)) unless doc_status.nil?
-          doc_status = DeepL.document.get_status(self)
-          break if doc_status.finished? || num_tries > max_tries
-        end
-        doc_status
-      end
-
-      private
-
-      def calculate_waiting_time(_resp)
-        # ignore _resp.seconds_remaining for now, while it is unreliable
-        5
-      end
-
-      def max_doc_status_queries
-        configured_value = DeepL.configuration.max_doc_status_queries
-        return configured_value unless configured_value.nil?
-
-        10
-      end
-    end
-  end
-end

data/lib/deepl/resources/document_translation_status.rb

@@ -1,54 +0,0 @@
-# Copyright 2024 DeepL SE (https://www.deepl.com)
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE file.
-# frozen_string_literal: true
-
-module DeepL
-  module Resources
-    class DocumentTranslationStatus < Base
-      attr_reader :document_id, :status, :seconds_remaining, :billed_characters, :error_message
-
-      def initialize(response, *args)
-        super(*args)
-
-        @document_id = response['document_id']
-        @status = response['status']
-        @seconds_remaining = response['seconds_remaining']
-        @billed_characters = response['billed_characters']
-        @error_message = response['error_message']
-      end
-
-      def to_s
-        "DocumentTranslationStatus: ID: #{document_id} - Status: #{status} " \
-          "- Error message: #{error_message}"
-      end
-
-      ##
-      # Checks if the translation finished successfully
-      #
-      # @return [true] if so
-
-      def successful?
-        status == 'done'
-      end
-
-      ##
-      # Checks if there was an error during translation
-      #
-      # @return [true] if so
-
-      def error?
-        status == 'error'
-      end
-
-      ##
-      # Checks if the translation process terminated. Note that this could be due to an error as
-      # well, but means no further waiting is necessary.
-      #
-      # @return [true] if so
-      def finished?
-        successful? || error?
-      end
-    end
-  end
-end

data/lib/deepl/resources/glossary.rb

@@ -1,28 +0,0 @@
-# Copyright 2022 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Resources
-    class Glossary < Base
-      attr_reader :id, :name, :ready, :source_lang, :target_lang, :creation_time, :entry_count
-
-      def initialize(glossary, *args)
-        super(*args)
-
-        @id = glossary['glossary_id']
-        @name = glossary['name']
-        @ready = glossary['ready']
-        @source_lang = glossary['source_lang']
-        @target_lang = glossary['target_lang']
-        @creation_time = glossary['creation_time']
-        @entry_count = glossary['entry_count']
-      end
-
-      def to_s
-        "#{id} - #{name}"
-      end
-    end
-  end
-end

data/lib/deepl/resources/language.rb

@@ -1,30 +0,0 @@
-# Copyright 2021 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Resources
-    class Language < Base
-      attr_reader :code, :name
-
-      def initialize(code, name, supports_formality, *args)
-        super(*args)
-
-        @code = code
-        @name = name
-        @supports_formality = supports_formality
-      end
-
-      def to_s
-        "#{code} - #{name}"
-      end
-
-      def supports_formality?
-        return @supports_formality unless @supports_formality.nil?
-
-        raise Exceptions::NotSupported, 'Support formality is only available on target languages'
-      end
-    end
-  end
-end

data/lib/deepl/resources/language_pair.rb

@@ -1,23 +0,0 @@
-# Copyright 2022 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Resources
-    class LanguagePair < Base
-      attr_reader :source_lang, :target_lang
-
-      def initialize(source_lang, target_lang, *args)
-        super(*args)
-
-        @source_lang = source_lang
-        @target_lang = target_lang
-      end
-
-      def to_s
-        "#{source_lang} - #{target_lang}"
-      end
-    end
-  end
-end

data/lib/deepl/resources/text.rb

@@ -1,24 +0,0 @@
-# Copyright 2018 Daniel Herzog
-# Use of this source code is governed by an MIT
-# license that can be found in the LICENSE.md file.
-# frozen_string_literal: true
-
-module DeepL
-  module Resources
-    class Text < Base
-      attr_reader :text, :detected_source_language, :model_type_used
-
-      def initialize(text, detected_source_language, model_type_used, *args)
-        super(*args)
-
-        @text = text
-        @detected_source_language = detected_source_language
-        @model_type_used = model_type_used
-      end
-
-      def to_s
-        text
-      end
-    end
-  end
-end