Class: Lara::Memories

Inherits:
Object
  • Object
show all
Defined in:
lib/lara/memories.rb

Defined Under Namespace

Modules: ExportFormat

Instance Method Summary collapse

Constructor Details

#initialize(client) ⇒ Memories

Returns a new instance of Memories.



22
23
24
25
 
# File 'lib/lara/memories.rb', line 22

def initialize(client)
  @client = client
  @polling_interval = 2
end

Instance Method Details

#add_translation(id_or_ids, source:, target:, sentence:, translation:, tuid: nil, sentence_before: nil, sentence_after: nil, headers: nil) ⇒ Lara::Models::MemoryImport

Returns:



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/lara/memories.rb', line 73

def add_translation(id_or_ids, source:, target:, sentence:, translation:, tuid: nil,
                    sentence_before: nil, sentence_after: nil, headers: nil)
  body = {
    source: source,
    target: target,
    sentence: sentence,
    translation: translation,
    tuid: tuid,
    sentence_before: sentence_before,
    sentence_after: sentence_after
  }.compact

  if id_or_ids.is_a?(Array)
    body[:ids] = id_or_ids
    Lara::Models::MemoryImport.new(**@client.put("/v2/memories/content",
                                                 body: body, headers: headers).transform_keys(&:to_sym))
  else
    Lara::Models::MemoryImport.new(**@client.put("/v2/memories/#{id_or_ids}/content",
                                                 body: body, headers: headers).transform_keys(&:to_sym))
  end
end

#connect(ids) ⇒ Lara::Models::Memory, ...

Parameters:

  • ids (String, Array<String>)

Returns:



63
64
65
66
67
68
69
70
 
# File 'lib/lara/memories.rb', line 63

def connect(ids)
  ids_array = ids.is_a?(Array) ? ids : [ids]
  results = @client.post("/v2/memories/connect", body: { ids: ids_array }) || []
  models = results.map { |_h| Lara::Models::Memory.new(**_h.transform_keys(&:to_sym)) }
  return models if ids.is_a?(Array)

  models.first
end

#create(name:, external_id: nil) ⇒ Lara::Models::Memory

Returns:



35
36
37
38
39
 
# File 'lib/lara/memories.rb', line 35

def create(name:, external_id: nil)
  payload = { name: name, external_id: external_id }.compact
  Lara::Models::Memory.new(**@client.post("/v2/memories",
                                          body: payload).transform_keys(&:to_sym))
end

#delete(id) ⇒ Lara::Models::Memory

Returns:



51
52
53
 
# File 'lib/lara/memories.rb', line 51

def delete(id)
  Lara::Models::Memory.new(**@client.delete("/v2/memories/#{id}").transform_keys(&:to_sym))
end

#delete_translation(id_or_ids, source:, target:, sentence:, translation:, tuid: nil, sentence_before: nil, sentence_after: nil) ⇒ Lara::Models::MemoryImport

Returns:



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/lara/memories.rb', line 96

def delete_translation(id_or_ids, source:, target:, sentence:, translation:, tuid: nil,
                       sentence_before: nil, sentence_after: nil)
  body = {
    source: source,
    target: target,
    sentence: sentence,
    translation: translation,
    tuid: tuid,
    sentence_before: sentence_before,
    sentence_after: sentence_after
  }.compact

  if id_or_ids.is_a?(Array)
    body[:ids] = id_or_ids
    Lara::Models::MemoryImport.new(**@client.delete("/v2/memories/content",
                                                    body: body).transform_keys(&:to_sym))
  else
    Lara::Models::MemoryImport.new(**@client.delete("/v2/memories/#{id_or_ids}/content",
                                                    body: body).transform_keys(&:to_sym))
  end
end

#export_async(id, format: nil, callback_url:) ⇒ Lara::Models::MemoryExport

Parameters:

  • format (String, nil) (defaults to: nil) —

    One of Lara::Memories::ExportFormat constants

Returns:



139
140
141
142
143
144
145
146
147
 
# File 'lib/lara/memories.rb', line 139

def export_async(id, format: nil, callback_url:)
  if format && !ExportFormat.valid?(format)
    raise ArgumentError, "Invalid format '#{format}'. Must be one of: #{ExportFormat.all.join(', ')}"
  end

  params = { callback_url: callback_url }
  params[:format] = format if format
  Lara::Models::MemoryExport.new(**@client.get("/v2/memories/#{id}/export/async", params: params).transform_keys(&:to_sym))
end

#get(id) ⇒ Lara::Models::Memory?

Returns:



42
43
44
45
46
47
48
 
# File 'lib/lara/memories.rb', line 42

def get(id)
  Lara::Models::Memory.new(**@client.get("/v2/memories/#{id}").transform_keys(&:to_sym))
rescue Lara::LaraApiError => e
  return nil if e.status_code == 404

  raise
end

#get_import_status(import_id) ⇒ Lara::Models::MemoryImport

Returns:



150
151
152
 
# File 'lib/lara/memories.rb', line 150

def get_import_status(import_id)
  Lara::Models::MemoryImport.new(**@client.get("/v2/memories/imports/#{import_id}").transform_keys(&:to_sym))
end

#import_tmx(id, tmx_path, callback_url: nil) ⇒ Lara::Models::MemoryImport

Returns:



119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/lara/memories.rb', line 119

def import_tmx(id, tmx_path, callback_url: nil)
  require "stringio"
  require "zlib"
  basename = File.basename(tmx_path)

  buffer = StringIO.new
  gz = Zlib::GzipWriter.new(buffer, 7, Zlib::DEFAULT_STRATEGY)
  File.open(tmx_path, "rb") { |_f| IO.copy_stream(_f, gz) }
  gz.finish
  buffer.rewind

  files = { "tmx" => Faraday::UploadIO.new(buffer, "application/gzip", "#{basename}.gz") }
  body = { "compression" => "gzip" }
  body["callback_url"] = callback_url if callback_url
  Lara::Models::MemoryImport.new(**@client.post("/v2/memories/#{id}/import",
                                                body: body, files: files).transform_keys(&:to_sym))
end

#list ⇒ Array<Lara::Models::Memory>

Returns:



28
29
30
31
32
 
# File 'lib/lara/memories.rb', line 28

def list
  (@client.get("/v2/memories") || []).map do |_h|
    Lara::Models::Memory.new(**_h.transform_keys(&:to_sym))
  end
end

#update(id, name:) ⇒ Lara::Models::Memory

Returns:



56
57
58
59
 
# File 'lib/lara/memories.rb', line 56

def update(id, name:)
  Lara::Models::Memory.new(**@client.put("/v2/memories/#{id}",
                                         body: { name: name }).transform_keys(&:to_sym))
end

#wait_for_import(memory_import, max_wait_time: 0) ⇒ Lara::Models::MemoryImport

Returns:



155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/lara/memories.rb', line 155

def wait_for_import(memory_import, max_wait_time: 0)
  start = Time.now
  current = memory_import
  while current.progress && current.progress < 1.0
    if max_wait_time.to_f.positive? && (Time.now - start) > max_wait_time.to_f
      raise Timeout::Error
    end

    sleep @polling_interval
    current = get_import_status(current.id)
    yield current if block_given?
  end
  current
end