lara-sdk 1.0.0

data/lib/lara/models/text.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Lara
+  module Models
+    class TextBlock < Base
+      attr_reader :text, :translatable
+
+      def initialize(text:, translatable: true)
+        super()
+        @text = text
+        @translatable = !!translatable
+      end
+    end
+
+    class NGMemoryMatch < Base
+      attr_reader :memory, :tuid, :language, :sentence, :translation
+
+      def initialize(memory:, language:, sentence:, translation:, tuid: nil)
+        super()
+        @memory = memory
+        @tuid = tuid
+        @language = language
+        @sentence = sentence
+        @translation = translation
+      end
+    end
+
+    class NGGlossaryMatch < Base
+      attr_reader :glossary, :language, :term, :translation
+
+      def initialize(glossary:, language:, term:, translation:)
+        super()
+        @glossary = glossary
+        @language = language
+        @term = term
+        @translation = translation
+      end
+    end
+
+    class DetectPrediction < Base
+      attr_reader :language, :confidence
+
+      def initialize(language:, confidence:)
+        super()
+        @language = language
+        @confidence = confidence
+      end
+    end
+
+    class DetectResult < Base
+      attr_reader :language, :content_type, :predictions
+
+      def initialize(language:, content_type:, predictions: [])
+        super()
+        @language = language
+        @content_type = content_type
+        @predictions = predictions.map { |p| DetectPrediction.new(**p.transform_keys(&:to_sym)) }
+      end
+    end
+
+    class TextResult < Base
+      attr_reader :content_type, :source_language, :translation,
+                  :adapted_to, :glossaries,
+                  :adapted_to_matches, :glossaries_matches
+
+      def self.from_hash(hash)
+        return nil unless hash.is_a?(Hash)
+
+        translation = hash["translation"]
+        if translation.is_a?(Array) && translation.is_a?(Array) && !translation.all?(String)
+          translation = translation.map do |e|
+            TextBlock.new(text: e["text"],
+                          translatable: e["translatable"])
+          end
+        end
+
+        adapted_to_matches = convert_matches(hash["adapted_to_matches"], NGMemoryMatch)
+        glossaries_matches = convert_matches(hash["glossaries_matches"], NGGlossaryMatch)
+
+        new(
+          content_type: hash["content_type"],
+          source_language: hash["source_language"],
+          translation: translation,
+          adapted_to: hash["adapted_to"],
+          glossaries: hash["glossaries"],
+          adapted_to_matches: adapted_to_matches,
+          glossaries_matches: glossaries_matches
+        )
+      end
+
+      def initialize(content_type:, source_language:, translation:, adapted_to: nil, glossaries: nil,
+                     adapted_to_matches: nil, glossaries_matches: nil)
+        super()
+        @content_type = content_type
+        @source_language = source_language
+        @translation = translation
+        @adapted_to = adapted_to
+        @glossaries = glossaries
+        @adapted_to_matches = adapted_to_matches
+        @glossaries_matches = glossaries_matches
+      end
+
+      class << self
+        private
+
+        def convert_matches(value, klass)
+          return nil if value.nil?
+
+          return unless value.is_a?(Array)
+
+          if value.empty?
+            []
+          elsif value.first.is_a?(Array)
+            value.map { |arr| arr.map { |h| build_match(klass, h) } }
+          else
+            value.map { |h| build_match(klass, h) }
+          end
+        end
+
+        def build_match(klass, h)
+          case klass.name.split("::").last
+          when "NGMemoryMatch"
+            NGMemoryMatch.new(
+              memory: h["memory"],
+              tuid: h["tuid"],
+              language: h["language"],
+              sentence: h["sentence"],
+              translation: h["translation"]
+            )
+          when "NGGlossaryMatch"
+            NGGlossaryMatch.new(
+              glossary: h["glossary"],
+              language: h["language"],
+              term: h["term"],
+              translation: h["translation"]
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lara/s3_client.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+
+module Lara
+  class S3Client
+    def upload(url:, fields:, io:)
+      payload_io = io.is_a?(String) ? File.open(io, "rb") : io
+
+      begin
+        filename = if io.is_a?(String)
+                     File.basename(io)
+                   else
+                     io.respond_to?(:path) ? File.basename(io.path) : "upload.bin"
+                   end
+
+        conn = Faraday.new(url: url) do |f|
+          f.request(:multipart)
+          f.request(:url_encoded)
+          f.adapter(Faraday.default_adapter)
+        end
+
+        file_part = Faraday::Multipart::FilePart.new(payload_io, "application/octet-stream",
+                                                     filename)
+
+        response = conn.post(nil) do |req|
+          req.body = fields.transform_values(&:to_s).merge("file" => file_part)
+        end
+
+        raise Lara::LaraError, "S3 upload failed: HTTP #{response.status}" unless response.success?
+
+        nil
+      ensure
+        payload_io.close if io.is_a?(String) && payload_io && !payload_io.closed?
+      end
+    rescue ArgumentError => e
+      warn "[S3Client] upload ArgumentError: #{e.message}"
+      raise
+    rescue Faraday::Error => e
+      warn "[S3Client] upload Faraday error: #{e.class} #{e.message}"
+      raise Lara::LaraError, "S3 upload failed: #{e.message}"
+    end
+
+    def download(url:)
+      conn = Faraday.new(url: url) { |f| f.adapter Faraday.default_adapter }
+      response = conn.get
+      raise Lara::LaraError, "S3 download failed: HTTP #{response.status}" unless response.success?
+
+      response.body
+    end
+  end
+end

data/lib/lara/translator.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative "client"
+
+module Lara
+  class Translator
+    # @param credentials [Lara::Credentials,nil]
+    # @param auth_token [Lara::AuthToken,nil]
+    # @param access_key_id [String,nil]
+    # @param access_key_secret [String,nil]
+    # @param base_url [String,nil]
+    # @param connection_timeout [Integer,nil]
+    # @param read_timeout [Integer,nil]
+    def initialize(credentials: nil, auth_token: nil, access_key_id: nil, access_key_secret: nil,
+                   base_url: nil, connection_timeout: nil, read_timeout: nil)
+      auth_method = if auth_token
+                      auth_token
+                    elsif credentials
+                      credentials
+                    elsif access_key_id && access_key_secret
+                      Credentials.new(access_key_id, access_key_secret)
+                    else
+                      raise ArgumentError,
+                            "either credentials, auth_token, or access_key_id and access_key_secret must be provided"
+                    end
+
+      @client = Client.new(auth_method, base_url: base_url,
+                                        connection_timeout: connection_timeout, read_timeout: read_timeout)
+      @memories = Memories.new(@client)
+      @glossaries = Glossaries.new(@client)
+      @documents = Documents.new(@client)
+      @images = Images.new(@client)
+      @audio = AudioTranslator.new(@client)
+    end
+
+    attr_reader :client, :memories, :glossaries, :documents, :images, :audio
+
+    # Translates text with optional tuning parameters.
+    # @param text [String, Array<String>, Array<Lara::Models::TextBlock>]
+    # @param source [String,nil]
+    # @param source_hint [String,nil]
+    # @param target [String]
+    # @param adapt_to [Array<String>,nil]
+    # @param glossaries [Array<String>,nil]
+    # @param instructions [Array<String>,nil]
+    # @param content_type [String,nil]
+    # @param multiline [Boolean]
+    # @param timeout_ms [Integer,nil]
+    # @param priority [String,nil]
+    # @param use_cache [String,Boolean,nil]
+    # @param cache_ttl_s [Integer,nil]
+    # @param no_trace [Boolean]
+    # @param verbose [Boolean]
+    # @param style [String,nil]
+    # @param reasoning [Boolean] When true with a block, yields partial results during reasoning
+    # @param headers [Hash,nil]
+    # @yield [Lara::Models::TextResult] Partial translation result (only when reasoning is true)
+    # @return [Lara::Models::TextResult] Final translation result
+    def translate(text, target:, source: nil, source_hint: nil, adapt_to: nil, glossaries: nil,
+                  instructions: nil, content_type: nil, multiline: true, timeout_ms: nil,
+                  priority: nil, use_cache: nil, cache_ttl_s: nil, no_trace: false, verbose: false,
+                  style: nil, reasoning: false, headers: nil, &callback)
+      q = normalize_text_input(text)
+
+      use_cache_value = case use_cache
+                        when true then "yes"
+                        when false then "no"
+                        else use_cache
+                        end
+
+      body = {
+        q: q,
+        source: source,
+        target: target,
+        source_hint: source_hint,
+        content_type: content_type,
+        multiline: multiline,
+        adapt_to: adapt_to,
+        glossaries: glossaries,
+        instructions: instructions,
+        timeout: timeout_ms,
+        priority: priority,
+        use_cache: use_cache_value,
+        cache_ttl: cache_ttl_s,
+        verbose: verbose,
+        style: style,
+        reasoning: reasoning
+      }.compact
+
+      request_headers = {}
+      request_headers.merge!(headers) if headers.is_a?(Hash)
+      request_headers["X-No-Trace"] = "true" if no_trace
+
+      stream_callback = if callback && reasoning
+                          ->(partial) { callback.call(Lara::Models::TextResult.from_hash(partial)) }
+                        end
+
+      result = @client.post("/translate", body: body, headers: request_headers, &stream_callback)
+      Lara::Models::TextResult.from_hash(result) if result
+    end
+
+    # Detects the language of the given text.
+    # @param text [String, Array<String>] Text to detect language for
+    # @param hint [String, nil] Language hint
+    # @param passlist [Array<String>, nil] List of allowed languages
+    # @return [Lara::Models::DetectResult]
+    def detect(text, hint: nil, passlist: nil)
+      body = { q: text }
+      body[:hint] = hint if hint
+      body[:passlist] = passlist if passlist&.any?
+      body = body.compact
+
+      result = @client.post("/v2/detect", body: body)
+      Lara::Models::DetectResult.new(
+        language: result["language"],
+        content_type: result["content_type"],
+        predictions: result["predictions"] || []
+      )
+    end
+
+    # Lists supported language codes.
+    def get_languages
+      @client.get("/v2/languages")
+    end
+
+    private
+
+    def normalize_text_input(text)
+      case text
+      when String
+        text
+      when Array
+        if text.all?(String)
+          text
+        elsif text.all?(Lara::Models::TextBlock)
+          text.map { |tb| { text: tb.text, translatable: tb.translatable } }
+        else
+          raise ArgumentError, "text must be an iterable of strings or TextBlock objects"
+        end
+      else
+        raise ArgumentError, "text must be a string or an iterable"
+      end
+    end
+  end
+end

data/lib/lara/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Lara
+  VERSION = "1.0.0"
+end

data/lib/lara.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "lara/version"
+require_relative "lara/credentials"
+require_relative "lara/auth_token"
+require_relative "lara/errors"
+require_relative "lara/client"
+require_relative "lara/translator"
+require_relative "lara/memories"
+require_relative "lara/glossaries"
+require_relative "lara/s3_client"
+require_relative "lara/documents"
+require_relative "lara/images"
+require_relative "lara/audio"
+
+# Models
+require_relative "lara/models/base"
+require_relative "lara/models/text"
+require_relative "lara/models/memories"
+require_relative "lara/models/glossaries"
+require_relative "lara/models/documents"
+require_relative "lara/models/images"
+require_relative "lara/models/audio"
+
+module Lara
+  # Ruby SDK for Lara AI-powered translation services
+end

metadata

@@ -0,0 +1,198 @@
+--- !ruby/object:Gem::Specification
+name: lara-sdk
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Translated
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: multipart-post
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: A Ruby library for Lara's API - AI-powered translation services
+email:
+- support@laratranslate.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lara.rb
+- lib/lara/audio.rb
+- lib/lara/auth_token.rb
+- lib/lara/client.rb
+- lib/lara/credentials.rb
+- lib/lara/documents.rb
+- lib/lara/errors.rb
+- lib/lara/glossaries.rb
+- lib/lara/images.rb
+- lib/lara/memories.rb
+- lib/lara/models/audio.rb
+- lib/lara/models/base.rb
+- lib/lara/models/documents.rb
+- lib/lara/models/glossaries.rb
+- lib/lara/models/images.rb
+- lib/lara/models/memories.rb
+- lib/lara/models/text.rb
+- lib/lara/s3_client.rb
+- lib/lara/translator.rb
+- lib/lara/version.rb
+homepage: https://laratranslate.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://laratranslate.com
+  source_code_uri: https://github.com/translated/lara-ruby
+  changelog_uri: https://github.com/translated/lara-ruby/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Official Lara SDK for Ruby
+test_files: []