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

ຄວາມສັບສົນທີ່ເຊື່ອງໄວ້ຂອງການແປເອກະສານຜ່ານ API

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

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

ສິ່ງທ້າທາຍໃນການເຂົ້າລະຫັດຕົວອັກສອນ

ພາສາປອກຕຸຍການປະກອບດ້ວຍຕົວອັກສອນພິເສດຫຼາຍຕົວ, ເຊັ່ນ ‘ç’, ‘ã’, ‘é’, ແລະ ‘õ’, ເຊິ່ງບໍ່ມີຢູ່ໃນຊຸດ ASCII ມາດຕະຖານ.
ນີ້ຮຽກຮ້ອງໃຫ້ມີການໃຊ້ການເຂົ້າລະຫັດຕົວອັກສອນທີ່ຖືກຕ້ອງ, ໂດຍສະເພາະ UTF-8, ເພື່ອຮັບປະກັນວ່າຕົວອັກສອນເຫຼົ່ານີ້ຖືກສະແດງຢ່າງຖືກຕ້ອງ.
ການຈັດການການເຂົ້າລະຫັດທີ່ບໍ່ຖືກຕ້ອງສາມາດເຮັດໃຫ້ເກີດຂໍ້ຄວາມທີ່ສັບສົນ, ເຊິ່ງເອີ້ນວ່າ mojibake, ເຊິ່ງເຮັດໃຫ້ເອກະສານບໍ່ສາມາດອ່ານໄດ້ ແລະ ບໍ່ເປັນມືອາຊີບ.

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

ການຮັກສາຮູບແບບທີ່ສັບສົນ

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

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

ການຮັກສາຄວາມສົມບູນຂອງໂຄງສ້າງໄຟລ໌

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

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

ການນໍາສະເໜີ Doctranslate Document Translation API

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

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

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

ຄູ່ມືຂັ້ນຕອນໂດຍຂັ້ນຕອນສຳລັບການເຊື່ອມໂຍງ API ເອກະສານ ພາສາອັງກິດ ເປັນ ພາສາປອກຕຸຍການ

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

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

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

ການຮ້ອງຂໍທັງໝົດໄປຫາ Doctranslate API ຕ້ອງປະກອບມີຄີ API ຂອງທ່ານໃນ header `Authorization`.
ຮູບແບບທີ່ຕ້ອງການແມ່ນ `Authorization: Bearer YOUR_API_KEY`.
ໃຫ້ແນ່ໃຈວ່າປ່ຽນແທນ `YOUR_API_KEY` ດ້ວຍຄີຕົວຈິງຈາກ dashboard ຂອງທ່ານ ເພື່ອກວດສອບການຮ້ອງຂໍຂອງທ່ານໃຫ້ສໍາເລັດ.

ຂັ້ນຕອນທີ 2: ການອັບໂຫລດເອກະສານຕົ້ນສະບັບຂອງທ່ານ

ຂັ້ນຕອນທໍາອິດໃນຂະບວນການແປແມ່ນການອັບໂຫລດເອກະສານຕົ້ນສະບັບຂອງທ່ານ.
ນີ້ແມ່ນເຮັດໄດ້ໂດຍການສົ່ງຄໍາຮ້ອງຂໍ `POST` ໄປຫາ endpoint `/v3/document/upload`.
ຄໍາຮ້ອງຂໍຕ້ອງເປັນຄໍາຮ້ອງຂໍ `multipart/form-data` ທີ່ມີໄຟລ໌ທີ່ທ່ານຕ້ອງການແປ.

API ຈະປະມວນຜົນໄຟລ໌ທີ່ອັບໂຫລດ ແລະ ສົ່ງຄືນ `document_id` ໃນການຕອບສະໜອງ JSON.
ID ນີ້ແມ່ນຕົວລະບຸສະເພາະສໍາລັບເອກະສານຂອງທ່ານພາຍໃນລະບົບ Doctranslate.
ທ່ານຈະໃຊ້ `document_id` ນີ້ໃນການໂທຫາ API ຕໍ່ໄປ ເພື່ອລິເລີ່ມການແປ ແລະ ກວດສອບສະຖານະຂອງມັນ.

ຂັ້ນຕອນທີ 3: ການລິເລີ່ມຂະບວນການແປ

ເມື່ອທ່ານມີ `document_id`, ທ່ານສາມາດຮ້ອງຂໍການແປຂອງມັນໄດ້.
ທ່ານເຮັດສິ່ງນີ້ໂດຍການສົ່ງຄໍາຮ້ອງຂໍ `POST` ໄປຫາ endpoint `/v3/document/translate`.
ຕົວເຄື່ອງຂອງຄໍາຮ້ອງຂໍນີ້ຄວນເປັນວັດຖຸ JSON ທີ່ກໍານົດ `document_id`, `source_lang`, ແລະ `target_lang`.

ສໍາລັບການແປຈາກ ພາສາອັງກິດ ເປັນ ພາສາປອກຕຸຍການ, ທ່ານຈະກໍານົດ `source_lang` ເປັນ `en` ແລະ `target_lang` ເປັນ `pt`.
ຈາກນັ້ນ API ຈະຈັດຄິວເອກະສານຂອງທ່ານສໍາລັບການແປ.
ການຕອບສະໜອງຈະຢືນຢັນວ່າຂະບວນການແປໄດ້ເລີ່ມຕົ້ນແລ້ວ, ແຕ່ມັນຈະບໍ່ມີເອກະສານທີ່ແປແລ້ວເອງ, ເນື່ອງຈາກວ່ານີ້ແມ່ນການດໍາເນີນງານແບບ asynchronous.

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

ເນື່ອງຈາກການແປເອກະສານສາມາດໃຊ້ເວລາຂຶ້ນຢູ່ກັບຂະໜາດ ແລະ ຄວາມສັບສົນຂອງໄຟລ໌, ທ່ານຈໍາເປັນຕ້ອງສອບຖາມສະຖານະ.
ທ່ານສາມາດກວດສອບຄວາມຄືບໜ້າໄດ້ໂດຍການສົ່ງຄໍາຮ້ອງຂໍ `GET` ໄປຫາ endpoint `/v3/document/status/{documentId}`.
ປ່ຽນແທນ `{documentId}` ດ້ວຍ `document_id` ຕົວຈິງທີ່ທ່ານໄດ້ຮັບຫຼັງຈາກການອັບໂຫລດ.

API ຈະສົ່ງຄືນວັດຖຸ JSON ທີ່ມີຊ່ອງ `status`.
ຄ່າທີ່ເປັນໄປໄດ້ລວມມີ `processing`, `completed`, ຫຼື `failed`.
ທ່ານຄວນໂທຫາ endpoint ນີ້ເປັນໄລຍະຈົນກວ່າສະຖານະຈະປ່ຽນເປັນ `completed`, ເຊິ່ງສະແດງວ່າເອກະສານທີ່ແປແລ້ວຂອງທ່ານພ້ອມແລ້ວ.

ຂັ້ນຕອນທີ 5: ການດາວໂຫລດເອກະສານພາສາປອກຕຸຍການສຸດທ້າຍ

ຫຼັງຈາກສະຖານະກາຍເປັນ `completed`, ທ່ານສາມາດດາວໂຫລດໄຟລ໌ທີ່ແປແລ້ວໄດ້.
ເພື່ອເຮັດສິ່ງນີ້, ສົ່ງຄໍາຮ້ອງຂໍ `GET` ໄປຫາ endpoint `/v3/document/download/{documentId}`.
endpoint ນີ້ຈະຕອບສະໜອງດ້ວຍຂໍ້ມູນ binary ຂອງເອກະສານທີ່ແປແລ້ວ, ເຊິ່ງທ່ານສາມາດບັນທຶກໄວ້ໃນໄຟລ໌ໄດ້.

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

ຕົວຢ່າງລະຫັດ Python ທີ່ສົມບູນ

ນີ້ແມ່ນສະຄຣິບ Python ທີ່ສົມບູນທີ່ສະແດງໃຫ້ເຫັນຂັ້ນຕອນການເຮັດວຽກທັງໝົດ.
ມັນປະກອບມີການອັບໂຫລດເອກະສານ, ການເລີ່ມຕົ້ນການແປ, ການສອບຖາມສະຖານະ, ແລະ ການດາວໂຫລດຜົນໄດ້ຮັບ.
ຢ່າລືມຕິດຕັ້ງ library `requests` (`pip install requests`) ແລະ ປ່ຽນຄ່າຕົວແທນດ້ວຍຄີ API ແລະ ເສັ້ນທາງໄຟລ໌ຕົວຈິງຂອງທ່ານ.

import requests
import time
import os

# Configuration
API_KEY = "YOUR_API_KEY"  # Replace with your actual API key
BASE_URL = "https://developer.doctranslate.io/api"
FILE_PATH = "path/to/your/document.docx"  # Replace with your document's path
SOURCE_LANG = "en"
TARGET_LANG = "pt"

def upload_document(file_path):
    """Uploads a document and returns the document_id."""
    headers = {"Authorization": f"Bearer {API_KEY}"}
    with open(file_path, "rb") as f:
        files = {"file": (os.path.basename(file_path), f)}
        response = requests.post(f"{BASE_URL}/v3/document/upload", headers=headers, files=files)
    response.raise_for_status()  # Raise an exception for bad status codes
    return response.json()["document_id"]

def start_translation(document_id):
    """Starts the translation process for a given document_id."""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    payload = {
        "document_id": document_id,
        "source_lang": SOURCE_LANG,
        "target_lang": TARGET_LANG
    }
    response = requests.post(f"{BASE_URL}/v3/document/translate", headers=headers, json=payload)
    response.raise_for_status()
    print("Translation process started.")

def check_status(document_id):
    """Polls the API for the translation status."""
    headers = {"Authorization": f"Bearer {API_KEY}"}
    while True:
        response = requests.get(f"{BASE_URL}/v3/document/status/{document_id}", headers=headers)
        response.raise_for_status()
        status = response.json()["status"]
        print(f"Current status: {status}")
        if status == "completed":
            print("Translation completed!")
            break
        elif status == "failed":
            raise Exception("Translation failed.")
        time.sleep(5)  # Wait for 5 seconds before checking again

def download_document(document_id, output_path):
    """Downloads the translated document."""
    headers = {"Authorization": f"Bearer {API_KEY}"}
    response = requests.get(f"{BASE_URL}/v3/document/download/{document_id}", 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(f"Translated document saved to {output_path}")

if __name__ == "__main__":
    try:
        print(f"Uploading document: {FILE_PATH}")
        doc_id = upload_document(FILE_PATH)
        print(f"Document uploaded successfully. Document ID: {doc_id}")
        
        start_translation(doc_id)
        check_status(doc_id)
        
        # Construct the output file path
        filename, ext = os.path.splitext(os.path.basename(FILE_PATH))
        translated_file_path = f"{filename}_{TARGET_LANG}{ext}"
        
        download_document(doc_id, translated_file_path)

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

ການຈັດການລັກສະນະສະເພາະຂອງພາສາປອກຕຸຍການດ້ວຍ API
ການແປເປັນ ພາສາປອກຕຸຍການ ຮຽກຮ້ອງໃຫ້ມີຄວາມເອົາໃຈໃສ່ໃນລາຍລະອຽດທີ່ເກີນກວ່າການປ່ຽນແທນຄໍາສັບໂດຍກົງ.
 ພາສາດັ່ງກ່າວມີສໍານຽງທີ່ແຕກຕ່າງກັນ ແລະ ຄວາມເປັນທາງການທາງດ້ານບໍລິບົດທີ່ສາມາດສົ່ງຜົນກະທົບຢ່າງໃຫຍ່ຫຼວງຕໍ່ຄຸນນະພາບ ແລະ ການຮັບເອົາເອກະສານສຸດທ້າຍ.
 ການເຊື່ອມໂຍງ API ລະດັບມືອາຊີບຕ້ອງຄຳນຶງເຖິງລັກສະນະສະເພາະຂອງພາສາເຫຼົ່ານີ້ ເພື່ອສະໜອງເນື້ອຫາທີ່ຖືກຕ້ອງ ແລະ ເໝາະສົມຢ່າງແທ້ຈິງ.
ຄວາມສະເພາະຂອງສໍານຽງ: ພາສາປອກຕຸຍການແບບເອີຣົບ ທຽບກັບ ແບບບຣາຊິລ
ມີສອງສໍານຽງຫຼັກຂອງ ພາສາປອກຕຸຍການ: ພາສາປອກຕຸຍການແບບເອີຣົບ (`pt-PT`) ແລະ ພາສາປອກຕຸຍການແບບບຣາຊິລ (`pt-BR`).
 ໃນຂະນະທີ່ພວກມັນສາມາດເຂົ້າໃຈເຊິ່ງກັນແລະກັນໄດ້, ພວກມັນມີຄວາມແຕກຕ່າງທີ່ໜ້າສັງເກດໃນດ້ານຄໍາສັບ, ໄວຍາກອນ, ແລະ ການກ່າວເຖິງຢ່າງເປັນທາງການ.
 ການໃຊ້ສໍານຽງທີ່ຜິດພາດສາມາດເບິ່ງຄືວ່າຜິດປົກກະຕິ ຫຼື ແມ້ກະທັ້ງບໍ່ຖືກຕ້ອງຕໍ່ຜູ້ຊົມເປົ້າໝາຍ, ໂດຍສະເພາະໃນເອກະສານທາງທຸລະກິດ ຫຼື ທາງກົດໝາຍ.
Doctranslate API ອະນຸຍາດໃຫ້ທ່ານກໍານົດສໍານຽງເປົ້າໝາຍທີ່ແນ່ນອນໃນຄໍາຮ້ອງຂໍການແປຂອງທ່ານ.
 ໂດຍການຕັ້ງຄ່າຕົວກໍານົດ `target_lang` ເປັນ `pt-PT` ຫຼື `pt-BR`, ທ່ານສາມາດຮັບປະກັນວ່າເຄື່ອງຈັກການແປໃຊ້ຄໍາສັບ ແລະ ການໃຊ້ໄວຍາກອນທີ່ຖືກຕ້ອງ.
 ລະດັບການຄວບຄຸມນີ້ແມ່ນສໍາຄັນສໍາລັບການຜະລິດເນື້ອຫາທີ່ດຶງດູດຄວາມສົນໃຈຂອງຜູ້ອ່ານທີ່ທ່ານຕັ້ງໃຈໄວ້ຢ່າງແທ້ຈິງ.
ການຮັບປະກັນການເຂົ້າລະຫັດຕົວອັກສອນທີ່ຖືກຕ້ອງ
ດັ່ງທີ່ໄດ້ກ່າວມາຂ້າງເທິງ, ການຈັດການຕົວອັກສອນພິເສດທີ່ຖືກຕ້ອງແມ່ນບໍ່ສາມາດຕໍ່ລອງໄດ້.
 Doctranslate API ຖືກສ້າງຂຶ້ນເພື່ອຈັດການສິ່ງນີ້ໄດ້ຢ່າງຄ່ອງແຄ້ວ, ໂດຍໃຊ້ UTF-8 encoding ຕະຫຼອດຂະບວນການທັງໝົດ.
 ນີ້ຊ່ວຍກໍາຈັດຄວາມສ່ຽງຂອງຄວາມເສຍຫາຍຂອງຕົວອັກສອນ, ຮັບປະກັນວ່າເຄື່ອງໝາຍພິເສດ ແລະ ສັນຍາລັກພິເສດທັງໝົດທີ່ເປັນເອກະລັກຂອງ ພາສາປອກຕຸຍການ ຖືກຮັກສາໄວ້ຢ່າງສົມບູນ.
ສໍາລັບນັກພັດທະນາ, ນີ້ໝາຍຄວາມວ່າທ່ານບໍ່ຈໍາເປັນຕ້ອງປະຕິບັດການກວດສອບການເຂົ້າລະຫັດທີ່ສັບສົນ ຫຼື logic ການປ່ຽນແປງໃນແອັບພລິເຄຊັນຂອງທ່ານເອງ.
 API ຮັບຜິດຊອບນີ້, ຮັບປະກັນວ່າຂໍ້ຄວາມໃນເອກະສານທີ່ດາວໂຫລດສຸດທ້າຍຂອງທ່ານຖືກສະແດງຢ່າງຖືກຕ້ອງ.
 ການຈັດການທີ່ເຂັ້ມແຂງນີ້ເຮັດໃຫ້ລະຫັດຂອງທ່ານງ່າຍຂຶ້ນ ແລະ ກໍາຈັດຈຸດລົ້ມເຫຼວທົ່ວໄປໃນຂັ້ນຕອນການເຮັດວຽກຂອງການແປ.
ຄວາມຖືກຕ້ອງທາງດ້ານບໍລິບົດ ແລະ ຄວາມເປັນທາງການ
ນໍ້າສຽງຂອງເອກະສານ—ບໍ່ວ່າຈະເປັນທາງການ ຫຼື ບໍ່ເປັນທາງການ—ແມ່ນສໍາຄັນສໍາລັບການສື່ສານທີ່ມີປະສິດທິຜົນ.
 ພາສາປອກຕຸຍການໃຊ້ຄໍາແທນນາມ ແລະ ການຜັນຄໍາກິລິຍາທີ່ແຕກຕ່າງກັນເພື່ອຖ່າຍທອດລະດັບຄວາມເປັນທາງການ, ເຊັ່ນ `tu` ທຽບກັບ `você`.
 ເຄື່ອງຈັກການແປທີ່ມີຄຸນນະພາບສູງ, ເຊັ່ນທີ່ນໍາໃຊ້ໂດຍ Doctranslate API, ຖືກຝຶກອົບຮົມໃນຊຸດຂໍ້ມູນຂະໜາດໃຫຍ່ເພື່ອເຂົ້າໃຈບໍລິບົດ.
ອັນນີ້ອະນຸຍາດໃຫ້ API ສ້າງການແປທີ່ເຄົາລົບນໍ້າສຽງຂອງເອກະສານຕົ້ນສະບັບ.
 ຕົວຢ່າງ, ມັນຈະໃຊ້ພາສາທີ່ເປັນທາງການສໍາລັບສັນຍາທຸລະກິດ ແລະ ນໍ້າສຽງທີ່ບໍ່ເປັນທາງການຫຼາຍຂຶ້ນສໍາລັບເອກະສານການຕະຫຼາດ.
 ຄວາມສະຫຼາດທາງດ້ານບໍລິບົດນີ້ຮັບປະກັນວ່າເອກະສານທີ່ແປແລ້ວບໍ່ພຽງແຕ່ຖືກຕ້ອງທາງດ້ານພາສາເທົ່ານັ້ນ ແຕ່ຍັງເໝາະສົມທາງດ້ານວັດທະນະທໍາ ແລະ ອາຊີບອີກດ້ວຍ.
ສະຫຼຸບ: ເຮັດໃຫ້ຂັ້ນຕອນການເຮັດວຽກການແປຂອງທ່ານຄ່ອງແຄ້ວຂຶ້ນ
ການເຊື່ອມໂຍງ API ເອກະສານ ພາສາອັງກິດ ເປັນ ພາສາປອກຕຸຍການ ສະໜອງວິທີແກ້ໄຂທີ່ມີປະສິດທິພາບສໍາລັບການເຮັດວຽກການແປທີ່ສັບສົນໂດຍອັດຕະໂນມັດ.
 ໂດຍການນໍາໃຊ້ບໍລິການສະເພາະເຊັ່ນ Doctranslate, ທ່ານສາມາດຂ້າມຜ່ານອຸປະສັກທາງດ້ານເຕັກນິກທີ່ສໍາຄັນຂອງການວິເຄາະໄຟລ໌, ການຮັກສາຮູບແບບ, ແລະ ລັກສະນະສະເພາະຂອງພາສາ.
 ນີ້ຊ່ວຍໃຫ້ທ່ານສາມາດສຸມໃສ່ເຫດຜົນຫຼັກຂອງແອັບພລິເຄຊັນຂອງທ່ານ ໃນຂະນະທີ່ສົ່ງເອກະສານທີ່ມີການຈັດຮູບແບບທີ່ສົມບູນແບບ ແລະ ແປໄດ້ຢ່າງຖືກຕ້ອງ.
ລັກສະນະ asynchronous ແລະ RESTful ຂອງ API ສະໜອງວິທີການທີ່ປັບຂະໜາດໄດ້ ແລະ ເຊື່ອຖືໄດ້ສໍາລັບການຈັດການເອກະສານທຸກຂະໜາດ.
 ດ້ວຍຄູ່ມືຂັ້ນຕອນໂດຍຂັ້ນຕອນ ແລະ ຕົວຢ່າງລະຫັດທີ່ໃຫ້ໄວ້, ທ່ານມີເສັ້ນທາງທີ່ຊັດເຈນໃນການປະຕິບັດການເຮັດວຽກນີ້ໃນໂຄງການຂອງທ່ານເອງ.
 ເພື່ອເຂົ້າໄປສູ່ຄວາມເລິກຂອງຕົວກໍານົດທີ່ມີຢູ່ທັງໝົດ ແລະ ຄຸນສົມບັດຂັ້ນສູງ, ພວກເຮົາຊຸກຍູ້ໃຫ້ທ່ານສໍາຫຼວດເອກະສານ Doctranslate API ຢ່າງເປັນທາງການ.