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_account_share(id, name: nil) ⇒ Object 



77
78
79
 
# File 'lib/lara/memories.rb', line 77

def (id, name: nil)
  memory_from(@client.post("/v2/memories/#{id}/shares", body: { name: name }.compact))
end

#add_group_share(id, group_id, name: nil) ⇒ Object 



89
90
91
 
# File 'lib/lara/memories.rb', line 89

def add_group_share(id, group_id, name: nil)
  memory_from(@client.post("/v2/memories/#{id}/shares/groups/#{group_id}", body: { name: name }.compact))
end

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

Returns:



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/lara/memories.rb', line 102

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:



125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/lara/memories.rb', line 125

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:



168
169
170
171
172
173
174
175
176
 
# File 'lib/lara/memories.rb', line 168

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:



179
180
181
 
# File 'lib/lara/memories.rb', line 179

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

#get_shares(id) ⇒ Lara::Models::MemoryShares

Returns:



73
74
75
 
# File 'lib/lara/memories.rb', line 73

def get_shares(id)
  Lara::Models::MemoryShares.new(**@client.get("/v2/memories/#{id}/shares").transform_keys(&:to_sym))
end

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

Returns:



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/lara/memories.rb', line 148

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

#rename_account_share(id, name:) ⇒ Object 



81
82
83
 
# File 'lib/lara/memories.rb', line 81

def (id, name:)
  memory_from(@client.put("/v2/memories/#{id}/shares", body: { name: name }))
end

#rename_group_share(id, group_id, name:) ⇒ Object 



93
94
95
 
# File 'lib/lara/memories.rb', line 93

def rename_group_share(id, group_id, name:)
  memory_from(@client.put("/v2/memories/#{id}/shares/groups/#{group_id}", body: { name: name }))
end

#revoke_account_share(id) ⇒ Object 



85
86
87
 
# File 'lib/lara/memories.rb', line 85

def (id)
  memory_from(@client.delete("/v2/memories/#{id}/shares"))
end

#revoke_group_share(id, group_id) ⇒ Object 



97
98
99
 
# File 'lib/lara/memories.rb', line 97

def revoke_group_share(id, group_id)
  memory_from(@client.delete("/v2/memories/#{id}/shares/groups/#{group_id}"))
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:



184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/lara/memories.rb', line 184

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