API ການແປເອກະສານຈາກພາສາອັງກິດເປັນພາສາປອກຕຸຍການ: ຮັກສາຮູບແບບໄດ້ໄວ

ສິ່ງທ້າທາຍຂອງການແປເອກະສານແບບໂປຣແກຣມ

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

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

ຄວາມສັບສົນໃນການເຂົ້າລະຫັດຕົວອັກສອນ

ພາສາປອກຕຸຍການນຳໃຊ້ເຄື່ອງໝາຍ diacritical, ເຊັ່ນ ç, á, é, ແລະ õ, ເຊິ່ງບໍ່ມີຢູ່ໃນຊຸດຕົວອັກສອນ ASCII ມາດຕະຖານ.
ນີ້ເຮັດໃຫ້ເກີດຄວາມສ່ຽງຂອງຄວາມຜິດພາດໃນການເຂົ້າລະຫັດທັນທີຖ້າບໍ່ໄດ້ຈັດການຢ່າງຖືກຕ້ອງ.
ຖ້າລະບົບຂອງທ່ານໃຊ້ຮູບແບບການເຂົ້າລະຫັດແບບເກົ່າໂດຍຄ່າເລີ່ມຕົ້ນ, ຕົວອັກສອນເຫຼົ່ານີ້ສາມາດສະແດງເປັນຂໍ້ຄວາມທີ່ບໍ່ມີຄວາມໝາຍ (ເຊັ່ນ: “mojibake”),
ເຮັດໃຫ້ເອກະສານທີ່ແປແລ້ວບໍ່ເປັນມືອາຊີບ ແລະ ມັກຈະເຂົ້າໃຈຍາກ.

ການຮັບປະກັນການເຂົ້າລະຫັດ UTF-8 ທີ່ສອດຄ່ອງກັນຕະຫຼອດຂັ້ນຕອນການເຮັດວຽກທັງໝົດ—ຕັ້ງແຕ່ການອ່ານໄຟລ໌ຕົ້ນສະບັບໄປຈົນເຖິງການປະມວນຜົນຂໍ້ຄວາມ ແລະ ການຂຽນໄຟລ໌ທີ່ແປແລ້ວ—ແມ່ນສຳຄັນທີ່ສຸດ.
ນີ້ລວມມີການຈັດການຄຳຮ້ອງຂໍ API ແລະ ຄຳຕອບຢ່າງຖືກຕ້ອງ,
ເພາະວ່າຈຸດຄວາມຜິດພາດດຽວໃດກໍ່ສາມາດເຮັດໃຫ້ຂໍ້ຄວາມເສຍຫາຍໄດ້. ນັກພັດທະນາຕ້ອງລະມັດລະວັງໃນການຕັ້ງຄ່າສ່ວນຫົວທີ່ຖືກຕ້ອງ ແລະ ການຕີຄວາມໝາຍຂອງສາຍໄບຕ໌ຢ່າງເໝາະສົມ ເພື່ອຫຼີກລ້ຽງບັນຫາທີ່ໜ້າລຳຄານ ແລະ ຍາກໃນການດີບັກເຫຼົ່ານີ້.

ການຮັກສາຮູບແບບສາຍຕາທີ່ສັບຊ້ອນ

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

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

ການຈັດການໂຄງສ້າງໄຟລ໌ທີ່ຫຼາກຫຼາຍ

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

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

ການນໍາສະເໜີ Doctranslate API ສໍາລັບການແປທີ່ບໍ່ມີການຕິດຂັດ

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

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

ສ້າງຂຶ້ນບົນຫຼັກການຂອງ RESTful

ຄວາມງ່າຍດາຍ ແລະ ຄວາມສາມາດໃນການຄາດເດົາໄດ້ແມ່ນຫຼັກຂອງການອອກແບບ API ຂອງພວກເຮົາ.
ພວກເຮົາປະຕິບັດຕາມຫຼັກການ RESTful ມາດຕະຖານ, ໂດຍໃຊ້ URLs ທີ່ເນັ້ນໃສ່ຊັບພະຍາກອນທີ່ຄາດເດົາໄດ້,
ຍອມຮັບເນື້ອໃນຄຳຮ້ອງຂໍທີ່ເຂົ້າລະຫັດແບບຟອມ, ແລະ ສົ່ງຄືນຄຳຕອບທີ່ເຂົ້າລະຫັດ JSON.
ມັນໃຊ້ລະຫັດຕອບສະໜອງ HTTP ມາດຕະຖານເພື່ອຊີ້ບອກຄວາມຜິດພາດຂອງ API, ເຮັດໃຫ້ການລວມເຂົ້າ ແລະ ການດີບັກເປັນເລື່ອງງ່າຍສຳລັບນັກພັດທະນາທີ່ຄຸ້ນເຄີຍກັບເຕັກໂນໂລຢີເວັບໃດກໍຕາມ.

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

ຂັ້ນຕອນການເຮັດວຽກແບບ Asynchronous ສໍາລັບໄຟລ໌ຂະໜາດໃຫຍ່

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

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

ຄູ່ມືຂັ້ນຕອນຕໍ່ຂັ້ນຕອນ: ການລວມ API ການແປເອກະສານຈາກພາສາອັງກິດເປັນພາສາປອກຕຸຍການ

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

ຂັ້ນຕອນທີ 1: ການກວດສອບຄວາມຖືກຕ້ອງ ແລະ ການຕັ້ງຄ່າ

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

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

import requests
import time

# Your API key from the Doctranslate dashboard
API_KEY = "your_api_key_here"

# The file you want to translate
FILE_PATH = "/path/to/your/document.docx"

# API endpoints
BASE_URL = "https://developer.doctranslate.io"
UPLOAD_URL = f"{BASE_URL}/v3/documents"
TRANSLATE_URL_TEMPLATE = f"{BASE_URL}/v3/documents/{{document_id}}/translate"
STATUS_URL_TEMPLATE = f"{BASE_URL}/v3/documents/{{document_id}}"
DOWNLOAD_URL_TEMPLATE = f"{BASE_URL}/v3/documents/{{document_id}}/download/{{translation_id}}"

HEADERS = {
    "Authorization": f"Bearer {API_KEY}"
}

ຂັ້ນຕອນທີ 2: ການອັບໂຫຼດເອກະສານຂອງທ່ານ
ຂັ້ນຕອນທໍາອິດໃນຂັ້ນຕອນການເຮັດວຽກແມ່ນການອັບໂຫຼດເອກະສານຕົ້ນສະບັບໄປຫາເຊີບເວີ Doctranslate.
 ທ່ານຈະເຮັດຄໍາຮ້ອງຂໍ POST ໄປຫາຈຸດສິ້ນສຸດ /v3/documents.
 ເນື້ອໃນຄຳຮ້ອງຂໍຄວນເປັນ multipart/form-data payload ທີ່ປະກອບມີໄຟລ໌ຕົວມັນເອງ.
 ການອັບໂຫຼດທີ່ສຳເລັດຜົນຈະສົ່ງຄືນຄຳຕອບ JSON ທີ່ປະກອບມີ document_id ທີ່ເປັນເອກະລັກສຳລັບໄຟລ໌ຂອງທ່ານ.
document_id ນີ້ແມ່ນສຳຄັນ, ເນື່ອງຈາກວ່າມັນຈະຖືກນຳໃຊ້ໃນການຮຽກໃຊ້ API ຕໍ່ໆໄປທັງໝົດເພື່ອອ້າງເຖິງເອກະສານສະເພາະນີ້.
 ໃຫ້ແນ່ໃຈວ່າໄດ້ແຍກວິເຄາະຄຳຕອບ ແລະ ເກັບຮັກສາ ID ນີ້ໄວ້.
 API ຈັດການຄວາມສັບສົນຂອງການຖ່າຍທອດໄຟລ໌ ແລະ ການເກັບຮັກສາໃນ backend,
 ດັ່ງນັ້ນທ່ານພຽງແຕ່ຕ້ອງການສົ່ງຂໍ້ມູນໄຟລ໌ຜ່ານຄຳຮ້ອງຂໍ HTTP ມາດຕະຖານ.

def upload_document(file_path):
    print(f"Uploading document: {file_path}")
    with open(file_path, 'rb') as f:
        files = {'file': (f.name, f, 'application/octet-stream')}
        response = requests.post(UPLOAD_URL, headers=HEADERS, files=files)
    
    response.raise_for_status()  # Raises an exception for bad status codes
    data = response.json()
    document_id = data.get('id')
    print(f"Document uploaded successfully. Document ID: {document_id}")
    return document_id

ຂັ້ນຕອນທີ 3: ການລິເລີ່ມການແປ
ເມື່ອເອກະສານຖືກອັບໂຫຼດແລ້ວ, ທ່ານສາມາດລິເລີ່ມຂະບວນການແປໄດ້.
 ເຮັດຄໍາຮ້ອງຂໍ POST ໄປຫາຈຸດສິ້ນສຸດ /v3/documents/{document_id}/translate,
 ປ່ຽນແທນ {document_id} ດ້ວຍ ID ທີ່ທ່ານໄດ້ຮັບໃນຂັ້ນຕອນກ່ອນໜ້ານີ້.
 ເນື້ອໃນຄຳຮ້ອງຂໍຄວນເປັນວັດຖຸ JSON ທີ່ກຳນົດ target_lang ເປັນ pt ສໍາລັບພາສາປອກຕຸຍການ.
API ຈະຕອບສະໜອງທັນທີ, ຢືນຢັນວ່າວຽກແປໄດ້ຖືກຈັດຄິວແລ້ວ.
 ຄໍາຕອບຈະມີ translation_id ເຊິ່ງທ່ານຈະຕ້ອງການຕໍ່ມາເພື່ອດາວໂຫຼດໄຟລ໌ທີ່ສຳເລັດແລ້ວ.
 ການໂທແບບບໍ່ບລັອກນີ້ຊ່ວຍໃຫ້ຄໍາຮ້ອງສະຫມັກຂອງທ່ານສືບຕໍ່ປະມວນຜົນວຽກງານອື່ນໆໃນຂະນະທີ່ການແປຖືກດໍາເນີນຢູ່ໃນເຊີບເວີຂອງພວກເຮົາ,
 ເຊິ່ງເປັນສິ່ງຈຳເປັນສຳລັບການສ້າງຄໍາຮ້ອງສະຫມັກທີ່ຕອບສະໜອງໄດ້.

def start_translation(document_id, target_language='pt'):
    print(f"Starting translation to {target_language} for document {document_id}")
    payload = {
        'target_lang': target_language
        # You can also specify 'source_lang': 'en' if needed
    }
    translate_url = TRANSLATE_URL_TEMPLATE.format(document_id=document_id)
    response = requests.post(translate_url, headers=HEADERS, json=payload)
    
    response.raise_for_status()
    data = response.json()
    print("Translation job started.")
    return data

ຂັ້ນຕອນທີ 4: ການກວດສອບສະຖານະການແປ
ເນື່ອງຈາກການແປເປັນຂະບວນການ asynchronous, ທ່ານຈຳເປັນຕ້ອງກວດສອບສະຖານະຂອງມັນເປັນໄລຍະ.
 ທ່ານສາມາດເຮັດໄດ້ໂດຍການເຮັດຄໍາຮ້ອງຂໍ GET ໄປຫາຈຸດສິ້ນສຸດສະຖານະເອກະສານທີ່ /v3/documents/{document_id}.
 ຄໍາຕອບຈະມີຂໍ້ມູນກ່ຽວກັບເອກະສານ, ລວມທັງລາຍຊື່ຂອງການແປ ແລະ status ປັດຈຸບັນຂອງພວກເຂົາ,
 ເຊິ່ງສາມາດເປັນ queued, processing, ຫຼື completed.
ວິທີການທົ່ວໄປແມ່ນການສຳຫຼວດຈຸດສິ້ນສຸດນີ້ທຸກໆສອງສາມວິນາທີ ຈົນກວ່າສະຖານະຈະປ່ຽນເປັນ completed.
 ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະປະຕິບັດໄລຍະການສຳຫຼວດທີ່ເໝາະສົມເພື່ອຫຼີກລ້ຽງຄຳຮ້ອງຂໍທີ່ຫຼາຍເກີນໄປຕໍ່ API.
 ສໍາລັບຄໍາຮ້ອງສະຫມັກການຜະລິດ, ການຕັ້ງຄ່າ webhook ແມ່ນທາງເລືອກທີ່ມີປະສິດທິພາບຫຼາຍກວ່າການສຳຫຼວດ,
 ເນື່ອງຈາກວ່າມັນກໍາຈັດຄວາມຈໍາເປັນສໍາລັບການກວດສອບສະຖານະຊ້ຳໆ.

def check_status_and_wait(document_id, target_language='pt'):
    print("Polling for translation status...")
    status_url = STATUS_URL_TEMPLATE.format(document_id=document_id)
    while True:
        response = requests.get(status_url, headers=HEADERS)
        response.raise_for_status()
        data = response.json()
        
        translation_found = False
        for translation in data.get('translations', []):
            if translation.get('lang') == target_language:
                translation_found = True
                status = translation.get('status')
                print(f"Current status: {status}")
                if status == 'completed':
                    return translation.get('id')
                elif status == 'error':
                    raise Exception("Translation failed with an error.")
                break
        
        if not translation_found:
            print("Translation not yet initiated in response, waiting...")

        time.sleep(5)  # Wait for 5 seconds before polling again

ຂັ້ນຕອນທີ 5: ການດາວໂຫຼດເອກະສານທີ່ແປແລ້ວ
ເມື່ອສະຖານະແມ່ນ completed, ທ່ານສາມາດດາວໂຫຼດເອກະສານທີ່ແປແລ້ວສຸດທ້າຍໄດ້.
 ເຮັດຄໍາຮ້ອງຂໍ GET ໄປຫາຈຸດສິ້ນສຸດການດາວໂຫຼດ /v3/documents/{document_id}/download/{translation_id}.
 translation_id ແມ່ນອັນທີ່ທ່ານໄດ້ຮັບຈາກການກວດສອບສະຖານະ.
 API ຈະຕອບສະໜອງດ້ວຍຂໍ້ມູນຖານສອງຂອງໄຟລ໌ທີ່ແປແລ້ວ.
ຫຼັງຈາກນັ້ນ, ລະຫັດຂອງທ່ານຄວນຂຽນຂໍ້ມູນຖານສອງນີ້ໃສ່ໄຟລ໌ໃໝ່ໃນລະບົບທ້ອງຖິ່ນຂອງທ່ານ.
 ໃຫ້ແນ່ໃຈວ່າເປີດໄຟລ໌ຜົນຜະລິດໃນໂໝດຂຽນຖານສອງ ('wb') ເພື່ອຈັດການເນື້ອໃນໄຟລ໌ຢ່າງຖືກຕ້ອງ.
 ຫຼັງຈາກຂັ້ນຕອນນີ້, ທ່ານຈະມີເອກະສານພາສາປອກຕຸຍການທີ່ແປສຳເລັດແລ້ວ ເຊິ່ງຮັກສາການຈັດຮູບແບບຕົ້ນສະບັບໄວ້,
 ພ້ອມສໍາລັບການນໍາໃຊ້ໃນຄໍາຮ້ອງສະຫມັກຂອງທ່ານ.

def download_translated_document(document_id, translation_id, output_path):
    print(f"Downloading translated document to {output_path}")
    download_url = DOWNLOAD_URL_TEMPLATE.format(document_id=document_id, translation_id=translation_id)
    response = requests.get(download_url, headers=HEADERS, stream=True)
    
    response.raise_for_status()
    
    with open(output_path, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    
    print("Download complete.")

# --- Main Execution Logic ---
def main():
    try:
        document_id = upload_document(FILE_PATH)
        start_translation(document_id, 'pt')
        translation_id = check_status_and_wait(document_id, 'pt')
        
        output_filename = FILE_PATH.replace('.docx', '_pt.docx')
        download_translated_document(document_id, translation_id, output_filename)
        
        print(f"
Translation workflow completed successfully!")
        print(f"Translated file saved as: {output_filename}")

    except requests.exceptions.HTTPError as e:
        print(f"An API error occurred: {e.response.status_code} {e.response.text}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

if __name__ == "__main__":
    main()

ຂໍ້ຄວນພິຈາລະນາທີ່ສໍາຄັນສໍາລັບການແປພາສາປອກຕຸຍການ
ນອກເໜືອໄປຈາກການລວມ API ດ້ານເຕັກນິກແລ້ວ, ຍັງມີຄວາມແຕກຕ່າງທາງດ້ານພາສາສະເພາະທີ່ຄວນພິຈາລະນາເມື່ອແປເນື້ອໃນເປັນພາສາປອກຕຸຍການ.
 ປັດໄຈເຫຼົ່ານີ້ສາມາດມີອິດທິພົນຕໍ່ຄຸນນະພາບ ແລະ ການຕອບຮັບຂອງເອກະສານສຸດທ້າຍ.
 ໃນຂະນະທີ່ API ຈັດການວຽກໜັກຂອງການແປ ແລະ ການຈັດຮູບແບບ,
 ນັກພັດທະນາສາມາດປັບປຸງຜົນໄດ້ຮັບໂດຍການເຂົ້າໃຈລັກສະນະທາງດ້ານພາສາສາດເຫຼົ່ານີ້.
ການຈັດການ Diacritics ດ້ວຍ UTF-8
ດັ່ງທີ່ໄດ້ກ່າວມາຂ້າງເທິງ, ພາສາປອກຕຸຍການມີເຄື່ອງໝາຍ diacritical ຫຼາຍອັນທີ່ຈຳເປັນສຳລັບການສະກົດຄຳ ແລະ ການອອກສຽງທີ່ຖືກຕ້ອງ.
 Doctranslate API ຈັດການສິ່ງນີ້ໄດ້ຢ່າງຄ່ອງຕົວໂດຍການດໍາເນີນງານກັບ UTF-8 ແບບ end-to-end.
 ມັນເປັນສິ່ງສໍາຄັນທີ່ຂໍ້ຄວາມໃດໆທີ່ທ່ານຈັດການຫຼືສະແດງຢູ່ໃນຄໍາຮ້ອງສະຫມັກຂອງທ່ານຍັງຮັກສາການເຂົ້າລະຫັດນີ້.
 ໃຫ້ແນ່ໃຈສະເໝີວ່າການເຊື່ອມຕໍ່ຖານຂໍ້ມູນຂອງທ່ານ, file I/O, ແລະ ໜ້າ HTML ຖືກກຳນົດຄ່າສຳລັບ UTF-8 ເພື່ອປ້ອງກັນການເສຍຫາຍຂອງຕົວອັກສອນ.
ການຄຳນຶງເຖິງການຂະຫຍາຍຕົວຂອງຂໍ້ຄວາມ
ຂໍ້ຄວາມພາສາປອກຕຸຍການມັກຈະຍາວກວ່າຂໍ້ຄວາມທີ່ທຽບເທົ່າໃນພາສາອັງກິດ.
 ໃນຂະນະທີ່ API ຂອງພວກເຮົາຖືກອອກແບບມາເພື່ອຈັດການການໄຫຼຂອງຂໍ້ຄວາມຄືນໃໝ່ ແລະ ປັບຮູບແບບໂດຍອັດຕະໂນມັດ,
 ນັກພັດທະນາຄວນຈະລະວັງກ່ຽວກັບເລື່ອງນີ້ເມື່ອອອກແບບແມ່ແບບ ຫຼື ອົງປະກອບ UI ທີ່ໃຊ້ເນື້ອໃນທີ່ແປແລ້ວ.
 ຖ້າເອກະສານຕົ້ນສະບັບຂອງທ່ານມີກ່ອງຂໍ້ຄວາມ ຫຼື ຕາຕະລາງທີ່ຖືກຈຳກັດຢ່າງເຄັ່ງຄັດ,
 ທ່ານອາດຈະຕ້ອງການອະນຸຍາດໃຫ້ມີບ່ອນຫວ່າງເພີ່ມເຕີມເພື່ອຮອງຮັບປະໂຫຍກພາສາປອກຕຸຍການທີ່ຍາວກວ່າຢ່າງເໝາະສົມ.
ອັນນີ້ແມ່ນສຳຄັນໂດຍສະເພາະໃນຮູບແບບຂໍ້ມູນທີ່ມີໂຄງສ້າງເຊັ່ນ XLSX ຫຼືໃນການນຳສະເໜີແບບກຣາບຟິກ.
 ກ່ອນທີ່ຈະສິ້ນສຸດແມ່ແບບເອກະສານສໍາລັບການແປ,
 ພິຈາລະນາວ່າການເພີ່ມຂຶ້ນຂອງຄວາມຍາວຂອງຂໍ້ຄວາມ 20-30% ອາດຈະສົ່ງຜົນກະທົບຕໍ່ການອອກແບບໂດຍລວມແນວໃດ.
 ການອອກແບບຢ່າງຫ້າວຫັນໂດຍຄໍານຶງເຖິງການຂະຫຍາຍຕົວຂອງຂໍ້ຄວາມສາມາດປ້ອງກັນບັນຫາການຈັດຮູບແບບຫຼັງການແປ ແລະ ຮັບປະກັນຜະລິດຕະພັນສຸດທ້າຍທີ່ສວຍງາມສຳລັບຜູ້ໃຊ້ສຸດທ້າຍຂອງທ່ານ.
ການຈັດການສຳນຽງທາງການ ແລະ ບໍ່ເປັນທາງການ
ພາສາປອກຕຸຍການມີລະດັບຄວາມເປັນທາງການທີ່ແຕກຕ່າງກັນ, ໂດຍສະເພາະໃນການໃຊ້ຄຳນາມ (ເຊັ່ນ, você ທຽບກັບ tu).
 ໃນຂະນະທີ່ພາສາປອກຕຸຍການເອີຣົບ ແລະ ບຣາຊິລມີການນຳໃຊ້ທົ່ວໄປທີ່ແຕກຕ່າງກັນ,
 ສຳນຽງຍັງສາມາດແຕກຕ່າງກັນໄດ້ໂດຍອີງໃສ່ກຸ່ມເປົ້າໝາຍ ແລະ ບໍລິບົດ.
 Doctranslate API ໃຫ້ການແປພື້ນຖານທີ່ມີຄຸນນະພາບສູງທີ່ເໝາະສົມກັບກໍລະນີການນຳໃຊ້ທຸລະກິດ ແລະ ທົ່ວໄປສ່ວນໃຫຍ່.
ສໍາລັບຄໍາຮ້ອງສະຫມັກທີ່ຕ້ອງການຄໍາສັບສະເພາະຫຼາຍ ຫຼື ສຽງຍີ່ຫໍ້ທີ່ສອດຄ່ອງກັນ,
 ພິຈາລະນາການໃຊ້ຄຸນສົມບັດຄໍາສັບຖ້າຫາກວ່າມີຢູ່ໃນແຜນຂອງທ່ານ.
 ຄໍາສັບຊ່ວຍໃຫ້ທ່ານສາມາດກໍານົດວ່າຄໍາສັບພາສາອັງກິດສະເພາະຄວນຖືກແປເປັນພາສາປອກຕຸຍການແນວໃດສະເໝີ.
 ນີ້ຮັບປະກັນວ່າຊື່ຍີ່ຫໍ້, ສັບວິຊາການ, ແລະ ປະໂຫຍກທີ່ສໍາຄັນຖືກຈັດການຢ່າງສອດຄ່ອງໃນທົ່ວເອກະສານທັງໝົດຂອງທ່ານ,
 ໃຫ້ທ່ານມີການຄວບຄຸມຫຼາຍຂຶ້ນຕໍ່ກັບຜົນຜະລິດສຸດທ້າຍ.
ສະຫຼຸບ ແລະ ຂັ້ນຕອນຕໍ່ໄປ
ການລວມ API ການແປເອກະສານຈາກພາສາອັງກິດເປັນພາສາປອກຕຸຍການທີ່ມີປະສິດທິພາບສາມາດຂະຫຍາຍການເຂົ້າເຖິງທົ່ວໂລກຂອງຄໍາຮ້ອງສະຫມັກຂອງທ່ານໄດ້ຢ່າງຫຼວງຫຼາຍ.
 ໂດຍການນໍາໃຊ້ Doctranslate API, ທ່ານສາມາດເອົາຊະນະອຸປະສັກທາງດ້ານເຕັກນິກທີ່ສໍາຄັນຂອງການແຍກວິເຄາະໄຟລ໌,
 ການຮັກສາຮູບແບບ, ແລະ ການເຂົ້າລະຫັດຕົວອັກສອນ. ບໍລິການ RESTful, asynchronous ຂອງພວກເຮົາໃຫ້ວິທີທີ່ສາມາດປັບຂະໜາດໄດ້ ແລະ ເປັນມິດກັບນັກພັດທະນາ ເພື່ອເຮັດໃຫ້ການແປທີ່ມີຄວາມຖືກຕ້ອງສູງເປັນອັດຕະໂນມັດໃນທົ່ວຮູບແບບໄຟລ໌ຫຼາຍສິບອັນ.
ຄູ່ມືນີ້ໄດ້ສະໜອງການຍ່າງຜ່ານທີ່ສົມບູນແບບຂອງຂະບວນການລວມເຂົ້າກັນທັງໝົດ,
 ຕັ້ງແຕ່ການອັບໂຫຼດເອກະສານໄປຈົນເຖິງການດາວໂຫຼດການແປທີ່ຖືກຈັດຮູບແບບຢ່າງຄົບຖ້ວນ.
 ໂດຍການປະຕິບັດຕາມຂັ້ນຕອນເຫຼົ່ານີ້ ແລະ ຮັກສາຂໍ້ຄວນພິຈາລະນາສະເພາະພາສາໄວ້ໃນໃຈ,
 ທ່ານສາມາດສ້າງຄຸນສົມບັດຫຼາຍພາສາທີ່ເຂັ້ມແຂງ, ເຊື່ອຖືໄດ້, ແລະ ເປັນມືອາຊີບ. ສໍາລັບຂໍ້ມູນລາຍລະອຽດເພີ່ມເຕີມກ່ຽວກັບຄຸນສົມບັດຂັ້ນສູງເຊັ່ນ webhooks, ພາສາທີ່ຮອງຮັບ, ແລະ ຄໍາສັບທີ່ກຳນົດເອງ,
 ກະລຸນາເບິ່ງເອກະສານຂອງນັກພັດທະນາຢ່າງເປັນທາງການຂອງພວກເຮົາ.