deepl-rb 3.3.0 → 3.5.0

data/lib/deepl/exceptions/bad_request.rb

@@ -1,16 +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 Exceptions
-    class BadRequest < RequestError
-      def to_s
-        JSON.parse(response.body)['message']
-      rescue JSON::ParserError
-        response.body
-      end
-    end
-  end
-end

data/lib/deepl/exceptions/document_translation_error.rb

@@ -1,15 +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 Exceptions
-    class DocumentTranslationError < Error
-      def initialize(message, handle)
-        super(message)
-        @handle = handle
-      end
-    end
-  end
-end

data/lib/deepl/exceptions/error.rb

@@ -1,14 +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 Exceptions
-    class Error < StandardError
-      def should_retry?
-        false
-      end
-    end
-  end
-end

data/lib/deepl/exceptions/limit_exceeded.rb

@@ -1,18 +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 Exceptions
-    class LimitExceeded < RequestError
-      def to_s
-        'Limit exceeded. Please wait and send your request once again.'
-      end
-
-      def should_retry?
-        true
-      end
-    end
-  end
-end

data/lib/deepl/exceptions/not_found.rb

@@ -1,16 +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 Exceptions
-    class NotFound < RequestError
-      def to_s
-        JSON.parse(response.body)['message']
-      rescue JSON::ParserError
-        response.body
-      end
-    end
-  end
-end

data/lib/deepl/exceptions/not_supported.rb

@@ -1,14 +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 Exceptions
-    class NotSupported < Error
-      def initialize(msg = 'The feature is not supported')
-        super
-      end
-    end
-  end
-end

data/lib/deepl/exceptions/quota_exceeded.rb

@@ -1,14 +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 Exceptions
-    class QuotaExceeded < RequestError
-      def to_s
-        'Quota exceeded. The character limit has been reached.'
-      end
-    end
-  end
-end

data/lib/deepl/exceptions/request_entity_too_large.rb

@@ -1,15 +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 Exceptions
-    class RequestEntityTooLarge < RequestError
-      def to_s
-        'The request size has reached the supported limit. ' \
-          "Make sure that you're not sending more than 50 text parts."
-      end
-    end
-  end
-end

data/lib/deepl/exceptions/request_error.rb

@@ -1,21 +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 Exceptions
-    class RequestError < Error
-      attr_reader :request, :response
-
-      def initialize(response)
-        super()
-        @response = response
-      end
-
-      def to_s
-        'Unknown error.'
-      end
-    end
-  end
-end

data/lib/deepl/exceptions/server_error.rb

@@ -1,18 +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 Exceptions
-    class ServerError < RequestError
-      def to_s
-        'An internal server error occured. Try again after waiting a short period.'
-      end
-
-      def should_retry?
-        true
-      end
-    end
-  end
-end

data/lib/deepl/glossary_api.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
-  class GlossaryApi
-    def initialize(api, options = {})
-      @api = api
-      @options = options
-    end
-
-    def create(name, source_lang, target_lang, entries, options = {})
-      DeepL::Requests::Glossary::Create.new(@api, name, source_lang, target_lang, entries, options)
-                                       .request
-    end
-
-    def destroy(glossary_id, options = {})
-      DeepL::Requests::Glossary::Destroy.new(@api, glossary_id, options).request
-    end
-
-    def entries(glossary_id, options = {})
-      DeepL::Requests::Glossary::Entries.new(@api, glossary_id, options).request
-    end
-
-    def find(glossary_id, options = {})
-      DeepL::Requests::Glossary::Find.new(@api, glossary_id, options).request
-    end
-
-    def language_pairs(options = {})
-      DeepL::Requests::Glossary::LanguagePairs.new(@api, options).request
-    end
-
-    def list(options = {})
-      DeepL::Requests::Glossary::List.new(@api, options).request
-    end
-  end
-end

data/lib/deepl/requests/base.rb

@@ -1,196 +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 Base # rubocop:disable Metrics/ClassLength
-      attr_reader :api, :response, :options
-
-      def initialize(api, options = {}, additional_headers = {})
-        @api = api
-        @options = options
-        @additional_headers = additional_headers
-        @num_retries = 0
-        @backoff_timer = Utils::BackoffTimer.new
-      end
-
-      def request
-        raise NotImplementedError
-      end
-
-      def details
-        "HTTP Headers #{headers}"
-      end
-
-      private
-
-      def option?(name)
-        options.key?(name.to_s) || options.key?(name.to_sym)
-      end
-
-      def option(name)
-        options[name.to_s] || options[name.to_sym]
-      end
-
-      def delete_option(name)
-        options.delete(name.to_s) || options.delete(name.to_sym)
-      end
-
-      def set_option(name, value)
-        if options.key?(name.to_sym)
-          options[name.to_sym] = value
-        else
-          options[name.to_s] = value
-        end
-      end
-
-      # Returns options excluding extra_body_parameters
-      # extra_body_parameters are applied separately via apply_extra_body_parameters_* methods
-      def options_without_extra_params
-        options.reject do |k, _|
-          k.to_s == 'extra_body_parameters' || k.to_sym == :extra_body_parameters
-        end
-      end
-
-      # Apply extra body parameters to a hash payload (for JSON/form-encoded requests)
-      # Extra parameters will override existing keys
-      def apply_extra_body_parameters_to_json(payload)
-        return unless option?(:extra_body_parameters)
-
-        extra_params = option(:extra_body_parameters)
-        extra_params.each do |key, value|
-          payload[key] = value.to_s
-        end
-      end
-
-      # Apply extra body parameters to multipart form data array
-      # Extra parameters will override existing keys
-      def apply_extra_body_parameters_to_form(form_data)
-        return unless option?(:extra_body_parameters)
-
-        extra_params = option(:extra_body_parameters)
-        extra_params.each do |key, value|
-          key_str = key.to_s
-          # Remove existing key if present to allow override.
-          # Required for form data as it would be duplicated otherwise
-          form_data.reject! { |field| field[0].to_s == key_str }
-          form_data.push([key_str, value.to_s])
-        end
-      end
-
-      # Files to reset: list of file objects to rewind when retrying the request
-      def execute_request_with_retries(req, files_to_reset = []) # rubocop:disable all
-        api.configuration.logger&.info("Request to the DeepL API: #{self}")
-        api.configuration.logger&.debug("Request details: #{details}")
-        loop do
-          resp = api.http_client.request(req)
-          validate_response!(resp)
-          return [req, resp]
-        rescue DeepL::Exceptions::Error => e
-          raise e unless should_retry?(resp, e, @backoff_timer.num_retries)
-
-          unless e.nil?
-            api.configuration.logger&.info("Encountered a retryable exception: #{e.message}")
-          end
-          api.configuration.logger&.info("Starting retry #{@backoff_timer.num_retries + 1} for " \
-                                         "request #{request} after sleeping for " \
-                                         "#{format('%.2f', @backoff_timer.time_until_deadline)}")
-          files_to_reset.each(&:rewind)
-          @backoff_timer.sleep_until_deadline
-          next
-        rescue Net::HTTPBadResponse, Net::HTTPServerError, Net::HTTPFatalError, Timeout::Error,
-               SocketError => e
-          unless e.nil?
-            api.configuration.logger&.info("Encountered a retryable exception: #{e.message}")
-          end
-          api.configuration.logger&.info("Starting retry #{@backoff_timer.num_retries + 1} for " \
-                                         "request #{request} after sleeping for " \
-                                         "#{format('%.2f', @backoff_timer.time_until_deadline)}")
-          files_to_reset.each(&:rewind)
-          @backoff_timer.sleep_until_deadline
-          next
-        end
-      end
-
-      def should_retry?(response, exception, num_retries)
-        return false if num_retries >= api.configuration.max_network_retries
-        return exception.should_retry? if response.nil?
-
-        response.is_a?(Net::HTTPTooManyRequests) || response.is_a?(Net::HTTPInternalServerError)
-      end
-
-      def post_request(payload)
-        apply_extra_body_parameters_to_json(payload)
-        http_headers = add_json_content_type(headers)
-        post_req = Net::HTTP::Post.new(uri.path, http_headers)
-        post_req.body = payload.merge(options_without_extra_params).to_json
-        post_req
-      end
-
-      def post_request_with_file(form_data)
-        http_headers = add_multipart_form_content_type(headers)
-        post_req = Net::HTTP::Post.new(uri.request_uri, http_headers)
-        post_req.set_form(form_data, 'multipart/form-data')
-        post_req
-      end
-
-      def get_request # rubocop:disable Naming/AccessorMethodName
-        http_headers = add_json_content_type(headers)
-        get_req = Net::HTTP::Get.new(uri.path, http_headers)
-        get_req.body = options_without_extra_params.to_json
-        get_req
-      end
-
-      def delete_request
-        http_headers = add_json_content_type(headers)
-        del_req = Net::HTTP::Delete.new(uri.path, http_headers)
-        del_req.body = options_without_extra_params.to_json
-        del_req
-      end
-
-      def validate_response!(response)
-        return if response.is_a?(Net::HTTPSuccess)
-
-        raise Utils::ExceptionBuilder.new(response).build
-      end
-
-      def path
-        raise NotImplementedError
-      end
-
-      def url
-        "#{host}/#{api.configuration.version}/#{path}"
-      end
-
-      def uri
-        @uri ||= URI(url)
-        @uri
-      end
-
-      def host
-        api.configuration.host
-      end
-
-      def query_params
-        options
-      end
-
-      def headers
-        { 'Authorization' => "DeepL-Auth-Key #{api.configuration.auth_key}",
-          'User-Agent' => api.configuration.user_agent }.merge(@additional_headers)
-      end
-
-      def add_json_content_type(headers_to_add_to)
-        headers_to_add_to['Content-Type'] = 'application/json'
-        headers_to_add_to
-      end
-
-      def add_multipart_form_content_type(headers_to_add_to)
-        headers_to_add_to['Content-Type'] = 'multipart/form-data'
-        headers_to_add_to
-      end
-    end
-  end
-end

data/lib/deepl/requests/document/download.rb

@@ -1,44 +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 Requests
-    module Document
-      class Download < Base
-        attr_reader :document_id, :document_key
-
-        def initialize(api, document_id, document_key, output_file)
-          super(api, {})
-          @document_id = document_id
-          @document_key = document_key
-          @output_file = output_file
-        end
-
-        def request
-          payload = { document_key: document_key }
-          extract_file(*execute_request_with_retries(post_request(payload)))
-        end
-
-        def details
-          "HTTP Headers: #{headers}\nPayload #{{ document_key: document_key }}"
-        end
-
-        def to_s
-          "POST #{uri.request_uri}"
-        end
-
-        private
-
-        def extract_file(_request, response)
-          File.write(@output_file, response.body)
-        end
-
-        def path
-          "document/#{document_id}/result"
-        end
-      end
-    end
-  end
-end

data/lib/deepl/requests/document/get_status.rb

@@ -1,44 +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 Requests
-    module Document
-      class GetStatus < Base
-        attr_reader :document_id, :document_key
-
-        def initialize(api, document_id, document_key, options = {}, additional_headers = {})
-          super(api, options, additional_headers)
-          @document_id = document_id
-          @document_key = document_key
-        end
-
-        def request
-          payload = { document_key: document_key }
-          build_doc_translation_status(*execute_request_with_retries(post_request(payload)))
-        end
-
-        def details
-          "HTTP Headers: #{headers}\nPayload #{{ document_key: document_key }}"
-        end
-
-        def to_s
-          "POST #{uri.request_uri}"
-        end
-
-        private
-
-        def build_doc_translation_status(request, response)
-          document_translation_status = JSON.parse(response.body)
-          Resources::DocumentTranslationStatus.new(document_translation_status, request, response)
-        end
-
-        def path
-          "document/#{document_id}"
-        end
-      end
-    end
-  end
-end

data/lib/deepl/requests/document/upload.rb

@@ -1,74 +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 Requests
-    module Document
-      class Upload < Base
-        attr_reader :input_file_path, :source_lang, :target_lang, :filename
-
-        SUPPORTED_OPTIONS = %w[formality glossary_id output_format].freeze
-
-        def initialize(api, input_file_path, source_lang, target_lang, filename = nil, # rubocop:disable Metrics/ParameterLists
-                       options = {}, additional_headers = {})
-          super(api, options, additional_headers)
-          @input_file_path = input_file_path
-          @source_lang = source_lang
-          @target_lang = target_lang
-          @filename = filename
-        end
-
-        def request
-          input_file = File.open(input_file_path, 'rb')
-          form_data = build_base_form_data(input_file)
-          apply_extra_body_parameters_to_form(form_data)
-          build_doc_handle(*execute_request_with_retries(post_request_with_file(form_data),
-                                                         [input_file]))
-        end
-
-        def details
-          "HTTP Headers: #{headers}\nPayload #{[
-            ['file', "File at #{input_file_path} opened in binary mode"],
-            ['source_lang', source_lang], ['target_lang', target_lang], ['filename', filename]
-          ]}"
-        end
-
-        def to_s
-          "POST #{uri.request_uri}"
-        end
-
-        private
-
-        def build_base_form_data(input_file)
-          form_data = [
-            ['file', input_file], ['source_lang', source_lang],
-            ['target_lang', target_lang]
-          ]
-          filename_param = filename || File.basename(input_file_path)
-          form_data.push(['filename', filename_param]) unless filename_param.nil?
-          add_supported_options_to_form(form_data)
-          form_data
-        end
-
-        def add_supported_options_to_form(form_data)
-          SUPPORTED_OPTIONS.each do |option_name|
-            option_value = option(option_name)
-            form_data.push([option_name, option_value]) unless option_value.nil?
-          end
-        end
-
-        def build_doc_handle(request, response)
-          parsed_response = JSON.parse(response.body)
-          Resources::DocumentHandle.new(parsed_response['document_id'],
-                                        parsed_response['document_key'], request, response)
-        end
-
-        def path
-          'document'
-        end
-      end
-    end
-  end
-end

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