API ແປ PDF ແອັດສະປາຍ ຫາ ຫວຽດນາມ: ການເຊື່ອມໂຍງ ໄວ & ງ່າຍ

ເຫດຜົນທີ່ການແປ PDF ແບບໂປຣແກຣມເປັນສິ່ງທ້າທາຍທີ່ສຳຄັນ

ນັກພັດທະນາມັກຈະປະເຊີນກັບອຸປະສັກທີ່ສຳຄັນເມື່ອພະຍາຍາມແປເອກະສານ PDF ດ້ວຍໂປຣແກຣມ, ໂດຍສະເພາະລະຫວ່າງພາສາຕ່າງໆ ເຊັ່ນ ແອັດສະປາຍ ແລະ ຫວຽດນາມ.
ບັນຫາຫຼັກແມ່ນວ່າ PDF ບໍ່ແມ່ນໄຟລ໌ຂໍ້ຄວາມທຳມະດາ; ມັນເປັນຮູບແບບທີ່ຊັບຊ້ອນ, ມີການຈັດວາງທີ່ຄົງທີ່ທີ່ອອກແບບມາສໍາລັບການນໍາສະເຫນີ, ບໍ່ແມ່ນການດັດແກ້.
ຄວາມສັບສົນນີ້ເຮັດໃຫ້ເກີດຄວາມຫຍຸ້ງຍາກຫຼາຍຂັ້ນຕອນທີ່ສາມາດເຮັດໃຫ້ຂະບວນການແປແບບອັດຕະໂນມັດຕົກລາງໄດ້ຢ່າງວ່ອງໄວ.

ສິ່ງທ້າທາຍຕົ້ນຕໍແມ່ນການຮັກສາຮູບແບບຕົ້ນສະບັບຂອງເອກະສານແລະການຈັດຮູບແບບໃນລະຫວ່າງຂະບວນການແປ.
PDFs ປະກອບດ້ວຍການຈັດຕໍາແໜ່ງທີ່ຊັດເຈນສໍາລັບຂໍ້ຄວາມ, ຮູບພາບ, ຖັນ, ຫົວຂໍ້, ແລະທ້າຍໜ້າ, ເຊິ່ງທັງຫມົດຕ້ອງໄດ້ຮັບການຮັກສາໄວ້.
ການສະກັດເອົາຂໍ້ຄວາມເພື່ອແປ ແລະຫຼັງຈາກນັ້ນນໍາເອົາຂໍ້ຄວາມທີ່ແປແລ້ວ, ເຊິ່ງມັກຈະຍາວກວ່າ, ກັບມາໃສ່ຄືນໂດຍບໍ່ທໍາລາຍໂຄງສ້າງສາຍຕາແມ່ນເປັນວຽກງານດ້ານເຕັກນິກທີ່ໃຫຍ່ຫຼວງ.
ຖ້າບໍ່ມີເຄື່ອງມືສະເພາະ, ເອກະສານທີ່ໄດ້ຮັບອາດຈະກາຍເປັນຄວາມວຸ້ນວາຍຂອງຂໍ້ຄວາມທີ່ຊ້ອນກັນ ແລະອົງປະກອບທີ່ວາງຜິດບ່ອນ.

ຍິ່ງໄປກວ່ານັ້ນ, ການຈັດການກັບອົງປະກອບທີ່ຝັງໄວ້ເຊັ່ນ: ຕາຕະລາງ, ຕາຕະລາງສະແດງ, ແລະກາຟ ເພີ່ມຄວາມສັບສົນອີກຊັ້ນໜຶ່ງ.
ອົງປະກອບເຫຼົ່ານີ້ຕ້ອງໄດ້ຮັບການລະບຸ, ເນື້ອໃນຂໍ້ຄວາມຂອງພວກມັນຖືກແປ, ແລະຫຼັງຈາກນັ້ນພວກມັນຕ້ອງໄດ້ຮັບການສ້າງຄືນໃຫມ່ຢ່າງສົມບູນໃນເອກະສານເປົ້າຫມາຍ.
ການເຂົ້າລະຫັດຕົວອັກສອນກໍ່ເປັນບັນຫາທີ່ສໍາຄັນ, ໂດຍສະເພາະໃນເວລາທີ່ຈັດການກັບເຄື່ອງໝາຍສຽງຂອງ ແອັດສະປາຍ (ເຊັ່ນ: ñ, á, é) ແລະເຄື່ອງໝາຍສຽງທີ່ຊັບຊ້ອນຂອງ ຫວຽດນາມ (ເຊັ່ນ: ă, ê, ô, ư).
ການຈັດການການເຂົ້າລະຫັດບໍ່ຖືກຕ້ອງສາມາດນໍາໄປສູ່ຂໍ້ຄວາມທີ່ເສຍຫາຍ, ເຮັດໃຫ້ເອກະສານສຸດທ້າຍບໍ່ສາມາດອ່ານໄດ້ຢ່າງສົມບູນແລະບໍ່ເປັນມືອາຊີບ.

ແນະນໍາ Doctranslate API: ວິທີແກ້ໄຂອັນດັບທໍາອິດຂອງນັກພັດທະນາ

Doctranslate API ສະຫນອງການແກ້ໄຂທີ່ເຂັ້ມແຂງແລະສະຫງ່າງາມຕໍ່ສິ່ງທ້າທາຍເຫຼົ່ານີ້, ສະເຫນີເຄື່ອງມືທີ່ມີປະສິດທິພາບສໍາລັບການແປເອກະສານທີ່ມີຄວາມຖືກຕ້ອງສູງ.
ສ້າງເປັນ RESTful API, ມັນອະນຸຍາດໃຫ້ນັກພັດທະນາສາມາດລວມເອົາຄວາມສາມາດໃນການແປ PDF ແອັດສະປາຍ ເປັນ ຫວຽດນາມ ເຂົ້າໃນແອັບພລິເຄຊັນໃດກໍໄດ້ຢ່າງງ່າຍດາຍ.
API ດຶງເອົາຄວາມສັບສົນຂອງການແຍກໄຟລ໌, ການສ້າງຮູບແບບຄືນໃໝ່, ແລະການເຂົ້າລະຫັດຕົວອັກສອນອອກ, ໃຫ້ປະສົບການທີ່ບໍ່ມີຮອຍຕໍ່.

ໂດຍຫຼັກແລ້ວ, Doctranslate API ຖືກອອກແບບມາສໍາລັບຈຸດປະສົງຕົ້ນຕໍອັນດຽວຄື: ເພື່ອຮັກສາໂຄງສ້າງຂອງເອກະສານຕົ້ນສະບັບດ້ວຍຄວາມຖືກຕ້ອງທີ່ບໍ່ມີໃຜທຽບເທົ່າ.
ນີ້ຫມາຍຄວາມວ່າຮູບແບບ, ຕາຕະລາງ, ຕົວອັກສອນ, ແລະຮູບພາບຕົ້ນສະບັບທັງຫມົດຂອງທ່ານຖືກຮັກສາໄວ້ຢ່າງລະມັດລະວັງໃນໄຟລ໌ PDF ຫວຽດນາມ ທີ່ແປແລ້ວສຸດທ້າຍ.
ຂັ້ນຕອນການເຮັດວຽກແມ່ນໄດ້ຖືກປັບປຸງໃຫ້ເປັນຂະບວນການທີ່ງ່າຍດາຍ, ບໍ່ພ້ອມກັນ: ອັບໂຫລດເອກະສານຕົ້ນສະບັບຂອງທ່ານ, ເລີ່ມຕົ້ນການແປ, ແລະດາວໂຫລດໄຟລ໌ທີ່ສໍາເລັດ.
ວິທີການທີ່ບໍ່ມີການສະກັດກັ້ນນີ້ແມ່ນດີເລີດສໍາລັບການຈັດການໄຟລ໌ຂະຫນາດໃຫຍ່ຫຼືການປະມວນຜົນເປັນຊຸດໂດຍບໍ່ໄດ້ຜູກມັດຊັບພະຍາກອນຂອງແອັບພລິເຄຊັນຂອງທ່ານ.

ການໂຕ້ຕອບກັບ API ແມ່ນຖືກຈັດການໂດຍຜ່ານຄໍາຮ້ອງຂໍ HTTP ມາດຕະຖານ, ໂດຍມີການຕອບສະຫນອງທີ່ຖືກສົ່ງໃນຮູບແບບ JSON ທີ່ສະອາດ.
ອັນນີ້ເຮັດໃຫ້ການເຊື່ອມໂຍງງ່າຍດາຍສໍາລັບພາສາການຂຽນໂປຣແກຣມທີ່ທັນສະໄຫມໃດໆ, ຕັ້ງແຕ່ Python ແລະ Node.js ເຖິງ Java ແລະ C#.
ນັກພັດທະນາສາມາດສຸມໃສ່ເຫດຜົນຫຼັກຂອງແອັບພລິເຄຊັນຂອງພວກເຂົາ ແທນທີ່ຈະຈົມຢູ່ກັບລາຍລະອຽດທີ່ສັບສົນຂອງການຈັດການ PDF.
ການອອກແບບທີ່ເນັ້ນນັກພັດທະນານີ້ຮັບປະກັນຂະບວນການເຊື່ອມໂຍງທີ່ວ່ອງໄວ, ປະຢັດເວລາແລະຊັບພະຍາກອນທີ່ມີຄ່າ.

ຄູ່ມືຂັ້ນຕອນຕໍ່ຂັ້ນຕອນ: ການເຊື່ອມໂຍງ API ສໍາລັບການແປ PDF ຈາກ ແອັດສະປາຍ ເປັນ ຫວຽດນາມ

ຄູ່ມືນີ້ສະຫນອງການຍ່າງຜ່ານທີ່ສົມບູນແບບສໍາລັບການເຊື່ອມໂຍງ Doctranslate API ເພື່ອແປໄຟລ໌ PDF ຈາກ ແອັດສະປາຍ ເປັນ ຫວຽດນາມ.
ພວກເຮົາຈະກວມເອົາທຸກຢ່າງຕັ້ງແຕ່ການຕັ້ງຄ່າສະພາບແວດລ້ອມຂອງທ່ານແລະການຢັ້ງຢືນຈົນເຖິງການອັບໂຫລດໄຟລ໌ແລະການດາວໂຫລດການແປສຸດທ້າຍ.
ການປະຕິບັດຕາມຂັ້ນຕອນເຫຼົ່ານີ້ຈະຊ່ວຍໃຫ້ທ່ານສ້າງຂະບວນການແປທີ່ມີປະສິດທິພາບ, ອັດຕະໂນມັດພາຍໃນແອັບພລິເຄຊັນຂອງທ່ານເອງ.

ການຕັ້ງຄ່າສະພາບແວດລ້ອມຂອງທ່ານ

ກ່ອນທີ່ຈະເຮັດການຮຽກຮ້ອງ API ໃດໆ, ທ່ານຈໍາເປັນຕ້ອງຮັບປະກັນວ່າສະພາບແວດລ້ອມການພັດທະນາຂອງທ່ານຖືກກະກຽມເພື່ອຈັດການຄໍາຮ້ອງຂໍ HTTP ແລະການອັບໂຫລດໄຟລ໌ແບບ multipart.
ສໍາລັບນັກພັດທະນາ Python, ຫ້ອງສະໝຸດ `requests` ແມ່ນທາງເລືອກມາດຕະຖານສໍາລັບຄວາມງ່າຍດາຍແລະພະລັງງານໃນການຈັດການການສື່ສານ HTTP.
ທ່ານສາມາດຕິດຕັ້ງມັນໄດ້ງ່າຍໂດຍໃຊ້ pip: `pip install requests`.
ສໍາລັບນັກພັດທະນາ Node.js, `axios` ແມ່ນລູກຄ້າ HTTP ທີ່ອີງໃສ່ຄໍາໝັ້ນສັນຍາທີ່ນິຍົມ, ແລະ `form-data` ແມ່ນຈໍາເປັນສໍາລັບການສ້າງຄໍາຮ້ອງຂໍການອັບໂຫລດໄຟລ໌.
ສິ່ງເຫຼົ່ານີ້ສາມາດຕິດຕັ້ງໄດ້ຜ່ານ npm: `npm install axios form-data`.

ການຢັ້ງຢືນ: ການເອົາລະຫັດ API ຂອງທ່ານ

ການຮ້ອງຂໍທັງຫມົດຕໍ່ Doctranslate API ຕ້ອງໄດ້ຮັບການຢັ້ງຢືນໂດຍໃຊ້ລະຫັດ API ທີ່ເປັນເອກະລັກ.
ລະຫັດນີ້ຮັບປະກັນວ່າຄໍາຮ້ອງຂໍຂອງທ່ານມີຄວາມປອດໄພແລະຖືກເຊື່ອມໂຍງຢ່າງຖືກຕ້ອງກັບບັນຊີຂອງທ່ານ.
ເພື່ອໃຫ້ໄດ້ລະຫັດຂອງທ່ານ, ທ່ານຈະຕ້ອງລົງທະບຽນຢູ່ໃນພອດທັລນັກພັດທະນາ Doctranslate ແລະສ້າງແອັບພລິເຄຊັນໃຫມ່.
ເມື່ອສ້າງແລ້ວ, ລະຫັດ API ຂອງທ່ານຈະມີຢູ່ໃນ dashboard ບັນຊີຂອງທ່ານ.
ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະຮັກສາລະຫັດນີ້ເປັນຄວາມລັບແລະເກັບຮັກສາມັນໄວ້ຢ່າງປອດໄພ, ຕົວຢ່າງ, ເປັນຕົວແປສະພາບແວດລ້ອມ, ແທນທີ່ຈະ hardcoding ມັນໂດຍກົງໃນລະຫັດແຫຼ່ງຂອງທ່ານ.

ຂັ້ນຕອນທີ 1: ການອັບໂຫລດ PDF ແອັດສະປາຍ ຂອງທ່ານ

ຂັ້ນຕອນທໍາອິດໃນຂະບວນການແປແມ່ນການອັບໂຫລດເອກະສານ PDF ແອັດສະປາຍ ຕົ້ນສະບັບຂອງທ່ານໄປຍັງເຊີບເວີ Doctranslate.
ອັນນີ້ແມ່ນເຮັດໄດ້ໂດຍການສົ່ງຄໍາຮ້ອງຂໍ `POST` ໄປຫາ endpoint `/v2/document/upload`.
ຄໍາຮ້ອງຂໍຕ້ອງຖືກຈັດຮູບແບບເປັນ `multipart/form-data` ແລະປະກອບມີໄຟລ໌ຕົວມັນເອງພາຍໃຕ້ parameter `file`.
ການອັບໂຫລດທີ່ສໍາເລັດຈະສົ່ງຄືນການຕອບສະຫນອງ JSON ທີ່ມີ `document_id` ທີ່ເປັນເອກະລັກ, ເຊິ່ງທ່ານຈະໃຊ້ໃນຂັ້ນຕອນຕໍ່ໄປ.

ຂັ້ນຕອນທີ 2: ການເລີ່ມຕົ້ນການແປເປັນ ຫວຽດນາມ

ເມື່ອທ່ານມີ `document_id`, ທ່ານສາມາດເລີ່ມຕົ້ນຂະບວນການແປໄດ້.
ທ່ານຈະສົ່ງຄໍາຮ້ອງຂໍ `POST` ໄປຫາ endpoint `/v2/translate/document` ດ້ວຍ payload JSON.
payload ນີ້ຕ້ອງປະກອບມີ `document_id` ຈາກຂັ້ນຕອນກ່ອນຫນ້າ, `source_lang` ຖືກຕັ້ງເປັນ `es` ສໍາລັບ ແອັດສະປາຍ, ແລະ `target_lang` ຖືກຕັ້ງເປັນ `vi` ສໍາລັບ ຫວຽດນາມ.
ຫຼັງຈາກນັ້ນ, API ຈະສົ່ງຄືນ `translation_id`, ເຊິ່ງເຮັດຫນ້າທີ່ເປັນຕົວລະບຸທີ່ເປັນເອກະລັກສໍາລັບວຽກງານການແປສະເພາະນີ້.

ຂັ້ນຕອນທີ 3: ການກວດສອບສະຖານະການແປ

ການແປເອກະສານແມ່ນການດໍາເນີນງານທີ່ບໍ່ພ້ອມກັນ, ຊຶ່ງຫມາຍຄວາມວ່າມັນແລ່ນຢູ່ໃນພື້ນຫຼັງ.
ທ່ານຈະຕ້ອງກວດສອບສະຖານະຂອງວຽກງານເປັນໄລຍະຈົນກວ່າຈະສໍາເລັດ.
ອັນນີ້ແມ່ນບັນລຸໄດ້ໂດຍການເຮັດຄໍາຮ້ອງຂໍ `GET` ໄປຫາ endpoint `/v2/translate/document/status`, ລວມທັງ `translation_id` ເປັນ query parameter.
API ຈະຕອບສະຫນອງກັບສະຖານະປະຈຸບັນ, ເຊິ່ງສາມາດເປັນ `processing` (ກໍາລັງປະມວນຜົນ), `done` (ສໍາເລັດ), ຫຼື `error` (ຜິດພາດ).
ທ່ານຄວນສອບຖາມ endpoint ນີ້ໃນໄລຍະຫ່າງທີ່ສົມເຫດສົມຜົນຈົນກ່ວາສະຖານະປ່ຽນເປັນ `done`.

ຂັ້ນຕອນທີ 4: ການດາວໂຫລດ PDF ທີ່ແປແລ້ວ

ເມື່ອສະຖານະເປັນ `done`, PDF ຫວຽດນາມ ທີ່ແປແລ້ວສຸດທ້າຍແມ່ນພ້ອມໃຫ້ດາວໂຫລດ.
ທ່ານສາມາດດຶງເອົາໄຟລ໌ໄດ້ໂດຍການເຮັດຄໍາຮ້ອງຂໍ `GET` ໄປຫາ endpoint `/v2/translate/document/download`, ອີກເທື່ອຫນຶ່ງໂດຍໃຊ້ `translation_id` ເປັນ query parameter.
ການຕອບສະຫນອງຂອງ API ຈະເປັນຂໍ້ມູນຖານສອງຂອງໄຟລ໌ PDF ທີ່ຖືກແປ.
ລະຫັດແອັບພລິເຄຊັນຂອງທ່ານຄວນຈະຖືກກະກຽມເພື່ອຈັດການສາຍຖານສອງນີ້ແລະບັນທຶກມັນໄວ້ໃນໄຟລ໌ `.pdf` ໃຫມ່. ພະລັງງານທີ່ແທ້ຈິງຂອງ API ນີ້ແມ່ນຄວາມສາມາດໃນການປະມວນຜົນເອກະສານທີ່ສັບສົນໄດ້ຢ່າງຫນ້າເຊື່ອຖື. ສໍາລັບນັກພັດທະນາທີ່ຕ້ອງການການແກ້ໄຂເພື່ອ ແປເອກະສານໃນຂະນະທີ່ຮັກສາຮູບແບບແລະຕາຕະລາງ, Doctranslate API ສະຫນອງຂະບວນການເຮັດວຽກທີ່ອັດຕະໂນມັດຢ່າງເຕັມສ່ວນແລະມີປະສິດທິພາບສູງ.

ຕົວຢ່າງການເຊື່ອມໂຍງ Python

ນີ້ແມ່ນສະຄຣິບ Python ທີ່ສົມບູນແບບທີ່ສະແດງໃຫ້ເຫັນຂະບວນການສີ່ຂັ້ນຕອນທັງຫມົດ.
ຕົວຢ່າງນີ້ໃຊ້ຫ້ອງສະໝຸດ `requests` ເພື່ອຈັດການການສື່ສານ API ແລະ `time` ສໍາລັບການສອບຖາມສະຖານະ.
ໃຫ້ແນ່ໃຈວ່າປ່ຽນແທນ `’YOUR_API_KEY’` ດ້ວຍລະຫັດຕົວຈິງຂອງທ່ານ ແລະສະຫນອງເສັ້ນທາງທີ່ຖືກຕ້ອງໄປຫາໄຟລ໌ PDF ຕົ້ນສະບັບຂອງທ່ານ.

import requests
import time
import os

API_KEY = os.getenv('DOCTRANSLATE_API_KEY', 'YOUR_API_KEY')
API_URL = 'https://developer.doctranslate.io/v2'
FILE_PATH = 'path/to/your/document.pdf'

def translate_spanish_to_vietnamese_pdf(file_path):
    headers = {'Authorization': f'Bearer {API_KEY}'}

    # Step 1: Upload the document
    print("Step 1: Uploading document...")
    with open(file_path, 'rb') as f:
        files = {'file': (os.path.basename(file_path), f, 'application/pdf')}
        response = requests.post(f'{API_URL}/document/upload', headers=headers, files=files)

    if response.status_code != 200:
        print(f"Error uploading file: {response.text}")
        return

    document_id = response.json().get('document_id')
    print(f"Document uploaded successfully. Document ID: {document_id}")

    # Step 2: Initiate translation
    print("
Step 2: Initiating translation to Vietnamese...")
    payload = {
        'document_id': document_id,
        'source_lang': 'es',
        'target_lang': 'vi'
    }
    response = requests.post(f'{API_URL}/translate/document', headers=headers, json=payload)

    if response.status_code != 200:
        print(f"Error initiating translation: {response.text}")
        return

    translation_id = response.json().get('translation_id')
    print(f"Translation initiated. Translation ID: {translation_id}")

    # Step 3: Check translation status
    print("
Step 3: Checking translation status...")
    while True:
        status_response = requests.get(f'{API_URL}/translate/document/status?translation_id={translation_id}', headers=headers)
        status = status_response.json().get('status')
        print(f"Current status: {status}")
        if status == 'done':
            break
        elif status == 'error':
            print("Translation failed.")
            return
        time.sleep(5) # Poll every 5 seconds

    # Step 4: Download the translated document
    print("
Step 4: Downloading translated document...")
    download_response = requests.get(f'{API_URL}/translate/document/download?translation_id={translation_id}', headers=headers)

    if download_response.status_code == 200:
        translated_file_path = 'translated_document_vi.pdf'
        with open(translated_file_path, 'wb') as f:
            f.write(download_response.content)
        print(f"Translated document saved to {translated_file_path}")
    else:
        print(f"Error downloading file: {download_response.text}")

if __name__ == '__main__':
    if API_KEY == 'YOUR_API_KEY':
        print("Please set your DOCTRANSALTE_API_KEY.")
    elif not os.path.exists(FILE_PATH):
        print(f"File not found at: {FILE_PATH}")
    else:
        translate_spanish_to_vietnamese_pdf(FILE_PATH)

ຕົວຢ່າງການເຊື່ອມໂຍງ Node.js
ສໍາລັບນັກພັດທະນາ JavaScript, ນີ້ແມ່ນຕົວຢ່າງທີ່ທຽບເທົ່າໂດຍໃຊ້ Node.js ກັບ `axios` ແລະ `form-data`. 
ສະຄຣິບນີ້ປະຕິບັດຕາມເຫດຜົນການສອບຖາມແບບບໍ່ພ້ອມກັນດຽວກັນເພື່ອຈັດການຂະບວນການແປຢ່າງມີປະສິດທິພາບ. 
ຈື່ໄວ້ວ່າໃຫ້ຕັ້ງລະຫັດ API ແລະເສັ້ນທາງໄຟລ໌ຂອງທ່ານກ່ອນທີ່ຈະດໍາເນີນການສະຄຣິບ.
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const path = require('path');

const API_KEY = process.env.DOCTRANSLATE_API_KEY || 'YOUR_API_KEY';
const API_URL = 'https://developer.doctranslate.io/v2';
const FILE_PATH = 'path/to/your/document.pdf';

const headers = {
    'Authorization': `Bearer ${API_KEY}`,
};

const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

async function translatePdf() {
    if (API_KEY === 'YOUR_API_KEY') {
        console.error('Please set your DOCTRANSLATE_API_KEY.');
        return;
    }
    if (!fs.existsSync(FILE_PATH)) {
        console.error(`File not found at: ${FILE_PATH}`);
        return;
    }

    try {
        // Step 1: Upload the document
        console.log('Step 1: Uploading document...');
        const form = new FormData();
        form.append('file', fs.createReadStream(FILE_PATH));
        const uploadResponse = await axios.post(`${API_URL}/document/upload`, form, {
            headers: { ...headers, ...form.getHeaders() },
        });
        const { document_id } = uploadResponse.data;
        console.log(`Document uploaded successfully. Document ID: ${document_id}`);

        // Step 2: Initiate translation
        console.log('
Step 2: Initiating translation to Vietnamese...');
        const translatePayload = {
            document_id,
            source_lang: 'es',
            target_lang: 'vi',
        };
        const translateResponse = await axios.post(`${API_URL}/translate/document`, translatePayload, { headers });
        const { translation_id } = translateResponse.data;
        console.log(`Translation initiated. Translation ID: ${translation_id}`);

        // Step 3: Check translation status
        console.log('
Step 3: Checking translation status...');
        let status = '';
        while (status !== 'done') {
            const statusResponse = await axios.get(`${API_URL}/translate/document/status?translation_id=${translation_id}`, { headers });
            status = statusResponse.data.status;
            console.log(`Current status: ${status}`);
            if (status === 'error') {
                throw new Error('Translation failed.');
            }
            if (status !== 'done') {
                await sleep(5000); // Poll every 5 seconds
            }
        }

        // Step 4: Download the translated document
        console.log('
Step 4: Downloading translated document...');
        const downloadResponse = await axios.get(`${API_URL}/translate/document/download?translation_id=${translation_id}`, {
            headers,
            responseType: 'stream',
        });
        const translatedFilePath = 'translated_document_vi.pdf';
        const writer = fs.createWriteStream(translatedFilePath);
        downloadResponse.data.pipe(writer);

        return new Promise((resolve, reject) => {
            writer.on('finish', () => {
                console.log(`Translated document saved to ${translatedFilePath}`);
                resolve();
            });
            writer.on('error', reject);
        });

    } catch (error) {
        console.error('An error occurred:', error.response ? error.response.data : error.message);
    }
}

translatePdf();

ການພິຈາລະນາທີ່ສໍາຄັນສໍາລັບລັກສະນະສະເພາະຂອງພາສາຫວຽດນາມ
ການແປເນື້ອໃນເປັນ ຫວຽດນາມ ນໍາສະເຫນີສິ່ງທ້າທາຍທາງດ້ານພາສາສາດແລະເຕັກນິກທີ່ເປັນເອກະລັກທີ່ຕ້ອງໄດ້ຮັບການຈັດການຢ່າງຖືກຕ້ອງເພື່ອໃຫ້ໄດ້ຜົນທີ່ມີຄຸນນະພາບສູງ. 
Doctranslate API ຖືກອອກແບບມາໂດຍສະເພາະເພື່ອຈັດການຄວາມສັບສົນເຫຼົ່ານີ້, ຮັບປະກັນວ່າຜົນຜະລິດສຸດທ້າຍມີຄວາມຖືກຕ້ອງແລະເບິ່ງເຫັນໄດ້ຖືກຕ້ອງ. 
ນັກພັດທະນາຄວນຈະຮູ້ເຖິງບັນຫາເຫຼົ່ານີ້ເພື່ອຊື່ນຊົມກັບພະລັງງານພື້ນຖານຂອງເຄື່ອງມືການແປ.
ການຈັດການເຄື່ອງໝາຍສຽງແລະໂຕນ
ຫວຽດນາມ ເປັນພາສາໂຕນທີ່ໃຊ້ລະບົບເຄື່ອງໝາຍສຽງທີ່ຊັບຊ້ອນເພື່ອໝາຍເຖິງທັງສຽງສະຫຼະແລະໂຕນ. 
ຕົວອັກສອນດຽວສາມາດມີຫຼາຍເຄື່ອງໝາຍ, ເຊັ່ນ: ໃນຕົວອັກສອນ ‘ệ’ ຫຼື ‘ậ’. 
ລະບົບການແປມາດຕະຖານແລະເຄື່ອງມືສະແດງຕົວອັກສອນຈໍານວນຫຼາຍພະຍາຍາມປະມວນຜົນຕົວອັກສອນປະສົມເຫຼົ່ານີ້ຢ່າງຖືກຕ້ອງ. 
ເຄື່ອງມືການແປຂັ້ນສູງຂອງ Doctranslate API ແລະເຕັກໂນໂລຍີການສ້າງເອກະສານຄືນໃໝ່ແມ່ນໄດ້ຖືກປັບປຸງຢ່າງລະອຽດເພື່ອຈັດການກໍລະນີເຫຼົ່ານີ້, ຮັບປະກັນວ່າເຄື່ອງໝາຍສຽງທັງໝົດຖືກຮັກສາໄວ້ແລະສະແດງໄດ້ຢ່າງຖືກຕ້ອງໃນ PDF ສຸດທ້າຍ.
ການຮັບປະກັນການເຂົ້າລະຫັດ UTF-8
ການເຂົ້າລະຫັດຕົວອັກສອນທີ່ເໝາະສົມແມ່ນບໍ່ສາມາດຕໍ່ລອງໄດ້ສໍາລັບແອັບພລິເຄຊັນຫຼາຍພາສາ, ໂດຍສະເພາະທີ່ກ່ຽວຂ້ອງກັບ ຫວຽດນາມ. 
UTF-8 ແມ່ນມາດຕະຖານທົ່ວໄປທີ່ສາມາດສະແດງທຸກຕົວອັກສອນໃນຕົວອັກສອນ ຫວຽດນາມ ໄດ້ຢ່າງຖືກຕ້ອງ. 
Doctranslate API ດໍາເນີນການທັງຫມົດພາຍໃນສະພາບແວດລ້ອມ UTF-8, ຕັ້ງແຕ່ການສະກັດຂໍ້ຄວາມໄປຫາການແປແລະການສ້າງເອກະສານສຸດທ້າຍ. 
ນີ້ລົບລ້າງຄວາມສ່ຽງຂອງ `mojibake` ຫຼືຂໍ້ຄວາມທີ່ເສຍຫາຍ, ໃຫ້ນັກພັດທະນາມີຄວາມສະຫງົບໃຈວ່າຂໍ້ມູນຂໍ້ຄວາມທັງຫມົດຖືກຈັດການດ້ວຍຄວາມຊື່ສັດຕະຫຼອດຂະບວນການເຮັດວຽກ.
ຮູບສັນຍາລັກຕົວອັກສອນ (Font Glyphs) ແລະການສະແດງຜົນ
ບັນຫາທົ່ວໄປເມື່ອສະແດງຂໍ້ຄວາມທີ່ແປແລ້ວແມ່ນການຂາດຮູບສັນຍາລັກຕົວອັກສອນ (font glyphs), ເຊິ່ງປາກົດເປັນກ່ອງເປົ່າ (ມັກຈະຖືກເອີ້ນວ່າ ‘tofu’). 
ອັນນີ້ເກີດຂຶ້ນເມື່ອຕົວອັກສອນທີ່ຝັງຢູ່ໃນ PDF ແອັດສະປາຍ ຕົ້ນສະບັບບໍ່ມີຕົວອັກສອນທີ່ຈໍາເປັນສໍາລັບ ຫວຽດນາມ. 
Doctranslate API ແກ້ໄຂບັນຫານີ້ຢ່າງສະຫລາດໂດຍການດໍາເນີນການທົດແທນຕົວອັກສອນອັດສະລິຍະ. 
ມັນຈະປ່ຽນແທນ ຫຼື ຝັງຕົວອັກສອນທີ່ເຂົ້າກັນໄດ້ໂດຍອັດຕະໂນມັດເຊິ່ງລວມມີຮູບສັນຍາລັກ ຫວຽດນາມ ທີ່ຕ້ອງການ, ຮັບປະກັນວ່າເອກະສານທີ່ແປແລ້ວແມ່ນສາມາດອ່ານໄດ້ຢ່າງສົມບູນແລະຮັກສາຮູບລັກສະນະທີ່ເປັນມືອາຊີບ.
ບົດສະຫຼຸບ ແລະຂັ້ນຕອນຕໍ່ໄປ
ການເຊື່ອມໂຍງ API ສໍາລັບການແປ PDF ຈາກ ແອັດສະປາຍ ເປັນ ຫວຽດນາມ ສາມາດປັບປຸງປະສິດທິພາບຢ່າງຫຼວງຫຼາຍແລະເປີດຄວາມເປັນໄປໄດ້ໃຫມ່ສໍາລັບການສື່ສານຂ້າມຕະຫຼາດ. 
Doctranslate API ສະຫນອງການແກ້ໄຂທີ່ມີປະສິດທິພາບ, ເຊື່ອຖືໄດ້, ແລະເປັນມິດກັບນັກພັດທະນາເຊິ່ງຈັດການຄວາມສັບສົນຂອງການແປ PDF ຢ່າງຊໍານານ. 
ໂດຍການຮັກສາຮູບແບບເອກະສານແລະການຈັດການຄວາມລະອຽດອ່ອນຂອງພາສາ ຫວຽດນາມ, ມັນອະນຸຍາດໃຫ້ທ່ານສາມາດເຮັດໃຫ້ຂະບວນການທີ່ເຄີຍເປັນຄູ່ມືແລະມີຄວາມຜິດພາດອັດຕະໂນມັດ.
ຄູ່ມືນີ້ໄດ້ພາທ່ານຜ່ານການເຊື່ອມໂຍງທີ່ສົມບູນ, ຕັ້ງແຕ່ການຕັ້ງຄ່າຈົນເຖິງການດາວໂຫລດໄຟລ໌ທີ່ແປແລ້ວສຸດທ້າຍ. 
ຂະບວນການສີ່ຂັ້ນຕອນທີ່ງ່າຍດາຍ, ບໍ່ພ້ອມກັນ—ອັບໂຫລດ, ແປ, ກວດສອບສະຖານະ, ແລະດາວໂຫລດ—ສາມາດຖືກປະຕິບັດໄດ້ຢ່າງງ່າຍດາຍໂດຍໃຊ້ຫ້ອງສະໝຸດມາດຕະຖານໃນພາສາການຂຽນໂປຣແກຣມໃດໆ. 
ນີ້ເຮັດໃຫ້ນັກພັດທະນາມີອໍານາດໃນການສ້າງຂະບວນການແປແບບອັດຕະໂນມັດທີ່ຊັບຊ້ອນໂດຍກົງໃນແອັບພລິເຄຊັນຂອງພວກເຂົາ. 
ພວກເຮົາຊຸກຍູ້ໃຫ້ທ່ານຄົ້ນຫາຄວາມສາມາດເຕັມຮູບແບບແລະເລີ່ມຕົ້ນການສ້າງໃນມື້ນີ້.
ເພື່ອຮຽນຮູ້ເພີ່ມເຕີມກ່ຽວກັບຄຸນສົມບັດຂັ້ນສູງ, ເຊັ່ນ: custom glossaries, tone control, ຫຼືການແປຮູບແບບເອກະສານອື່ນໆ, ກະລຸນາອ້າງອີງເຖິງເອກະສານທາງການຂອງ Doctranslate API. 
ເອກະສານດັ່ງກ່າວສະຫນອງຄໍາອະທິບາຍຢ່າງເລິກເຊິ່ງກ່ຽວກັບ endpoints ແລະ parameters ທີ່ມີຢູ່ທັງຫມົດ. 
ເລີ່ມຕົ້ນການເດີນທາງການເຊື່ອມໂຍງຂອງທ່ານດຽວນີ້ເພື່ອປົດລັອກການແປເອກະສານທີ່ບໍ່ມີຮອຍຕໍ່ແລະມີຄວາມຖືກຕ້ອງສູງ.