lara-sdk 1.0.6 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f716cc4e241ce65c527b569fa22d48c570b974f29a8274c09c46af198e2f3e1
-  data.tar.gz: 43bc6db5d3199a3959f329d9f6b425341655432a9fbfe308bc424fb18ed3002b
+  metadata.gz: 20907c5322ca25cec94d4475f543ba03a04f611c8707711ca5b188b1aac5d708
+  data.tar.gz: 41f47a2c9a56145711d5275a9f8db3b1dc9a66e3b514d4d4106cbf2fa69bcb8e
 SHA512:
-  metadata.gz: d99be00c98ce8ecb50ccf6e0f3efb0d5a726340136cb3630c18e8ac7b3f2dab0d33fd69742859a6a0a4cfc19b3c89e7f8128d21edef48287c63f13133e665ac8
-  data.tar.gz: 4ccfd2e79297dff673b1fd06b00ab9a465cdab46c62e104f7a26d47e2ba08945d3d84b6fc22b64bde22078a612d24ab2dccef37b1e09f8b4d3fbbde335b62ed3
+  metadata.gz: 323a5b9dbe032b6cc66ca30f42cf599ebd451f29b87c9a7fa7ed0f98769b91a952c57ece507d4bf9a9a120159364c6c224059a4b7a4a09b76ec65c3a0e50f078
+  data.tar.gz: 6123b7826259215d940b6e06e75b912756f9351cf750837e793059488472dac3ff3fc47906a4e6922b966873ea9803e240e588d9e9cf80f8c67509e3798136a0

data/lib/lara/auth_token.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "json"
+require "base64"
+
 module Lara
   # JWT authentication token for API access
   class AuthToken
@@ -8,10 +11,34 @@ module Lara
     def initialize(token, refresh_token)
       @token = token
       @refresh_token = refresh_token
+      @expires_at_ms = parse_expires_at_ms(token)
     end
 
     def to_s
       token
     end
+
+    def token_expired?
+      @expires_at_ms <= (Time.now.to_f * 1000).to_i + 5_000 # 5 seconds buffer
+    end
+
+    private
+
+    def parse_expires_at_ms(token)
+      return 0 if token.nil? || token.empty?
+
+      parts = token.split(".")
+      return 0 if parts.length != 3
+
+      b64 = parts[1].tr("-_", "+/")
+      b64 += "=" * (4 - (b64.length % 4)) if b64.length % 4 != 0
+
+      exp = JSON.parse(Base64.decode64(b64))["exp"]
+      return 0 unless exp.is_a?(Numeric)
+
+      (exp * 1000).to_i
+    rescue StandardError
+      0
+    end
   end
 end

data/lib/lara/client.rb

@@ -7,6 +7,7 @@ require "openssl"
 require "base64"
 require "digest"
 require "uri"
+require "monitor"
 
 module Lara
   # This class is used to interact with Lara via the REST API.
@@ -31,7 +32,7 @@ module Lara
       @connection_timeout = connection_timeout
       @read_timeout = read_timeout
       @extra_headers = {}
-      @auth_mutex = Mutex.new
+      @auth_mutex = Monitor.new
 
       @connection = build_connection
     end
@@ -93,23 +94,37 @@ module Lara
       make_request(method, path, body: body, files: files, headers: headers, params: params,
                    raw_response: raw_response, &callback)
     rescue LaraApiError => e
-      # Auto-refresh token on 401 with jwt expired
-      raise unless e.status_code == 401 && e.message.include?("jwt expired")
+      raise unless e.status_code == 401
 
-      refresh_token
-      # Retry once with new token
+      @auth_mutex.synchronize { refresh_or_reauthenticate }
       make_request(method, path, body: body, files: files, headers: headers, params: params,
                    raw_response: raw_response, &callback)
     end
 
     def ensure_valid_token
       @auth_mutex.synchronize do
-        return if @auth_token
+        return if @auth_token && !@auth_token.token_expired?
 
-        raise LaraError, "No authentication method available" unless @credentials
+        refresh_or_reauthenticate
+      end
+    end
+
+    def refresh_or_reauthenticate
+      if @auth_token&.refresh_token && !@auth_token.refresh_token.empty?
+        begin
+          do_refresh
+          return
+        rescue StandardError
+          raise unless @credentials
+        end
+      end
 
+      if @credentials
         @auth_token = authenticate
+        return
       end
+
+      raise LaraError, "No authentication method available for token renewal"
     end
 
     def authenticate
@@ -143,47 +158,37 @@ module Lara
       raise LaraApiError.from_response(response) unless response.success?
 
       data = JSON.parse(response.body)
-      refresh_token = response.headers["x-lara-refresh-token"]
+      refresh_token_value = response.headers["x-lara-refresh-token"]
 
-      raise LaraError, "Missing refresh token in authentication response" unless refresh_token
+      raise LaraError, "Missing refresh token in authentication response" unless refresh_token_value
 
-      AuthToken.new(data["token"], refresh_token)
+      AuthToken.new(data["token"], refresh_token_value)
     end
 
-    def refresh_token
-      @auth_mutex.synchronize do
-        return unless @auth_token
-
-        conn = Faraday.new(url: @base_url) do |c|
-          c.adapter Faraday.default_adapter
-        end
+    def do_refresh
+      raise LaraError, "No refresh token available" unless @auth_token&.refresh_token
 
-        response = conn.post("/v2/auth/refresh") do |req|
-          req.headers = {
-            "Date" => Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S GMT"),
-            "X-Lara-SDK-Name" => "lara-ruby",
-            "X-Lara-SDK-Version" => Lara::VERSION,
-            "Authorization" => "Bearer #{@auth_token&.refresh_token}"
-          }
-        end
+      conn = Faraday.new(url: @base_url) do |c|
+        c.adapter Faraday.default_adapter
+      end
 
-        if response.success?
-          data = JSON.parse(response.body)
-          refresh_token = response.headers["x-lara-refresh-token"]
-
-          if refresh_token
-            @auth_token = AuthToken.new(data["token"], refresh_token)
-          else
-            # Refresh failed, force re-authentication
-            @auth_token = nil
-            ensure_valid_token
-          end
-        else
-          # Refresh failed, force re-authentication
-          @auth_token = nil
-          ensure_valid_token
-        end
+      response = conn.post("/v2/auth/refresh") do |req|
+        req.headers = {
+          "Date" => Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S GMT"),
+          "X-Lara-SDK-Name" => "lara-ruby",
+          "X-Lara-SDK-Version" => Lara::VERSION,
+          "Authorization" => "Bearer #{@auth_token.refresh_token}"
+        }
       end
+
+      raise LaraApiError.from_response(response) unless response.success?
+
+      data = JSON.parse(response.body)
+      refresh_token_value = response.headers["x-lara-refresh-token"]
+
+      raise LaraError, "Missing refresh token in refresh response" unless refresh_token_value
+
+      @auth_token = AuthToken.new(data["token"], refresh_token_value)
     end
 
     def make_request(method, path, body: nil, files: nil, headers: nil, params: nil, raw_response: false, &callback)
@@ -221,8 +226,14 @@ module Lara
     end
 
     def parse_json(body)
-      parsed = body.nil? || body.empty? ? {} : JSON.parse(body)
-      parsed.is_a?(Hash) && parsed.key?("content") ? parsed["content"] : parsed
+      return {} if body.nil? || body.empty?
+
+      parsed = JSON.parse(body)
+      if parsed.is_a?(Hash) && parsed.key?("content")
+        inner = parsed["content"]
+        return inner if inner.is_a?(Hash) || inner.is_a?(Array)
+      end
+      parsed
     end
 
     def parse_stream_response(body, &block)

data/lib/lara/errors.rb

@@ -17,15 +17,16 @@ module Lara
   class LaraApiError < LaraError
     attr_reader :type
 
-    # Builds an error from an HTTP response with JSON body:
-    # { "error": { "type": "...", "message": "..." } }
+    # Builds an error from an HTTP response with JSON body.
+    # Supports both { "error": { "type": "...", "message": "..." } }
+    # and { "type": "...", "message": "..." } response formats.
     def self.from_response(response)
       data = begin
         JSON.parse(response.body)
       rescue StandardError
         {}
       end
-      error = data["error"] || {}
+      error = data["error"] || data
       error_type = error["type"] || "UnknownError"
       error_message = error["message"] || "An unknown error occurred"
       new(response.status, error_type, error_message)

data/lib/lara/models/text.rb

@@ -39,6 +39,83 @@ module Lara
       end
     end
 
+    class DetectedProfanity < Base
+      attr_reader :text, :start_char_index, :end_char_index, :score
+
+      def initialize(text:, start_char_index:, end_char_index:, score:)
+        super()
+        @text = text
+        @start_char_index = start_char_index
+        @end_char_index = end_char_index
+        @score = score
+      end
+    end
+
+    class ProfanityDetectResult < Base
+      attr_reader :masked_text, :profanities
+
+      def initialize(masked_text:, profanities: [])
+        super()
+        @masked_text = masked_text
+        @profanities = profanities.map do |p|
+          DetectedProfanity.new(
+            text: p["text"] || p[:text],
+            start_char_index: p["start_char_index"] || p[:start_char_index],
+            end_char_index: p["end_char_index"] || p[:end_char_index],
+            score: p["score"] || p[:score]
+          )
+        end
+      end
+    end
+
+    class StyleguideChange < Base
+      attr_reader :id, :original_translation, :refined_translation, :explanation
+
+      def initialize(id:, original_translation:, refined_translation:, explanation:)
+        super()
+        @id = id
+        @original_translation = original_translation
+        @refined_translation = refined_translation
+        @explanation = explanation
+      end
+
+      def to_s
+        "StyleguideChange{id='#{id}', explanation='#{explanation}'}"
+      end
+    end
+
+    class StyleguideResults < Base
+      attr_reader :original_translation, :changes
+
+      def initialize(original_translation:, changes: [])
+        super()
+        @original_translation = original_translation
+        @changes = changes
+      end
+
+      def to_s
+        "StyleguideResults{changes=#{changes&.size || 0}}"
+      end
+    end
+
+    class Styleguide < Base
+      attr_reader :id, :name, :content, :owner_id, :created_at, :updated_at
+
+      def initialize(id:, name:, content: nil, owner_id: nil, created_at: nil, updated_at: nil, **_kwargs)
+        super()
+        @id = id
+        @name = name
+        @content = content
+        @owner_id = owner_id
+        @created_at = Base.parse_time(created_at)
+        @updated_at = Base.parse_time(updated_at)
+      end
+
+      def to_s
+        "Styleguide{id='#{id}', name='#{name}'}"
+      end
+    end
+
     class DetectPrediction < Base
       attr_reader :language, :confidence
 
@@ -60,10 +137,20 @@ module Lara
       end
     end
 
+    class QualityEstimationResult < Base
+      attr_reader :score
+
+      def initialize(score:)
+        super()
+        @score = score
+      end
+    end
+
     class TextResult < Base
       attr_reader :content_type, :source_language, :translation,
                   :adapted_to, :glossaries,
-                  :adapted_to_matches, :glossaries_matches
+                  :adapted_to_matches, :glossaries_matches,
+                  :profanities, :styleguide_results
 
       def self.from_hash(hash)
         return nil unless hash.is_a?(Hash)
@@ -78,6 +165,8 @@ module Lara
 
         adapted_to_matches = convert_matches(hash["adapted_to_matches"], NGMemoryMatch)
         glossaries_matches = convert_matches(hash["glossaries_matches"], NGGlossaryMatch)
+        profanities = convert_profanities(hash["profanities"])
+        styleguide_results = convert_styleguide_results(hash["styleguide_results"])
 
         new(
           content_type: hash["content_type"],
@@ -86,12 +175,15 @@ module Lara
           adapted_to: hash["adapted_to"],
           glossaries: hash["glossaries"],
           adapted_to_matches: adapted_to_matches,
-          glossaries_matches: glossaries_matches
+          glossaries_matches: glossaries_matches,
+          profanities: profanities,
+          styleguide_results: styleguide_results
         )
       end
 
       def initialize(content_type:, source_language:, translation:, adapted_to: nil, glossaries: nil,
-                     adapted_to_matches: nil, glossaries_matches: nil)
+                     adapted_to_matches: nil, glossaries_matches: nil, profanities: nil,
+                     styleguide_results: nil)
         super()
         @content_type = content_type
         @source_language = source_language
@@ -100,6 +192,8 @@ module Lara
         @glossaries = glossaries
         @adapted_to_matches = adapted_to_matches
         @glossaries_matches = glossaries_matches
+        @profanities = profanities
+        @styleguide_results = styleguide_results
       end
 
       class << self
@@ -119,6 +213,46 @@ module Lara
           end
         end
 
+        def convert_profanities(value)
+          return nil if value.nil?
+
+          if value.is_a?(Hash)
+            ProfanityDetectResult.new(
+              masked_text: value["masked_text"],
+              profanities: value["profanities"] || []
+            )
+          elsif value.is_a?(Array)
+            value.map do |v|
+              next nil if v.nil?
+
+              ProfanityDetectResult.new(
+                masked_text: v["masked_text"],
+                profanities: v["profanities"] || []
+              )
+            end
+          end
+        end
+
+        def convert_styleguide_results(value)
+          return nil if value.nil?
+          return nil unless value.is_a?(Hash)
+
+          original_translation = value["original_translation"]
+          changes = (value["changes"] || []).map do |c|
+            StyleguideChange.new(
+              id: c["id"],
+              original_translation: c["original_translation"],
+              refined_translation: c["refined_translation"],
+              explanation: c["explanation"]
+            )
+          end
+
+          StyleguideResults.new(
+            original_translation: original_translation,
+            changes: changes
+          )
+        end
+
         def build_match(klass, h)
           case klass.name.split("::").last
           when "NGMemoryMatch"

data/lib/lara/styleguides.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Lara
+  class Styleguides
+    def initialize(client)
+      @client = client
+    end
+
+    # @return [Array<Lara::Models::Styleguide>]
+    def list
+      (@client.get("/v2/styleguides") || []).map do |h|
+        Lara::Models::Styleguide.new(**h.transform_keys(&:to_sym))
+      end
+    end
+
+    # @return [Lara::Models::Styleguide,nil]
+    def get(id)
+      Lara::Models::Styleguide.new(**@client.get("/v2/styleguides/#{id}").transform_keys(&:to_sym))
+    rescue Lara::LaraApiError => e
+      return nil if e.status_code == 404
+
+      raise
+    end
+  end
+end

data/lib/lara/translator.rb

@@ -28,12 +28,13 @@ module Lara
                                         connection_timeout: connection_timeout, read_timeout: read_timeout)
       @memories = Memories.new(@client)
       @glossaries = Glossaries.new(@client)
+      @styleguides = Styleguides.new(@client)
       @documents = Documents.new(@client)
       @images = Images.new(@client)
       @audio = AudioTranslator.new(@client)
     end
 
-    attr_reader :client, :memories, :glossaries, :documents, :images, :audio
+    attr_reader :client, :memories, :glossaries, :styleguides, :documents, :images, :audio
 
     # Translates text with optional tuning parameters.
     # @param text [String, Array<String>, Array<Lara::Models::TextBlock>]
@@ -55,12 +56,16 @@ module Lara
     # @param reasoning [Boolean] When true with a block, yields partial results during reasoning
     # @param headers [Hash,nil]
     # @param metadata [String, Hash, nil]
+    # @param profanity_filter [String,nil] One of "detect", "avoid", "hide"
     # @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, metadata: nil, &callback)
+                  style: nil, reasoning: false, headers: nil, metadata: nil,
+                  profanity_filter: nil,
+                  styleguide_id: nil, styleguide_reasoning: nil,
+                  styleguide_explanation_language: nil, &callback)
       q = normalize_text_input(text)
 
       use_cache_value = case use_cache
@@ -86,7 +91,11 @@ module Lara
         verbose: verbose,
         style: style,
         reasoning: reasoning,
-        metadata: metadata
+        metadata: metadata,
+        profanity_filter: profanity_filter,
+        styleguide_id: styleguide_id,
+        styleguide_reasoning: styleguide_reasoning,
+        styleguide_explanation_language: styleguide_explanation_language
       }.compact
 
       request_headers = {}
@@ -112,7 +121,7 @@ module Lara
       body[:passlist] = passlist if passlist&.any?
       body = body.compact
 
-      result = @client.post("/v2/detect", body: body)
+      result = @client.post("/v2/detect/language", body: body)
       Lara::Models::DetectResult.new(
         language: result["language"],
         content_type: result["content_type"],
@@ -120,6 +129,48 @@ module Lara
       )
     end
 
+    VALID_CONTENT_TYPES = %w[text/plain text/html text/xml application/xliff+xml].freeze
+
+    # Detects profanities in the given text.
+    # @param text [String] Text to check for profanities
+    # @param language [String] Language code (e.g. "en")
+    # @param content_type [String] One of "text/plain", "text/html", "text/xml", "application/xliff+xml"
+    # @return [Lara::Models::ProfanityDetectResult]
+    def detect_profanities(text, language:, content_type: "text/plain")
+      unless VALID_CONTENT_TYPES.include?(content_type)
+        raise ArgumentError, "Invalid content_type '#{content_type}'. Must be one of: #{VALID_CONTENT_TYPES.join(', ')}"
+      end
+
+      body = { text: text, language: language, content_type: content_type }
+      result = @client.post("/v2/detect/profanities", body: body)
+      Lara::Models::ProfanityDetectResult.new(
+        masked_text: result["masked_text"],
+        profanities: result["profanities"] || []
+      )
+    end
+
+    # Estimates translation quality for a sentence pair (or batch of pairs).
+    # @param source [String]
+    # @param target [String]
+    # @param sentence [String, Array<String>]
+    # @param translation [String, Array<String>]
+    # @return [Lara::Models::QualityEstimationResult, Array<Lara::Models::QualityEstimationResult>]
+    def quality_estimation(source:, target:, sentence:, translation:)
+      body = {
+        source: source,
+        target: target,
+        sentence: sentence,
+        translation: translation
+      }
+
+      result = @client.post("/v2/detect/quality-estimation", body: body)
+      if result.is_a?(Array)
+        result.map { |r| Lara::Models::QualityEstimationResult.new(score: r["score"] || r[:score]) }
+      else
+        Lara::Models::QualityEstimationResult.new(score: result["score"] || result[:score])
+      end
+    end
+
     # Lists supported language codes.
     def get_languages
       @client.get("/v2/languages")

data/lib/lara/version.rb

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

data/lib/lara.rb

@@ -8,6 +8,7 @@ require_relative "lara/client"
 require_relative "lara/translator"
 require_relative "lara/memories"
 require_relative "lara/glossaries"
+require_relative "lara/styleguides"
 require_relative "lara/s3_client"
 require_relative "lara/documents"
 require_relative "lara/images"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lara-sdk
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.2.1
 platform: ruby
 authors:
 - Translated
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-11 00:00:00.000000000 Z
+date: 2026-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -167,6 +167,7 @@ files:
 - lib/lara/models/memories.rb
 - lib/lara/models/text.rb
 - lib/lara/s3_client.rb
+- lib/lara/styleguides.rb
 - lib/lara/translator.rb
 - lib/lara/version.rb
 homepage: https://laratranslate.com