lara-sdk 1.0.9 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bec4d6b11a9be0d2481e0c83488befb4230e87cba9ec5d598f8ee397307b0c8c
-  data.tar.gz: 9db2905ef0db583ef555c1792d326369776c2508d2d5bdc3a75ff9176320c284
+  metadata.gz: 3a959c719f2393f4626f029c7116d426f1402889baeaea48a16800fbb58cd229
+  data.tar.gz: 54b9f604df73458c8abebb16ecce4389dcf4486f255d53187e3ad8dd7d2145c4
 SHA512:
-  metadata.gz: 9b644e13aeb677fa3a95af224165f87d1b35fdaf7f356ad25d1fc803cd0e243641e99a25514e5cbfef15d110efb4bca232d69e92fff333348ce68794d4e9f6f3
-  data.tar.gz: 488de412d6562bbca3b8c6f9ba613da79150dccbdfdb58a1be4e1288ccaa8f3f060d6584c98b58ecb9e1802f12dae6b2ffa6e41b34ac52469c2a0aa3c9b1d271
+  metadata.gz: 0d29539cdb0b1fe5add2b2f3200b812666d1edd1c0ebac1d77604f9c696f1f791cac76a791a0fedf7d75d6c263086090b57116705c477f1d9455ae27bb2e4c67
+  data.tar.gz: 29de437c146d524cca9b29a198ebbdb3426e8bf258a073d72e9740efedcd84edb83d01156870f3a461b1d62fcb144cb52b27c178bb51a8d7b7b521593d60ecff

data/lib/lara/client.rb

@@ -226,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/models/text.rb

@@ -39,6 +39,99 @@ 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, :error
+
+      def initialize(masked_text:, profanities: [], error: nil)
+        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
+        @error = error
+      end
+    end
+
+    # Wraps profanity detection results for both target and (optionally) source text.
+    # Returned in TextResult#profanities when profanities_detect is set.
+    class ProfanitiesResult < Base
+      # @return [ProfanityDetectResult, Array<ProfanityDetectResult, nil>, nil]
+      attr_reader :target
+      # @return [ProfanityDetectResult, Array<ProfanityDetectResult, nil>, nil]
+      attr_reader :source
+
+      def initialize(target: nil, source: nil)
+        super()
+        @target = target
+        @source = source
+      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 +153,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 +181,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 +191,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 +208,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 +229,59 @@ module Lara
           end
         end
 
+        def convert_profanities(value)
+          return nil if value.nil?
+          return nil unless value.is_a?(Hash)
+          return nil unless value.key?("target") || value.key?("source")
+
+          ProfanitiesResult.new(
+            target: parse_profanity_value(value["target"]),
+            source: parse_profanity_value(value["source"])
+          )
+        end
+
+        def parse_profanity_value(value)
+          return nil if value.nil?
+
+          if value.is_a?(Hash)
+            ProfanityDetectResult.new(
+              masked_text: value["masked_text"],
+              profanities: value["profanities"] || [],
+              error: value["error"]
+            )
+          elsif value.is_a?(Array)
+            value.map do |v|
+              next nil if v.nil?
+
+              ProfanityDetectResult.new(
+                masked_text: v["masked_text"],
+                profanities: v["profanities"] || [],
+                error: v["error"]
+              )
+            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,17 @@ 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 profanities_detect [String,nil] One of "target", "source_target"
+    # @param profanities_handling [String,nil] One of "detect", "avoid", "hide" (default: "hide" when profanities_detect is set)
     # @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,
+                  profanities_detect: nil, profanities_handling: 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 +92,12 @@ module Lara
         verbose: verbose,
         style: style,
         reasoning: reasoning,
-        metadata: metadata
+        metadata: metadata,
+        profanities_detect: profanities_detect,
+        profanities_handling: profanities_handling,
+        styleguide_id: styleguide_id,
+        styleguide_reasoning: styleguide_reasoning,
+        styleguide_explanation_language: styleguide_explanation_language
       }.compact
 
       request_headers = {}
@@ -112,7 +123,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 +131,49 @@ 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"] || [],
+        error: result["error"]
+      )
+    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.9"
+  VERSION = "1.2.2"
 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.9
+  version: 1.2.2
 platform: ruby
 authors:
 - Translated
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-16 00:00:00.000000000 Z
+date: 2026-04-28 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