Module: Baidu::Aip::Client

Includes:
Tokenable
Included in:
Baidu::Aip
Defined in:
lib/baidu/aip/client.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Tokenable

#access_token, #access_token=, #expire_time, #expire_time=

Instance Attribute Details

#api_key ⇒ Object

Returns the value of attribute api_key.



82
83
84
 
# File 'lib/baidu/aip/client.rb', line 82

def api_key
  @api_key
end

#secret_key ⇒ Object

Returns the value of attribute secret_key.



82
83
84
 
# File 'lib/baidu/aip/client.rb', line 82

def secret_key
  @secret_key
end

Instance Method Details

#face_detect(image_in_base64, options = {}) ⇒ Object

Face



85
86
87
88
89
 
# File 'lib/baidu/aip/client.rb', line 85

def face_detect(image_in_base64, options = {})
  aip = Face::Detect.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#face_group_copy_user(group_id, uid, source_group_id) ⇒ Object 



91
92
93
94
95
 
# File 'lib/baidu/aip/client.rb', line 91

def face_group_copy_user(group_id, uid, source_group_id)
  aip = Face::GroupCopyUser.new({group_id: group_id, uid: uid, src_group_id: source_group_id})
  aip.client = self
  aip.process
end

#face_group_delete_user(group_id, uid) ⇒ Object 



98
99
100
101
102
 
# File 'lib/baidu/aip/client.rb', line 98

def face_group_delete_user(group_id, uid)
  aip = Face::GroupDeleteUser.new({group_id: group_id, uid: uid})
  aip.client = self
  aip.process
end

#face_group_get_list(options = {}) ⇒ Object 



105
106
107
108
109
 
# File 'lib/baidu/aip/client.rb', line 105

def face_group_get_list(options = {})
  aip = Face::GroupGetList.new options
  aip.client = self
  aip.process
end

#face_group_get_users(group_id, options = {}) ⇒ Object 



112
113
114
115
116
 
# File 'lib/baidu/aip/client.rb', line 112

def face_group_get_users(group_id, options = {})
  aip = Face::GroupGetUsers.new options.merge({group_id: group_id})
  aip.client = self
  aip.process
end

#face_identify(image_in_base64, group_id, options = {}) ⇒ Object 



119
120
121
122
123
 
# File 'lib/baidu/aip/client.rb', line 119

def face_identify(image_in_base64, group_id, options = {})
  aip = Face::Identify.new options.merge({image: image_in_base64, group_id: group_id})
  aip.client = self
  aip.process
end

#face_match(images_in_base64 = [], options = {}) ⇒ Object 



126
127
128
129
130
 
# File 'lib/baidu/aip/client.rb', line 126

def face_match(images_in_base64 = [], options = {})
  aip = Face::Match.new options.merge({image: images_in_base64.join(',')})
  aip.client = self
  aip.process
end

#face_multi_identify(image_in_base64, group_id, options = {}) ⇒ Object 



133
134
135
136
137
 
# File 'lib/baidu/aip/client.rb', line 133

def face_multi_identify(image_in_base64, group_id, options = {})
  aip = Face::MultiIdentify.new options.merge({image: image_in_base64, group_id: group_id})
  aip.client = self
  aip.process
end

#face_user_add(uid, group_id, image_in_base64, user_info, options = {}) ⇒ Object 



140
141
142
143
144
 
# File 'lib/baidu/aip/client.rb', line 140

def face_user_add(uid, group_id, image_in_base64, , options = {})
  aip = Face::UserAdd.new options.merge({uid: uid, group_id: group_id, image: image_in_base64, user_info: })
  aip.client = self
  aip.process
end

#face_user_delete(uid, options = {}) ⇒ Object 



146
147
148
149
150
 
# File 'lib/baidu/aip/client.rb', line 146

def face_user_delete(uid, options = {})
  aip = Face::UserDelete.new options.merge({uid: uid})
  aip.client = self
  aip.process
end

#face_user_get(uid, options = {}) ⇒ Object 



152
153
154
155
156
 
# File 'lib/baidu/aip/client.rb', line 152

def face_user_get(uid, options = {})
  aip = Face::UserGet.new options.merge({uid: uid})
  aip.client = self
  aip.process
end

#face_user_update(uid, image_in_base64, user_info, group_id, options = {}) ⇒ Object 



158
159
160
161
162
 
# File 'lib/baidu/aip/client.rb', line 158

def face_user_update(uid, image_in_base64, , group_id, options = {})
  aip = Face::UserUpdate.new options.merge({uid: uid, image: image_in_base64, user_info: , group_id: group_id})
  aip.client = self
  aip.process
end

#face_verify(image_in_base64, id_card_number, name, options = {}) ⇒ Object 



165
166
167
168
169
 
# File 'lib/baidu/aip/client.rb', line 165

def face_verify(image_in_base64, id_card_number, name, options = {})
  aip = Face::Verify.new options.merge({image: image_in_base64, id_card_number: id_card_number, name: name})
  aip.client = self
  aip.process
end

#image_audit_anti_porn(image_in_base64) ⇒ Object

Image audit



231
232
233
234
235
 
# File 'lib/baidu/aip/client.rb', line 231

def image_audit_anti_porn(image_in_base64)
  aip = ImageAudit::AntiPorn.new({image: image_in_base64})
  aip.client = self
  aip.process
end

#image_audit_anti_porn_gif(image_in_base64) ⇒ Object 



237
238
239
240
241
 
# File 'lib/baidu/aip/client.rb', line 237

def image_audit_anti_porn_gif(image_in_base64)
  aip = ImageAudit::AntiPornGif.new({image: image_in_base64})
  aip.client = self
  aip.process
end

#image_audit_anti_terrer(image_in_base64) ⇒ Object 



243
244
245
246
247
 
# File 'lib/baidu/aip/client.rb', line 243

def image_audit_anti_terrer(image_in_base64)
  aip = ImageAudit::AntiTerror.new({image: image_in_base64})
  aip.client = self
  aip.process
end

#image_audit_combination(scenes, image_in_base64, options = {}) ⇒ Object 



249
250
251
252
253
 
# File 'lib/baidu/aip/client.rb', line 249

def image_audit_combination(scenes, image_in_base64, options={})
  aip = ImageAudit::Combination.new options.merge({scenes: scenes, image: image_in_base64})
  aip.client = self
  aip.process
end

#image_audit_combination_with_url(scenes, image_url, options = {}) ⇒ Object 



255
256
257
258
259
 
# File 'lib/baidu/aip/client.rb', line 255

def image_audit_combination_with_url(scenes, image_url, options={})
  aip = ImageAudit::Combination.new options.merge({scenes: scenes, imageUrl: image_url})
  aip.client = self
  aip.process
end

#image_audit_face(images_in_base64 = []) ⇒ Object 



261
262
263
264
265
 
# File 'lib/baidu/aip/client.rb', line 261

def image_audit_face(images_in_base64 = [])
  aip = ImageAudit::Face.new({images: images_in_base64.join(',')})
  aip.client = self
  aip.process
end

#image_audit_face_url(image_url) ⇒ Object 



267
268
269
270
271
 
# File 'lib/baidu/aip/client.rb', line 267

def image_audit_face_url(image_urls = [])
  aip = ImageAudit::Face.new({imgUrls: image_urls.join(',')})
  aip.client = self
  aip.process
end

#image_audit_user_defined(image_in_base64) ⇒ Object 



273
274
275
276
277
 
# File 'lib/baidu/aip/client.rb', line 273

def image_audit_user_defined(image_in_base64)
  aip = ImageAudit::UserDefined.new({image: images_in_base64})
  aip.client = self
  aip.process
end

#image_recognition_animal(image_in_base64, options = {}) ⇒ Object

Image_recognition



174
175
176
177
178
179
 
# File 'lib/baidu/aip/client.rb', line 174

def image_recognition_animal(image_in_base64, options = {})
  aip = ImageRecognition::Animal.new options.merge({image: image_in_base64})
  aip.client = self

  aip.process
end

#image_recognition_car(image_in_base64, options = {}) ⇒ Object 



181
182
183
184
185
186
 
# File 'lib/baidu/aip/client.rb', line 181

def image_recognition_car(image_in_base64, options = {})
  aip = ImageRecognition::Car.new options.merge({image: image_in_base64})
  aip.client = self

  aip.process
end

#image_recognition_dish(image_in_base64, options = {}) ⇒ Object 



188
189
190
191
192
193
 
# File 'lib/baidu/aip/client.rb', line 188

def image_recognition_dish(image_in_base64, options = {})
  aip = ImageRecognition::Dish.new options.merge({image: image_in_base64})
  aip.client = self

  aip.process
end

#image_recognition_logo(image_in_base64, options = {}) ⇒ Object 



195
196
197
198
199
200
 
# File 'lib/baidu/aip/client.rb', line 195

def (image_in_base64, options = {})
  aip = ImageRecognition::Logo.new options.merge({image: image_in_base64})
  aip.client = self

  aip.process
end

#image_recognition_logo_add(image_in_base64, brief) ⇒ Object 



202
203
204
205
206
207
 
# File 'lib/baidu/aip/client.rb', line 202

def image_recognition_logo_add(image_in_base64, brief)
  aip = ImageRecognition::LogoAdd.new options.merge({image: image_in_base64, brief: brief})
  aip.client = self

  aip.process
end

#image_recognition_logo_delete(image_in_base64, cont_sign) ⇒ Object 



209
210
211
212
213
214
 
# File 'lib/baidu/aip/client.rb', line 209

def image_recognition_logo_delete(image_in_base64, cont_sign)
  aip = ImageRecognition::LogoDelete.new options.merge({image: image_in_base64, cont_sign: cont_sign})
  aip.client = self

  aip.process
end

#image_recognition_object(image_in_base64, options = {}) ⇒ Object 



216
217
218
219
220
221
 
# File 'lib/baidu/aip/client.rb', line 216

def image_recognition_object(image_in_base64, options = {})
  aip = ImageRecognition::Object.new options.merge({image: image_in_base64})
  aip.client = self

  aip.process
end

#image_recognition_plant(image_in_base64) ⇒ Object 



223
224
225
226
227
228
 
# File 'lib/baidu/aip/client.rb', line 223

def image_recognition_plant(image_in_base64)
  aip = ImageRecognition::Plant.new({image: image_in_base64})
  aip.client = self

  aip.process
end

#image_search_product(image_in_base64, options = {}) ⇒ Object 



292
293
294
295
296
 
# File 'lib/baidu/aip/client.rb', line 292

def image_search_product(image_in_base64, options = {})
  aip = ImageSearch::Product.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#image_search_product_add(image_in_base64, options = {}) ⇒ Object

Image Search



286
287
288
289
290
 
# File 'lib/baidu/aip/client.rb', line 286

def image_search_product_add(image_in_base64, options = {})
  aip = ImageSearch::ProductAdd.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#image_search_product_delete(image_in_base64) ⇒ Object 



298
299
300
301
302
 
# File 'lib/baidu/aip/client.rb', line 298

def image_search_product_delete(image_in_base64)
  aip = ImageSearch::ProductDelete.new({image: image_in_base64})
  aip.client = self
  aip.process
end

#image_search_same(image_in_base64) ⇒ Object 



310
311
312
313
314
 
# File 'lib/baidu/aip/client.rb', line 310

def image_search_same(image_in_base64)
  aip = ImageSearch::Same.new({image: image_in_base64})
  aip.client = self
  aip.process
end

#image_search_same_add(image_in_base64, brief) ⇒ Object 



304
305
306
307
308
 
# File 'lib/baidu/aip/client.rb', line 304

def image_search_same_add(image_in_base64, brief)
  aip = ImageSearch::SameAdd.new({image: image_in_base64, brief: brief})
  aip.client = self
  aip.process
end

#image_search_same_delete(image_in_base64) ⇒ Object 



316
317
318
319
320
 
# File 'lib/baidu/aip/client.rb', line 316

def image_search_same_delete(image_in_base64)
  aip = ImageSearch::SameDelete.new({image: image_in_base64})
  aip.client = self
  aip.process
end

#image_search_similar(image_in_base64) ⇒ Object 



328
329
330
331
332
 
# File 'lib/baidu/aip/client.rb', line 328

def image_search_similar(image_in_base64)
  aip = ImageSearch::Similar.new({image: image_in_base64})
  aip.client = self
  aip.process
end

#image_search_similar_add(image_in_base64, brief) ⇒ Object 



322
323
324
325
326
 
# File 'lib/baidu/aip/client.rb', line 322

def image_search_similar_add(image_in_base64, brief)
  aip = ImageSearch::SimilarAdd.new({image: image_in_base64, brief: brief})
  aip.client = self
  aip.process
end

#image_search_similar_delete(image_in_base64) ⇒ Object 



334
335
336
337
338
 
# File 'lib/baidu/aip/client.rb', line 334

def image_search_similar_delete(image_in_base64)
  aip = ImageSearch::SimilarDelete.new({image: image_in_base64})
  aip.client = self
  aip.process
end

#knowledge_graph_task_create(name, template_content, input_mapping_file, output_file, ulr_pattern, options = {}) ⇒ Object

knowledge_graph



341
342
343
344
345
 
# File 'lib/baidu/aip/client.rb', line 341

def knowledge_graph_task_create(name, template_content, input_mapping_file, output_file, ulr_pattern, options = {})
  aip = KnowledgeGraph::TaskCreate.new options.merge({name: name, template_content: template_content, input_mapping_file: input_mapping_file, output_file: output_file})
  aip.client = self
  aip.process
end

#knowledge_graph_task_info(id, options = {}) ⇒ Object 



347
348
349
350
351
 
# File 'lib/baidu/aip/client.rb', line 347

def knowledge_graph_task_info(id, options = {})
  aip = KnowledgeGraph::TaskInfo.new options.merge({id: id})
  aip.client = self
  aip.process
end

#knowledge_graph_task_query(options = {}) ⇒ Object 



353
354
355
356
357
 
# File 'lib/baidu/aip/client.rb', line 353

def knowledge_graph_task_query(options = {})
  aip = KnowledgeGraph::TaskQuery.new(options)
  aip.client = self
  aip.process
end

#knowledge_graph_task_start(id, options = {}) ⇒ Object 



365
366
367
368
369
 
# File 'lib/baidu/aip/client.rb', line 365

def knowledge_graph_task_start(id, options = {})
  aip = KnowledgeGraph::TaskStart.new options.merge({id: id})
  aip.client = self
  aip.process
end

#knowledge_graph_task_status(id, options = {}) ⇒ Object 



359
360
361
362
363
 
# File 'lib/baidu/aip/client.rb', line 359

def knowledge_graph_task_status(id, options = {})
  aip = KnowledgeGraph::TaskStatus.new options.merge({id: id})
  aip.client = self
  aip.process
end

#knowledge_graph_task_update(id, options = {}) ⇒ Object 



371
372
373
374
375
 
# File 'lib/baidu/aip/client.rb', line 371

def knowledge_graph_task_update(id, options = {})
  aip = KnowledgeGraph::TaskUpdate.new options.merge({id: id})
  aip.client = self
  aip.process
end

#nlp_comment_tag(text, options = {}) ⇒ Object

nlp



378
379
380
381
382
 
# File 'lib/baidu/aip/client.rb', line 378

def nlp_comment_tag(text, options = {})
  aip = Nlp::CommentTag.new options.merge({text: text})
  aip.client = self
  aip.process
end

#nlp_dep_parser(text, options = {}) ⇒ Object 



384
385
386
387
388
 
# File 'lib/baidu/aip/client.rb', line 384

def nlp_dep_parser(text, options = {})
  aip = Nlp::DepParser.new options.merge({text: text})
  aip.client = self
  aip.process
end

#nlp_dnnlm_cn(text, options = {}) ⇒ Object 



390
391
392
393
394
 
# File 'lib/baidu/aip/client.rb', line 390

def nlp_dnnlm_cn(text, options = {})
  aip = Nlp::DnnlmCn.new options.merge({text: text})
  aip.client = self
  aip.process
end

#nlp_keyword(title, content, options = {}) ⇒ Object 



396
397
398
399
400
 
# File 'lib/baidu/aip/client.rb', line 396

def nlp_keyword(title, content, options = {})
  aip = Nlp::Keyword.new options.merge({title: title, content: content})
  aip.client = self
  aip.process
end

#nlp_lexer(text, options = {}) ⇒ Object 



408
409
410
411
412
 
# File 'lib/baidu/aip/client.rb', line 408

def nlp_lexer(text, options = {})
  aip = Nlp::Lexer.new options.merge({text: text})
  aip.client = self
  aip.process
end

#nlp_lexer_custom(text, options = {}) ⇒ Object 



402
403
404
405
406
 
# File 'lib/baidu/aip/client.rb', line 402

def nlp_lexer_custom(text, options = {})
  aip = Nlp::LexerCustom.new options.merge({text: text})
  aip.client = self
  aip.process
end

#nlp_sentiment_classify(text, options = {}) ⇒ Object 



414
415
416
417
418
 
# File 'lib/baidu/aip/client.rb', line 414

def nlp_sentiment_classify(text, options={})
  aip = Nlp::SentimentClassify.new options.merge({text: text})
  aip.client = self
  aip.process
end

#nlp_simnet(text1, text2, options = {}) ⇒ Object 



420
421
422
423
424
 
# File 'lib/baidu/aip/client.rb', line 420

def nlp_simnet(text1, text2, options = {})
  aip = Nlp::Simnet.new options.merge({text_1:text1, text_2: text2})
  aip.client = self
  aip.process
end

#nlp_word_embedding(word, options = {}) ⇒ Object 



426
427
428
429
430
 
# File 'lib/baidu/aip/client.rb', line 426

def nlp_word_embedding(word, options = {})
  aip = Nlp::WordEmbedding.new options.merge({word: word})
  aip.client = self
  aip.process
end

#nlp_word_sim_embedding(word1, word2, options = {}) ⇒ Object 



432
433
434
435
436
 
# File 'lib/baidu/aip/client.rb', line 432

def nlp_word_sim_embedding(word1, word2, options = {})
  aip = Nlp::WordSimEmbedding.new options.merge({word_1: word1, word_2: word2})
  aip.client = self
  aip.process
end

#ocr_accurate(image_in_base64, options = {}) ⇒ Object 



445
446
447
448
449
 
# File 'lib/baidu/aip/client.rb', line 445

def ocr_accurate(image_in_base64, options = {})
  aip = Ocr::Accurate.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#ocr_accurate_basic(image_in_base64, options = {}) ⇒ Object

Ocr



439
440
441
442
443
 
# File 'lib/baidu/aip/client.rb', line 439

def ocr_accurate_basic(image_in_base64, options = {})
  aip = Ocr::AccurateBasic.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#ocr_bankcard(image_in_base64, options = {}) ⇒ Object 



451
452
453
454
455
 
# File 'lib/baidu/aip/client.rb', line 451

def ocr_bankcard(image_in_base64, options = {})
  aip = Ocr::Bankcard.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#ocr_business_license(image_in_base64, options = {}) ⇒ Object 



457
458
459
460
461
 
# File 'lib/baidu/aip/client.rb', line 457

def ocr_business_license(image_in_base64, options = {})
  aip = Ocr::BusinessLicense.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#ocr_custom(image_in_base64, template_sign, options = {}) ⇒ Object 



463
464
465
466
467
 
# File 'lib/baidu/aip/client.rb', line 463

def ocr_custom(image_in_base64, template_sign, options = {})
  aip = Ocr::Custom.new options.merge({image: image_in_base64, templateSign: template_sign})
  aip.client = self
  aip.process
end

#ocr_driving_license(image_in_base64, options = {}) ⇒ Object 



469
470
471
472
473
 
# File 'lib/baidu/aip/client.rb', line 469

def ocr_driving_license(image_in_base64, options = {})
  aip = Ocr::DrivingLicense.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#ocr_form_result_get(request_id, options = {}) ⇒ Object

todo def ocr_form_recognize(image_in_base64, options = {})

aip = Ocr::FormRecognize.new options.merge({image: image_in_base64})
aip.client = self
aip.process

end



482
483
484
485
486
 
# File 'lib/baidu/aip/client.rb', line 482

def ocr_form_result_get(request_id, options = {})
  aip = Ocr::FormResultGet.new options.merge({request_id: request_id})
  aip.client = self
  aip.process
end

#ocr_general(image_in_base64, options = {}) ⇒ Object 



500
501
502
503
504
 
# File 'lib/baidu/aip/client.rb', line 500

def ocr_general(image_in_base64, options = {})
  aip = Ocr::General.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#ocr_general_basic(image_in_base64, options = {}) ⇒ Object 



488
489
490
491
492
 
# File 'lib/baidu/aip/client.rb', line 488

def ocr_general_basic(image_in_base64, options = {})
  aip = Ocr::GeneralBasic.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#ocr_genral_enhanced(image_in_base64, options = {}) ⇒ Object 



494
495
496
497
498
 
# File 'lib/baidu/aip/client.rb', line 494

def ocr_genral_enhanced(image_in_base64, options = {})
  aip = Ocr::GeneralEnhanced.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#ocr_idcard(image_in_base64, idcard_side, options = {}) ⇒ Object 



506
507
508
509
510
 
# File 'lib/baidu/aip/client.rb', line 506

def ocr_idcard(image_in_base64, idcard_side, options = {})
  aip = Ocr::Idcard.new options.merge({image: image_in_base64, id_card_side: idcard_side})
  aip.client = self
  aip.process
end

#ocr_license_plate(image_in_base64, options = {}) ⇒ Object 



512
513
514
515
516
 
# File 'lib/baidu/aip/client.rb', line 512

def ocr_license_plate(image_in_base64, options = {})
  aip = Ocr::LicensePlate.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#ocr_receipt(image_in_base64, options = {}) ⇒ Object 



518
519
520
521
522
 
# File 'lib/baidu/aip/client.rb', line 518

def ocr_receipt(image_in_base64, options = {})
  aip = Ocr::Receipt.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#ocr_vehicle_license(image_in_base64, options = {}) ⇒ Object 



524
525
526
527
528
 
# File 'lib/baidu/aip/client.rb', line 524

def ocr_vehicle_license(image_in_base64, options = {})
  aip = Ocr::VehicleLicense.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end

#ocr_web_image(image_in_base64, options = {}) ⇒ Object 



530
531
532
533
534
 
# File 'lib/baidu/aip/client.rb', line 530

def ocr_web_image(image_in_base64, options = {})
  aip = Ocr::WebImage.new options.merge({image: image_in_base64})
  aip.client = self
  aip.process
end