Blog Pengembangan

2022.09.06

Menggunakan DeepL Translator dari Python (Bagian 2)

Dalam artikel ini, kami akan memperkenalkan bagian kedua dari cara menggunakan API DeepL Translator, yaitu penerjemahan file. (Bagian 1 dapat dilihat di sini)
※Diasumsikan Anda memiliki pengetahuan dasar tentang Python dan Linux.

Terjemahan file teks

Setelah pemanasan selesai, mari kita coba melakukan penerjemahan file.
Ini memerlukan kombinasi dari tiga panggilan API.
Siapkan file teks test.txt yang berisi teks bahasa Jepang yang sesuai.
Kita akan merancang mekanisme untuk menerjemahkannya ke bahasa Inggris (AS) dan menyimpannya sebagai test.trans.txt.

Langkah 1: Unggah file bahasa sumber

Saat mengirim permintaan terjemahan ke server DeepL, tentukan file bahasa sumber.

 $ curl https://api.deepl.com/v2/document \

 $ -F file=@test.txt \

 $ -F auth_key=${auth_key} \

 $ -F target_lang=en-us

document_id dan document_key dari file yang permintaannya telah diterima
akan dikembalikan dari server dalam format json.
Proses hingga pengiriman jika ditulis dalam Python adalah sebagai berikut:

 url = 'https://api.deepl.com/v2/document'

 files = dict()

 files['file'] = open(fn, 'rb')

 files['auth_key'] = (None, get_key())

 files['target_lang'] = (None, 'en-us')

 res = requests.post(url, files=files)

Penentuan auth_key dan target_lang cukup rumit, ya.
Ada beberapa cara untuk menentukan item files, dan jika menggunakan tuple 2 item,
item pertama adalah nama file, dan item kedua adalah objek.
Jika Anda menentukan string, penulisannya akan seperti ini.
Sebagai cara lain, auth_key dan target_lang dapat
disimpan di bagian data (format dict) seperti pada penerjemahan string pertama,
dan ada juga cara untuk meneruskan data dan files ke requests.post() secara bersamaan.

Langkah 2: Mendapatkan status proses terjemahan

Tanyakan status penerjemahan file yang sedang diproses:

 $ document_id=[documentID]

 $ document_key=[documentKey]

 $ curl https://api.deepl.com/v2/document/${document_id} \

 $ -d auth_key=${auth_key} \

 $ -d document_key=${document_key}

Ada empat status: queued (diterima), translating (sedang diterjemahkan),
error (terjadi kesalahan terjemahan), dan done (penerjemahan selesai).
Jika statusnya translating, perkiraan sisa waktu pemrosesan juga akan dikembalikan.
Dengan asumsi variabel document_id dan document_key telah diisi,
proses hingga pengiriman jika ditulis dalam Python adalah sebagai berikut:

 url = f'https://api.deepl.com/v2/document/{document_id}'

 data = dict()

 data['auth_key'] = get_key()

 data['document_key'] = document_key

 res = requests.post(url, data=data)

Langkah 3: Unduh file bahasa tujuan

Setelah status penerjemahan menjadi done, unduh filenya:

  $ curl https://api.deepl.com/v2/document/${document_id}/result \

 $ -d auth_key=${auth_key} \

 $ -d document_key=${document_key} > test.trans.txt

Unduhan hanya dilakukan satu kali.
Hasil terjemahan dialihkan (disimpan) ke test.trans.txt.
Proses hingga pengiriman jika ditulis dalam Python adalah sebagai berikut:

 url = f'https://api.deepl.com/v2/document/{document_id}/result'

 data = dict()

 data['auth_key'] = get_key()

 data['document_key'] = document_key

 res = requests.post(url, data=data)

Proses terjemahan file

Terakhir, hubungkan proses-proses di atas.
Karena langkah 2 hanya mengembalikan status kemajuan terjemahan,
diperlukan proses tunggu setelah menerima hasilnya. Pada dasarnya:
・Jika translating , lakukan sleep selama seconds_remaining detik
untuk sisa waktu tersebut, lalu periksa kembali status kemajuannya.
・Jika muncul done atau error , keluar dari loop.
Proses di atas jika ditulis dalam Python adalah sebagai berikut:

 import requests

 import json

 from time import sleep

def get_key():
return open('key.txt').read().rstrip()

def upload_src(fn):
'''
Langkah 1 penerjemahan file: Mengunggah file bahasa sumber
'''
url = 'https://api.deepl.com/v2/document'
files = dict()
files['file'] = open(fn, 'rb')
files['auth_key'] = (None, get_key())
files['target_lang'] = (None, 'en-us')

res = requests.post(url, files=files)
res_status = res.status_code # 200 jika berhasil (tidak digunakan saat ini)
res_text = res.text
res_data = json.loads(res_text)
document_id = res_data['document_id']
document_key = res_data['document_key']
return document_id, document_key

def get_trans_status(document_id, document_key):
'''
Sub-langkah 2: Mendapatkan status pemrosesan terjemahan
'''
url = f'https://api.deepl.com/v2/document/{document_id}'
data = dict()
data['auth_key'] = get_key()
data['document_key'] = document_key

res = requests.post(url, data=data)
res_status = res.status_code # 200 jika berhasil (tidak digunakan saat ini)
res_text = res.text
res_data = json.loads(res_text)
return res_data

def check_proceeding(document_id, document_key):
    ”’
    Langkah penerjemahan file 2: Menunggu proses penerjemahan
    ”’
    while True:
        res = get_trans_status(document_id, document_key)
        status = res[‘status’]
        print(f’status: {status}’, flush=True)
        seconds_remaining = 0
        if status == ‘done’ or status == ‘error’:
            break
        elif status == ‘translating’:
            if ‘seconds_remaining’ in res:
                seconds_remaining = int(res[‘seconds_remaining’])
                # Menghindari error
                if seconds_remaining <= 0:
                    seconds_remaining = 10
        else: # seperti queued
            pass
        print(f’…waiting for (another) {seconds_remaining}s’, flush=True)
        sleep(seconds_remaining)
    return status

def download_tgt(fn, document_id, document_key):
    ”’
    Langkah penerjemahan file 3: Mengunduh file bahasa target
    ”’
    url = f’https://api.deepl.com/v2/document/{document_id}/result’
    data = dict()
    data[‘auth_key’] = get_key()
    data[‘document_key’] = document_key

    res = requests.post(url, data=data)
    res_status = res.status_code # 200 jika berhasil (saat ini tidak digunakan)
    tgt_bin = res._content
    with open(fn, ‘w’, encoding=’utf-8′) as f:
        print(tgt_bin.decode(‘utf-8’), end=”, file=f)

def main():
fn_src = ‘test.txt’
fn_tgt = fn_src.replace(‘.txt’, ‘.trans.txt’)

print(f’fn_src: {fn_src}’)
print(f’fn_tgt: {fn_tgt}’)

print(f'mengunggah: {fn_src}')
document_id, document_key = upload_src(fn_src)
status = check_proceeding(document_id, document_key)
if status == 'done':
print(f'mengunduh: {fn_tgt}')
download_tgt(fn_tgt, document_id, document_key)

if __name__ == '__main__':
main()

Ketiga jenis panggilan API tersebut memiliki proses yang serupa, namun
demi tema "menulis perintah curl dalam Python",
saya sengaja tidak meringkasnya dan menulisnya secara redundan.

Demikian, dalam artikel ini:

・Menerjemahkan file menggunakan API DeepL.
・Membuat program dengan merepresentasikan konten perintah curl dalam Python.

Terima kasih telah membaca.