Nuitka
1.0.0
เอกสารนี้แนะนำให้อ่านครั้งแรกเมื่อคุณเริ่มใช้ Nuitka ในหน้านี้ คุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับพื้นฐาน ของ Nuitka เช่น ประเภทใบอนุญาต กรณีการใช้งาน ข้อกำหนด และเครดิต
สารบัญ
ความต้องการ
การใช้งาน
บทช่วยสอนการตั้งค่าและสร้างบน Windows
ใช้กรณี
ปรับแต่ง
ปัญหาทั่วไป
เคล็ดลับ
รายงานการรวบรวม
ผลงาน
ฟังก์ชันการทำงานที่ไม่รองรับ
Nuitka เป็น คอม ไพเลอร์ Python มันเขียนด้วยภาษาไพธอน มันเป็นการแทนที่หรือส่วนขยายอย่างราบรื่นสำหรับล่าม Python และคอมไพล์ ทุก โครงสร้างที่ Python 2 (2.6, 2.7) และ Python 3 (3.4 - 3.13) มีเมื่อรันด้วยเวอร์ชัน Python นั้น
จากนั้นจะรันโค้ดที่ไม่ได้คอมไพล์และโค้ดที่คอมไพล์แล้วร่วมกันในลักษณะที่เข้ากันได้อย่างยิ่ง
คุณสามารถใช้โมดูลไลบรารี Python ทั้งหมดและโมดูลส่วนขยายทั้งหมดได้อย่างอิสระ
Nuitka แปลโมดูล Python เป็นโปรแกรมระดับ C จากนั้นใช้ไฟล์ libpython และ static C ของตัวเองเพื่อดำเนินการในลักษณะเดียวกับที่ CPython ทำ
การเพิ่มประสิทธิภาพทั้งหมดมีจุดมุ่งหมายเพื่อหลีกเลี่ยงค่าใช้จ่ายที่ไม่จำเป็น ไม่มีจุดมุ่งหมายที่จะลบความเข้ากันได้ แม้ว่าการปรับปรุงเล็กน้อยจะดำเนินการในบางครั้ง โดยที่ไม่ได้มีการจำลองข้อบกพร่องของ Python มาตรฐานทุกรายการ เช่น มีข้อความแสดงข้อผิดพลาดที่สมบูรณ์มากขึ้น แต่มีโหมดความเข้ากันได้เต็มรูปแบบที่จะปิดใช้งานแม้ว่าจะเป็นเช่นนั้นก็ตาม
เพื่อให้การทำงานของ Nuitka ราบรื่น โปรดปฏิบัติตามข้อกำหนดของระบบ ซึ่งรวมถึงส่วนประกอบต่อไปนี้:
ซีคอมไพเลอร์
หลาม
ระบบปฏิบัติการ
สถาปัตยกรรม
คุณต้องมีคอมไพเลอร์ C ที่รองรับ C11 หรือคอมไพเลอร์ C++ สำหรับ C++03 [1]
ในปัจจุบัน หมายความว่า คุณต้องใช้หนึ่งในคอมไพเลอร์เหล่านี้:
คอมไพเลอร์ MinGW64 C11 บน Windows ต้องใช้ gcc 11.2 หรือสูงกว่า มันจะถูกดาวน์โหลด โดยอัตโนมัติ หากไม่พบคอมไพเลอร์ C ที่ใช้งานได้ ซึ่งเป็นวิธีการติดตั้งที่แนะนำ เนื่องจาก Nuitka จะอัปเกรดให้คุณด้วย
Visual Studio 2022 หรือสูงกว่าบน Windows [2] ชุดภาษาอังกฤษเพื่อผลลัพธ์ที่ดีที่สุด (Nuitka กรองผลลัพธ์ขยะออกไป แต่สำหรับภาษาอังกฤษเท่านั้น) มันจะถูกใช้เป็นค่าเริ่มต้นหากติดตั้ง
บนแพลตฟอร์มอื่นๆ ทั้งหมด คอมไพเลอร์ gcc เวอร์ชันอย่างน้อย 5.1 และต่ำกว่านั้นคอมไพเลอร์ g++ เวอร์ชันอย่างน้อย 4.4 เป็นทางเลือก
คอมไพเลอร์ clang บน macOS X และสถาปัตยกรรม FreeBSD ส่วนใหญ่
บน Windows สามารถใช้คอมไพเลอร์ clang-cl บน Windows ได้หากมีให้โดยตัวติดตั้ง Visual Studio
| [1] | รองรับ C11 นี้ด้วย gcc 5.x หรือสูงกว่าหรือเวอร์ชันเสียงดังกราว คอมไพเลอร์ MSVC รุ่นเก่ายังไม่ทำ แต่สำหรับวิธีแก้ปัญหาด้วย Python 3.10 หรือเก่ากว่านั้น มาตรฐานภาษา C++03 ทับซ้อนกับ C11 อย่างมาก จากนั้นจึงใช้แทน |
| [2] | ดาวน์โหลดฟรีจาก https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx (รุ่นชุมชนทำงานได้ดี) แนะนำให้ใช้เวอร์ชันล่าสุด แต่ไม่จำเป็น ในทางกลับกัน ไม่จำเป็นต้องยกเว้นการรองรับเวอร์ชันก่อน Windows 10 และอาจใช้ได้ผลสำหรับคุณ แต่การรองรับการกำหนดค่าเหล่านี้มีให้สำหรับผู้ใช้เชิงพาณิชย์เท่านั้น |
รองรับ Python 2 (2.6, 2.7) และ Python 3 (3.4 — 3.13) หากมีเวอร์ชัน Python ที่เสถียรซึ่งไม่อยู่ในรายการนี้ โปรดมั่นใจได้ว่าอยู่ในระหว่างดำเนินการและจะถูกเพิ่มเข้าไป
สำคัญ
สำหรับ Python 3.4 และเวอร์ชันนั้น เท่านั้น เราจำเป็นต้องมีเวอร์ชัน Python อื่นเป็นการพึ่งพา เวลาคอมไพล์
Nuitka นั้นเข้ากันได้กับเวอร์ชันที่ระบุไว้ทั้งหมดอย่างสมบูรณ์ แต่ Scons เนื่องจากเป็นเครื่องมือที่ใช้ภายในไม่รองรับ
สำหรับเวอร์ชันเหล่านี้ คุณ ต้อง ติดตั้ง Python2 หรือ Python 3.5 หรือสูงกว่าด้วย แต่เฉพาะในช่วงเวลาคอมไพล์เท่านั้น นั่นสำหรับใช้กับ Scons (ซึ่งจัดเตรียมการคอมไพล์ C) ซึ่งไม่รองรับ Python เวอร์ชันเดียวกันกับ Nuitka
นอกจากนี้บน Windows ไม่สามารถใช้ Python2 ได้เนื่องจาก clcache ไม่สามารถใช้งานได้ จำเป็นต้องติดตั้ง Python 3.5 หรือสูงกว่า
Nuitka พบเวอร์ชัน Python ที่จำเป็นเหล่านี้ (เช่นบน Windows ผ่านทางรีจิสตรี) และคุณไม่ควรสังเกตเห็นตราบใดที่ติดตั้งไว้
ฟังก์ชันอื่นๆ จะพร้อมใช้งานมากขึ้นเมื่อ Python อื่นติดตั้งแพ็คเกจบางอย่างไว้ ตัวอย่างเช่น การบีบอัดไฟล์เดียวจะทำงานสำหรับ Python 2.x เมื่อพบ Python อื่นที่ติดตั้งแพ็คเกจ zstandard
การย้ายไบนารีไปยังเครื่องอื่น
ไบนารีที่สร้างขึ้นสามารถเรียกใช้งานได้โดยไม่ขึ้นอยู่กับการติดตั้ง Python ด้วยตัวเลือก --standalone และ --onefile
ส่วนต่อท้ายชื่อไฟล์ไบนารี
ไบนารีที่สร้างขึ้นมีส่วนต่อท้าย .exe บน Windows บนแพลตฟอร์มอื่น ไม่มีส่วนต่อท้ายสำหรับโหมดสแตนด์อโลนหรือส่วนต่อท้าย .bin ซึ่งคุณสามารถลบหรือเปลี่ยนแปลงได้อย่างอิสระ หรือระบุด้วยตัวเลือก -o
มีการเพิ่มส่วนต่อท้ายสำหรับโหมดการเร่งความเร็วเพื่อให้แน่ใจว่าชื่อสคริปต์ต้นฉบับและชื่อไบนารีจะไม่ขัดแย้งกัน ดังนั้นเราจึงสามารถเขียนทับไบนารี่ได้อย่างปลอดภัยโดยไม่ทำลายไฟล์ต้นฉบับ
ต้อง เป็น CPython, Anaconda Python หรือ Homebrew
คุณต้องมีการใช้งาน Python มาตรฐานที่เรียกว่า "CPython" เพื่อรัน Nuitka เพราะมันเชื่อมโยงอย่างใกล้ชิดกับรายละเอียดการใช้งานของมัน
ไม่สามารถมา จาก Windows App Store ได้
เป็นที่ทราบกันว่า Python ของ Windows App Store ใช้งานไม่ได้อย่างแน่นอน แต่มีการตรวจสอบแล้ว
ไม่สามารถ pyenv บน macOS ได้
เป็นที่ทราบกันว่า macOS "pyenv" ไม่ ทำงาน ใช้ Homebrew แทนสำหรับการติดตั้ง Python ที่คอมไพล์เอง แต่โปรดทราบว่าโหมดสแตนด์อโลนจะแย่กว่าบนแพลตฟอร์มเหล่านี้และไม่สามารถใช้งานร่วมกับ macOS เวอร์ชันเก่าได้
ระบบปฏิบัติการที่รองรับ: Linux, FreeBSD, NetBSD, macOS และ Windows (32 บิต/64 บิต/ARM)
คนอื่นก็จะทำงานเช่นกัน โดยทั่วไปแล้ว ความสามารถในการพกพาจะดี แต่เช่น การใช้งาน Scons ภายในของ Nuitka อาจต้องปรับเปลี่ยนหรือต้องส่งแฟล็ก ตรวจสอบให้แน่ใจว่าตรงกับสถาปัตยกรรมคอมไพเลอร์ Python และ C ไม่เช่นนั้นคุณจะได้รับข้อความแสดงข้อผิดพลาดที่เป็นความลับ
สถาปัตยกรรมที่รองรับคือ x86, x86_64 (amd64) และ arm และอีกมากมาย
สถาปัตยกรรมอื่นๆ คาดว่าจะใช้งานได้ตั้งแต่แกะกล่อง เนื่องจากโดยทั่วไปแล้ว Nuitka ไม่ได้ใช้ฮาร์ดแวร์เฉพาะใดๆ นี่เป็นเพียงผลิตภัณฑ์ที่ได้รับการทดสอบและทราบว่าดี ข้อเสนอแนะยินดีต้อนรับ โดยทั่วไปแล้ว สถาปัตยกรรมที่ Debian รองรับก็ถือว่าดีและผ่านการทดสอบเช่นกัน
วิธีที่แนะนำในการรัน Nuitka คือ <the_right_python> -m nuitka เพื่อให้แน่ใจว่าคุณใช้ล่าม Python ตัวไหน ดังนั้นจึงง่ายกว่าที่จะจับคู่กับสิ่งที่ Nuitka มี
วิธีที่ดีที่สุดถัดไปในการดำเนินการ Nuitka bare ที่มาจากการชำระเงินต้นทางหรือการเก็บถาวร โดยไม่มีการเปลี่ยนแปลงตัวแปรสภาพแวดล้อม สิ่งที่สำคัญที่สุดคือคุณไม่จำเป็นต้องยุ่งกับ PYTHONPATH เลยสำหรับ Nuitka คุณเพียงแค่รันสคริปต์ nuitka และ nuitka-run โดยตรงโดยไม่มีการเปลี่ยนแปลงสภาพแวดล้อม คุณอาจต้องการเพิ่มไดเร็กทอรี bin ให้กับ PATH ของคุณเพื่อความสะดวกของคุณ แต่ขั้นตอนนั้นเป็นทางเลือก
ยิ่งไปกว่านั้น หากคุณต้องการดำเนินการด้วยล่ามที่ถูกต้อง ในกรณีนี้ ต้องแน่ใจว่าได้รัน <the_right_python> bin/nuitka และทำได้ดี
เลือกล่ามที่เหมาะสม
หากคุณพบ SyntaxError แสดงว่าคุณได้เลือกล่ามผิดสำหรับโปรแกรมที่คุณกำลังคอมไพล์
Nuitka มีตัวเลือก --help เพื่อส่งออกสิ่งที่สามารถทำได้:
นุ้ยกะ --ช่วยด้วย
คำสั่ง nuitka-run เหมือนกับ nuitka แต่มีค่าเริ่มต้นอื่น มันพยายามรวบรวม และ รันสคริปต์ Python โดยตรง:
นุ้ยกะรัน --help
ตัวเลือกนี้ที่แตกต่างออกไปคือ --run และส่งต่ออาร์กิวเมนต์หลังจากตัวเลือกแรกที่ไม่ใช่ตัวเลือกไปยังไบนารีที่สร้างขึ้น ดังนั้นจึงค่อนข้างคล้ายกับสิ่งที่ python ธรรมดาจะทำมากกว่า
สำหรับระบบส่วนใหญ่ จะมีแพ็คเกจอยู่ที่หน้าดาวน์โหลดของ Nuitka แต่คุณยังสามารถติดตั้งได้จากซอร์สโค้ดตามที่อธิบายไว้ข้างต้น แต่ก็เหมือนกับโปรแกรม Python อื่นๆ ที่สามารถติดตั้งผ่านรูทีน python setup.py install ปกติ
ประกาศสำหรับการผสานรวมกับเวิร์กโฟลว์ GitHub มี Nuitka-Action ที่คุณควรใช้ซึ่งทำให้ง่ายต่อการรวมเข้าด้วยกัน คุณควรเริ่มต้นด้วยการรวบรวมในเครื่อง แต่จะง่ายที่สุดสำหรับการรวบรวมข้ามแพลตฟอร์มกับ Nuitka
Nuitka ได้รับอนุญาตภายใต้ Apache License เวอร์ชัน 2.0; คุณไม่สามารถใช้มันได้เว้นแต่จะเป็นไปตามใบอนุญาต
คุณสามารถขอรับสำเนาใบอนุญาตได้ที่ http://www.apache.org/licenses/LICENSE-2.0
เว้นแต่กฎหมายที่ใช้บังคับกำหนดหรือตกลงเป็นลายลักษณ์อักษร ซอฟต์แวร์ที่เผยแพร่ภายใต้ใบอนุญาตนี้จะถูกแจกจ่าย "ตามที่เป็น" โดยไม่มีการรับประกันหรือเงื่อนไขใดๆ ทั้งโดยชัดแจ้งหรือโดยนัย ดูใบอนุญาตสำหรับภาษาเฉพาะที่ควบคุมการอนุญาตและข้อจำกัดภายใต้ใบอนุญาต
นี่เป็นขั้นตอนพื้นฐานหากคุณไม่ได้ติดตั้งอะไรเลย แน่นอนว่าหากคุณมีชิ้นส่วนใด ๆ ก็ข้ามไปได้เลย
ดาวน์โหลดและติดตั้ง Python จาก https://www.python.org/downloads/windows
เลือก Windows x86-64 web-based installer (แนะนำให้ใช้ Python 64 บิต) หรือตัวติดตั้ง x86 executable (Python 32 บิต)
ตรวจสอบว่ามันใช้งานได้โดยใช้คำสั่ง python --version
python -m pip install nuitka
ตรวจสอบโดยใช้คำสั่ง python -m nuitka --version
mkdir สวัสดีโลก
สร้างไฟล์หลามชื่อ hello.py
def talk (ข้อความ): return "Talk " + messagedef main():print(talk("Hello World"))if __name__ == "__main__":main()ทำตามที่คุณทำตามปกติ การเรียกใช้ Nuitka บนโค้ดที่ทำงานไม่ถูกต้องนั้นไม่ใช่เรื่องง่ายที่จะแก้ไขข้อบกพร่อง
หลาม hello.py
หลาม -m nuitka hello.py
บันทึก
ซึ่งจะแจ้งให้คุณดาวน์โหลดเครื่องมือแคช C (เพื่อเพิ่มความเร็วในการคอมไพล์โค้ด C ที่สร้างขึ้นซ้ำ) และคอมไพเลอร์ C ที่ใช้ MinGW64 เว้นแต่คุณจะติดตั้ง MSVC ที่เหมาะสม ตอบว่า yes กับทั้งสองคำถามเหล่านั้น
ดำเนินการ hello.exe ที่สร้างขึ้นใกล้กับ hello.py
หากต้องการแจกจ่าย ให้สร้างด้วยตัวเลือก --standalone ซึ่งจะไม่ส่งออกไฟล์ปฏิบัติการเพียงไฟล์เดียว แต่เป็นทั้งโฟลเดอร์ คัดลอกโฟลเดอร์ hello.dist ที่ได้ไปยังเครื่องอื่นแล้วรัน
คุณอาจลอง --onefile ซึ่งสร้างไฟล์เดียว แต่ต้องแน่ใจว่าไฟล์แบบสแตนด์อโลนนั้นใช้งานได้ ก่อนที่จะเปลี่ยนมาใช้มัน เนื่องจากจะทำให้การดีบักยากขึ้นเท่านั้น เช่น ในกรณีที่ไฟล์ข้อมูลหายไป
หากคุณต้องการคอมไพล์ทั้งโปรแกรมแบบวนซ้ำ และไม่ใช่แค่ไฟล์เดียวที่เป็นโปรแกรมหลัก ให้ทำดังนี้:
python -m nuitka --follow-imports program.py
บันทึก
มีการควบคุมที่ละเอียดมากกว่า --follow-imports ที่พร้อมใช้งาน พิจารณาผลลัพธ์ของ nuitka --help การรวมโมดูลน้อยลงในการคอมไพล์ แต่แทนที่จะใช้ Python ปกติแทน จะทำให้คอมไพล์เร็วขึ้น
ในกรณีที่คุณมีไดเร็กทอรีต้นทางที่มีไฟล์ที่โหลดแบบไดนามิก เช่น ไดเร็กทอรีที่ไม่สามารถพบได้โดยการเรียกซ้ำหลังจากคำสั่งนำเข้าปกติผ่าน PYTHONPATH (ซึ่งเป็นวิธีที่แนะนำ) คุณสามารถกำหนดให้ไดเร็กทอรีที่ระบุจะต้องรวมอยู่ในไดเร็กทอรีนั้นด้วย ปฏิบัติการได้:
python -m nuitka --follow-imports --include-plugin-directory=plugin_dir program.py
บันทึก
หากคุณไม่ได้ทำการนำเข้าแบบไดนามิกใดๆ เพียงแค่ตั้งค่า PYTHONPATH ณ เวลารวบรวมคือสิ่งที่คุณควรทำ
ใช้ --include-plugin-directory เฉพาะเมื่อคุณทำการ __import__() โทรที่ Nuitka ไม่สามารถคาดเดาได้ และที่มาจากไดเรกทอรี สำหรับทุกสิ่งจากการติดตั้ง Python ของคุณ ให้ใช้ --include-module หรือ --include-package
บันทึก
ชื่อไฟล์ที่ได้จะเป็น program.exe บน Windows, program.bin บนแพลตฟอร์มอื่น ๆ แต่ --output-filename อนุญาตให้เปลี่ยนแปลงได้
บันทึก
ไบนารีที่ได้ผลลัพธ์ยังคงขึ้นอยู่กับ CPython และโมดูลส่วนขยาย C ที่ใช้ที่ติดตั้งอยู่
หากคุณต้องการคัดลอกไปยังเครื่องอื่น ให้ใช้ --standalone และคัดลอกไดเร็กทอรี program.dist ที่สร้างขึ้น และรัน program.exe (Windows) หรือ program (แพลตฟอร์มอื่น) ที่ใส่ไว้ภายใน
หากคุณต้องการคอมไพล์โมดูลส่วนขยายเดียว สิ่งที่คุณต้องทำคือ:
หลาม -m nuitka --โมดูล some_module.py
ไฟล์ผลลัพธ์ some_module.so สามารถใช้แทน some_module.py ได้
สำคัญ
ชื่อไฟล์ของโมดูลส่วนขยายที่ผลิตจะต้องไม่เปลี่ยนแปลงเนื่องจาก Python ยืนยันในฟังก์ชันที่ได้รับชื่อโมดูลเป็นจุดเริ่มต้น ในกรณีนี้ PyInit_some_module และการเปลี่ยนชื่อไฟล์จะไม่เปลี่ยนสิ่งนั้น จับคู่ชื่อไฟล์ของซอร์สโค้ดกับชื่อไบนารีที่ควรเป็น
บันทึก
หากทั้งโมดูลส่วนขยายและซอร์สโค้ดอยู่ในไดเร็กทอรีเดียวกัน โมดูลส่วนขยายจะถูกโหลด การเปลี่ยนแปลงซอร์สโค้ดจะมีผลเมื่อคุณคอมไพล์ใหม่เท่านั้น
บันทึก
ตัวเลือก --follow-import-to ก็ใช้งานได้เช่นกัน แต่โมดูลที่รวมไว้จะสามารถนำเข้าได้ หลังจากที่ คุณนำเข้าชื่อ some_module เท่านั้น หาก Nuitka มองไม่เห็นการนำเข้าประเภทนี้ เช่น สร้างขึ้นแบบไดนามิก คุณสามารถใช้ --include-module หรือ --include-package ในกรณีนั้น แต่สำหรับการนำเข้าแบบคงที่ ก็ไม่จำเป็น
บันทึก
โมดูลส่วนขยายไม่สามารถรวมโมดูลส่วนขยายอื่นๆ ได้ คุณจะต้องสร้างวงล้อเพื่อให้สิ่งนี้เป็นไปได้
บันทึก
โมดูลส่วนขยายผลลัพธ์สามารถโหลดลงใน CPython เวอร์ชันเดียวกันได้เท่านั้น และไม่รวมโมดูลส่วนขยายอื่นๆ
หากคุณต้องการคอมไพล์แพ็คเกจทั้งหมดและฝังโมดูลทั้งหมด ก็เป็นไปได้เช่นกัน ให้ใช้ Nuitka ดังนี้:
หลาม -m nuitka --โมดูล some_package --include-package=some_package
บันทึก
จำเป็นต้องมีการรวมเนื้อหาแพ็คเกจด้วยตนเอง มิฉะนั้น แพ็คเกจจะว่างเปล่าเป็นส่วนใหญ่ คุณสามารถระบุให้เจาะจงมากขึ้นได้หากต้องการ และรวมเฉพาะบางส่วนเท่านั้น หรือไม่รวมบางส่วน เช่น ด้วย --nofollow-import-to='*.tests' คุณจะไม่รวมส่วนทดสอบที่ไม่ได้ใช้ของโค้ดของคุณ
บันทึก
ไฟล์ข้อมูลที่อยู่ในแพ็คเกจจะไม่ถูกฝังโดยกระบวนการนี้ คุณต้องคัดลอกด้วยตนเองด้วยวิธีนี้ หรือคุณสามารถใช้ไฟล์ฝังโฆษณา Nuitka ได้
สำหรับการแจกจ่ายไปยังระบบอื่น จะมีโหมดสแตนด์อโลนซึ่งสร้างโฟลเดอร์ที่คุณสามารถระบุ --standalone
python -m nuitka --standalone program.py
การติดตามการนำเข้าทั้งหมดจะเป็นค่าเริ่มต้นในโหมดนี้ คุณสามารถเลือกแยกโมดูลได้โดยการพูดว่า --nofollow-import-to โดยเฉพาะ แต่จากนั้น ImportError จะเพิ่มขึ้นเมื่อมีการพยายามนำเข้าในขณะรันโปรแกรม นี่อาจทำให้เกิดพฤติกรรมที่แตกต่างออกไป แต่ก็อาจปรับปรุงเวลาในการคอมไพล์ของคุณได้เช่นกันหากทำอย่างชาญฉลาด
หากต้องการรวมไฟล์ข้อมูล ให้ใช้อ็อพชัน --include-data-files=<source>=<target> โดยที่ต้นทางเป็นพาธของระบบไฟล์ แต่ต้องระบุเป้าหมายแบบสัมพันธ์กัน สำหรับโหมดสแตนด์อโลน คุณสามารถคัดลอกด้วยตนเองได้ แต่สามารถตรวจสอบเพิ่มเติมได้ และสำหรับโหมด onefile จะไม่มีการคัดลอกด้วยตนเอง
หากต้องการคัดลอกไฟล์บางส่วนหรือทั้งหมดในไดเร็กทอรี ให้ใช้ตัวเลือก --include-data-files=/etc/*.txt=etc/ โดยที่คุณจะระบุรูปแบบเชลล์สำหรับไฟล์ และไดเร็กทอรีย่อยที่จะวางไฟล์เหล่านั้น ตามที่ระบุไว้ โดยเครื่องหมายทับต่อท้าย
สำคัญ
Nuitka ไม่ถือว่าโค้ดไฟล์ข้อมูล ไม่รวมไฟล์ DLL หรือไฟล์ Python เป็นไฟล์ข้อมูล และคาดหวังให้ไฟล์เหล่านั้นใช้งานได้ ไฟล์เหล่านั้นจะไม่ทำงาน เว้นแต่คุณจะรู้จริงๆ ว่าคุณกำลังทำอะไรอยู่
ต่อไปนี้ ไฟล์ข้อมูลที่ไม่ใช่โค้ดคือไฟล์ทั้งหมด ซึ่งไม่ตรงกับเกณฑ์เหล่านี้
| คำต่อท้าย | เหตุผล | สารละลาย |
|---|---|---|
.py | Nuitka ตัดแต่งแม้กระทั่งโมดูล stdlib ที่จะรวมไว้ หากไม่เห็นโค้ด Python แสดงว่าไม่มีการวิเคราะห์การขึ้นต่อกัน และด้วยเหตุนี้จึงไม่ทำงาน | ใช้ --include-module กับพวกเขาแทน |
.pyc | เช่นเดียวกับ . .py | ใช้ --include-module กับพวกเขาจากซอร์สโค้ดแทน |
.pyo | เช่นเดียวกับ .pyc | ใช้ --include-module กับพวกเขาจากซอร์สโค้ดแทน |
.pyw | เช่นเดียวกับ . .py | หากต้องการรวมหลายโปรแกรม ให้ใช้ --main อาร์กิวเมนต์หลายรายการแทน |
.pyi | สิ่งเหล่านี้จะถูกละเว้น เนื่องจากมีลักษณะเหมือนโค้ดและไม่จำเป็นในขณะรันไทม์ สำหรับแพ็คเกจ lazy ที่จริงๆ แล้วจะขึ้นอยู่กับแพ็คเกจเหล่านั้น เราได้จัดทำโซลูชันเวลาคอมไพล์ที่ขจัดความจำเป็นออกไป | แจ้งปัญหาหากซอฟต์แวร์ส่วนที่ 3 จำเป็นต้องใช้ |
.pyx | สิ่งเหล่านี้จะถูกละเว้น เนื่องจากเป็นซอร์สโค้ด Cython ที่ไม่ได้ใช้ในขณะรันไทม์ | |
.dll | สิ่งเหล่านี้จะถูกละเว้น เนื่องจาก โดยปกติแล้ว ไม่ใช่ไฟล์ข้อมูล สำหรับกรณีที่แพ็คเกจของบุคคลที่สามนำไปใช้จริงเป็นข้อมูล เช่น แพ็คเกจ .NET เราจะแก้ไขสิ่งนั้นในการกำหนดค่าแพ็คเกจ | สร้างการกำหนดค่า Nuitka Package สำหรับสิ่งเหล่านั้น โดยมีส่วน dll สำหรับแพ็คเกจที่ใช้งาน ในบางกรณีที่เกิดขึ้นไม่บ่อยนัก ส่วนไฟล์ข้อมูลที่มีการกำหนดค่าพิเศษอาจเป็นสิ่งที่ถูกต้อง |
.dylib | สิ่งเหล่านี้จะถูกละเว้น เนื่องจากเป็นโมดูลส่วนขยายของ macOS หรือ DLL | จำเป็นต้องเพิ่มการกำหนดค่าด้วยส่วน dll หรือ depends ส่วนที่ขาดหายไป |
.so | สิ่งเหล่านี้จะถูกละเว้น เนื่องจากเป็นโมดูลส่วนขยาย Linux, BSD ฯลฯ หรือ DLL | จำเป็นต้องเพิ่มการกำหนดค่าด้วยส่วน dll หรือ depends ส่วนที่ขาดหายไป |
.exe | เป็นไบนารี่ของ Windows | คุณสามารถเพิ่มการกำหนดค่า Nuitka Package เพื่อรวมสิ่งเหล่านั้นเป็น DLL และทำเครื่องหมายว่า executable: yes |
.bin | เป็นไบนารีที่ไม่ใช่ Windows มิฉะนั้นจะเหมือนกับ .exe |
นอกจากนี้โฟลเดอร์ต่างๆ จะถูกละเว้น ซึ่งได้แก่ site-packages , dist-packages และ vendor-packages มิฉะนั้นจะรวม virtualenv แบบเต็ม ซึ่งไม่เคยเป็นสิ่งที่ดีที่จะเกิดขึ้น และโฟลเดอร์ __pycache__ ก็จะถูกละเว้นเช่นกัน บนระบบปฏิบัติการที่ไม่ใช่ MacOS ไฟล์ . .DS_Store จะถูกละเว้นเช่นกัน และโฟลเดอร์ py.typed มีความหมายเฉพาะกับ IDE เท่านั้น และจะถูกละเว้นเช่นเดียวกับไฟล์ .pyi
หากต้องการคัดลอกทั้งโฟลเดอร์ด้วยไฟล์ที่ไม่ใช่โค้ดทั้งหมด คุณสามารถใช้ --include-data-dir=/path/to/images=images ซึ่งจะวางไฟล์เหล่านั้นไว้ในปลายทาง และหากคุณต้องการใช้ --noinclude-data-files ตัวเลือก --noinclude-data-files เพื่อลบออก ไฟล์โค้ดจะมีรายละเอียดตามรายละเอียดข้างต้น DLL, ไฟล์ปฏิบัติการ, ไฟล์ Python ฯลฯ และจะถูกละเว้น สำหรับผู้ที่คุณสามารถใช้ --include-data-files=/binaries/*.exe=binary/ แบบฟอร์มเพื่อบังคับ แต่ไม่แนะนำและทราบว่าทำให้เกิดปัญหาในขณะรันไทม์
สำหรับข้อมูลแพ็คเกจ มีวิธีที่ดีกว่าคือการใช้ --include-package-data ซึ่งจะตรวจจับไฟล์ข้อมูลที่ไม่ใช่โค้ดทั้งหมดของแพ็คเกจโดยอัตโนมัติและคัดลอกมันไป มันยังรับลวดลายในรูปแบบเปลือกหอยด้วย ช่วยให้คุณไม่ต้องค้นหาไดเร็กทอรีแพ็คเกจด้วยตัวเอง และควรเลือกใช้ทุกครั้งที่มี ในทางปฏิบัติมันคล้ายกับ --include-data-dir มาก แต่มีประโยชน์ในการค้นหาโฟลเดอร์ที่ถูกต้องสำหรับคุณ
ด้วยไฟล์ข้อมูล คุณส่วนใหญ่ต้องอยู่คนเดียว Nuitka ติดตามสิ่งที่จำเป็นสำหรับแพ็คเกจยอดนิยม แต่อาจไม่สมบูรณ์ แจ้งปัญหาหากคุณพบบางสิ่งในสิ่งเหล่านี้ ยิ่งไปกว่านั้น ยกระดับ PR ด้วยการปรับปรุงการกำหนดค่าแพ็คเกจ Nuitka เราต้องการให้ซอฟต์แวร์ของบุคคลที่สามทำงานนอกกรอบ
เมื่อได้ผล คุณสามารถใช้โหมด onefile ได้หากต้องการ
หลาม -m nuitka --onefile program.py
สิ่งนี้จะสร้างไบนารีเดี่ยวที่จะแยกตัวเองออกจากเป้าหมายก่อนที่จะรันโปรแกรม แต่โปรดสังเกตว่าการเข้าถึงไฟล์ที่เกี่ยวข้องกับโปรแกรมของคุณได้รับผลกระทบ โปรดอ่านหัวข้อ Onefile: การค้นหาไฟล์ ด้วยเช่นกัน
# สร้างไบนารีที่คลายลงในโฟลเดอร์ชั่วคราว python -m nuitka --onefile program.py
บันทึก
มีตัวเลือกเฉพาะแพลตฟอร์มเพิ่มเติม เช่น ที่เกี่ยวข้องกับไอคอน หน้าจอเริ่มต้น และข้อมูลเวอร์ชัน ลองพิจารณาเอาต์พุต --help สำหรับรายละเอียดเหล่านี้ และตรวจสอบส่วนการปรับแต่ง
สำหรับการแตกไฟล์ โดยค่าเริ่มต้นจะใช้เส้นทางชั่วคราวของผู้ใช้ที่ไม่ซ้ำใคร จากนั้นจึงลบออก อย่างไรก็ตาม ค่าเริ่มต้น --onefile-tempdir-spec="{TEMP}/onefile_{PID}_{TIME}" สามารถแทนที่ได้ด้วยเส้นทาง จากนั้นใช้เส้นทางที่แคชไว้ หลีกเลี่ยงการคลายแพ็กซ้ำ เช่น ด้วย --onefile-tempdir-spec="{CACHE_DIR}/{COMPANY}/{PRODUCT}/{VERSION}" ซึ่งใช้ข้อมูลเวอร์ชัน และ ไดเร็กทอรีแคชเฉพาะผู้ใช้
บันทึก
การใช้เส้นทางที่แคชไว้จะมีความเกี่ยวข้อง เช่น เมื่อ Windows Firewall เข้ามามีบทบาท เพราะไม่เช่นนั้น ไบนารี่จะแตกต่างออกไปในแต่ละครั้งที่มีการเรียกใช้
ปัจจุบันโทเค็นขยายเหล่านี้พร้อมใช้งาน:
| โทเค็น | สิ่งนี้ขยายไปถึง | ตัวอย่าง |
|---|---|---|
| {อุณหภูมิ} | ไดเร็กทอรีไฟล์ชั่วคราวของผู้ใช้ | C:ผู้ใช้...AppDataLocalsTemp |
| {รหัส} | รหัสกระบวนการ | 2772 |
| {เวลา} | เวลาเป็นวินาทีนับตั้งแต่ยุค | 1299852985 |
| {โปรแกรม} | ชื่อไฟล์รันไทม์ของโปรแกรมแบบเต็มของไฟล์ปฏิบัติการ | C:SomeWhereYourOnefile.exe |
| {โปรแกรม_ฐาน} | ไม่มีส่วนต่อท้ายของชื่อไฟล์รันไทม์ของปฏิบัติการ | C:SomewhereYourOnefile |
| {CACHE_DIR} | ไดเร็กทอรีแคชสำหรับผู้ใช้ | C: UsersSomeBodyAppDataLocal |
| {บริษัท} | ค่าที่กำหนดเป็น --company-name | ชื่อบริษัทของคุณ |
| {ผลิตภัณฑ์} | ค่าที่กำหนดเป็น --product-name | ชื่อผลิตภัณฑ์ของคุณ |
| {เวอร์ชัน} | การรวมกันของ --file-version และ --product-version | 3.0.0.0-1.0.0.0 |
| {บ้าน} | โฮมไดเร็กทอรีสำหรับผู้ใช้ | /home/ใครสักคน |
| {ไม่มี} | เมื่อระบุสำหรับเอาต์พุตไฟล์ ระบบจะใช้ None | ดูประกาศด้านล่าง |
| {โมฆะ} | เมื่อระบุสำหรับเอาต์พุตไฟล์ os.devnull จะถูกใช้ | ดูประกาศด้านล่าง |
สำคัญ
เป็นความรับผิดชอบของคุณที่จะต้องทำให้เส้นทางที่ระบุไม่ซ้ำกัน บน Windows โปรแกรมที่ทำงานอยู่จะถูกล็อค และในขณะที่ใช้ชื่อโฟลเดอร์คงที่นั้นเป็นไปได้ แต่ก็อาจทำให้เกิดปัญหาการล็อคได้ในกรณีนั้น ซึ่งเป็นจุดที่โปรแกรมถูกรีสตาร์ท
โดยปกติ คุณจะต้องใช้ {TIME} หรืออย่างน้อย {PID} เพื่อสร้างเส้นทางที่ไม่ซ้ำใคร และสิ่งนี้มีไว้สำหรับกรณีการใช้งานเป็นหลัก โดยที่ เช่น คุณต้องการให้สิ่งต่าง ๆ อยู่ในสถานที่ที่คุณเลือกหรือปฏิบัติตามแบบแผนการตั้งชื่อของคุณ
สำคัญ
สำหรับการปิดการใช้งานเอาต์พุตและ stderr ด้วย --force-stdout-spec และ --force-stderr-spec ค่า {NONE} และ {NULL} บรรลุผลสำเร็จ แต่มีเอฟเฟกต์ที่แตกต่างกัน ด้วย {NONE} หมายเลขอ้างอิงที่เกี่ยวข้องจะกลายเป็น None เป็นผลให้เช่น sys.stdout จะเป็น None ซึ่งแตกต่างจาก {NULL} ซึ่งจะได้รับการสำรองข้อมูลโดยไฟล์ที่ชี้ไปที่ os.devnull นั่นคือคุณสามารถเขียนลงไปได้
ด้วย {NONE} คุณอาจได้รับ RuntimeError: lost sys.stdout ในกรณีที่มันถูกใช้ ด้วย {NULL} ที่ไม่เคยเกิดขึ้น อย่างไรก็ตาม ไลบรารีบางแห่งจัดการสิ่งนี้เป็นอินพุตสำหรับกลไกการบันทึก และบน Windows นี่คือวิธีที่คุณเข้ากันได้กับ pythonw.exe ซึ่งมีพฤติกรรมเหมือน {NONE}
หากคุณมี setup.py , setup.cfg หรือ pyproject.toml ขับเคลื่อนการสร้างวงล้อสำหรับซอฟต์แวร์ของคุณ การใช้ Nuitka เป็นเรื่องง่ายมาก
เริ่มจากแนวทาง setuptools ที่ใช้บ่อยที่สุด ซึ่งแน่นอนว่าเมื่อติดตั้ง Nuitka แล้ว ก็แค่รันเป้าหมาย bdist_nuitka แทนที่จะเป็น bdist_wheel ใช้ตัวเลือกทั้งหมดและอนุญาตให้คุณระบุเพิ่มเติมบางอย่างที่เกี่ยวข้องกับ Nuitka โดยเฉพาะ
# สำหรับ setup.py หากคุณไม่ได้ใช้ระบบบิลด์อื่น:setup( # ไฟล์ข้อมูลจะต้องได้รับการจัดการโดย setuptools ไม่ใช่ Nuitka
package_data={"some_package": ["some_file.txt"]},
..., #นี่คือการผ่านตัวเลือก Nuitka
command_options={ 'nuitka': { # ตัวเลือกบูลีน เช่น หากคุณสนใจคำสั่งการคอมไพล์ C '--show-scons': จริง, # ตัวเลือกที่ไม่มีค่า เช่น บังคับใช้โดยใช้ Clang '--clang': ไม่มี, # ตัวเลือกด้วย ค่าเดียว เช่น เปิดใช้งานปลั๊กอินของ Nuitka '--enable-plugin': "pyside2", # ตัวเลือกที่มีหลายค่า เช่น หลีกเลี่ยงการรวมโมดูล '--nofollow-import-to' : ["*.tests", "*.distutils"],
-
-
)# สำหรับ setup.py กับระบบบิลด์อื่นๆ:# ลักษณะทูเพิลของอาร์กิวเมนต์นั้นจำเป็นโดยลักษณะความมืดของ# "setuptools" และปลั๊กอินของมัน ซึ่งยืนยันความเข้ากันได้อย่างสมบูรณ์# เช่น "setuptools_rust"setup( # ไฟล์ข้อมูล จะต้องได้รับการจัดการโดย setuptools ไม่ใช่ Nuitka
package_data={"some_package": ["some_file.txt"]},
..., #นี่คือการผ่านตัวเลือก Nuitka
..., command_options={ 'nuitka': { # ตัวเลือกบูลีน เช่น หากคุณดูแลคำสั่งการคอมไพล์ C '--show-scons': ("setup.py", True), # ตัวเลือกที่ไม่มีค่า เช่น บังคับใช้การใช้ Clang '--clang': ("setup.py", None), # ตัวเลือกที่มีค่าเดียว เช่น เปิดใช้งานปลั๊กอินของ Nuitka '--enable-plugin': ("setup.py", "pyside2"), # ตัวเลือกที่มีหลายค่า เช่น หลีกเลี่ยงการรวมโมดูล '--nofollow-import-to' : ("setup.py", ["*.tests", "*.distutils "]),
-
-
- หากคุณไม่สามารถหรือไม่ต้องการเปลี่ยนเป้าหมายได้ด้วยเหตุผลบางประการ คุณสามารถเพิ่มสิ่งนี้ลงใน setup.py ของคุณได้
# สำหรับ setup.pysetup( ..., build_with_nuitka=True)
บันทึก
หากต้องการปิดใช้งานการคอมไพล์ชั่วคราว คุณสามารถลบบรรทัดด้านบนออก หรือแก้ไขค่าเป็น False by หรือรับค่าจากตัวแปรสภาพแวดล้อมได้ หากคุณเลือก เช่น bool(os.getenv("USE_NUITKA", "True")) นี่ขึ้นอยู่กับคุณ
หรือคุณสามารถใส่ไว้ใน setup.cfg ของคุณ
[ข้อมูลเมตา] build_with_nuitka = จริง
และสุดท้ายแต่ไม่ท้ายสุด Nuitka ยังรองรับเม build ใหม่ ดังนั้นเมื่อคุณมี pyproject.toml อยู่แล้ว ให้แทนที่หรือเพิ่มค่านี้ง่ายๆ:
[build-system]requires = ["setuptools>=42", "wheel", "nuitka", "toml"]build-backend = "nuitka.distutils.Build"# ไฟล์ข้อมูลจะต้องได้รับการจัดการโดย setuptools ไม่ใช่ Nuitka [tool.setuptools.package-data]some_package = ['data_file.txt'] [tool.nuitka]# ไม่แนะนำสิ่งเหล่านี้ แต่จะทำให้เห็นได้ชัดว่ามีผลกระทบ# ตัวเลือกบูลีน เช่น หากคุณสนใจคำสั่งการคอมไพล์ C เครื่องหมายขีด # ชั้นนำจะถูกละเว้นshow-scons = ตัวเลือก true# ที่มีค่าเดียว เช่น เปิดใช้งาน ปลั๊กอินของ Nuitkaenable-plugin = "pyside2"# ตัวเลือกที่มีหลายค่า เช่น หลีกเลี่ยงการรวมโมดูล ยอมรับ# list argument.nofollow-import-to = ["*.tests", "*.distutils"]
บันทึก
สำหรับข้อกำหนด nuitka เหนือเส้นทางสัมบูรณ์เช่น C:Users...Nuitka จะทำงานบน Linux เช่นกัน ให้ใช้เส้นทางสัมบูรณ์ที่มีเครื่องหมายทับนำหน้า สองตัว เช่น //home/.../Nuitka
บันทึก
ไม่ว่าคุณจะใช้แนวทางใดก็ตาม ไฟล์ข้อมูลในวงล้อเหล่านี้จะไม่ได้รับการจัดการโดย Nuitka เลย แต่โดย setuptools อย่างไรก็ตาม คุณสามารถใช้ไฟล์ข้อมูลที่ฝังอยู่ในเชิงพาณิชย์ของ Nuitka ได้ ในกรณีนั้น คุณจะฝังไฟล์ไว้ในโมดูลส่วนขยายจริงๆ ไม่ใช่เป็นไฟล์ในวงล้อ
หากคุณมีหลายโปรแกรม แต่ละโปรแกรมควรจะสามารถเรียกใช้งานได้ ในอดีตคุณต้องคอมไพล์หลายครั้ง และปรับใช้ทั้งหมดนี้ ด้วยโหมดสแตนด์อโลน แน่นอนว่าสิ่งนี้หมายความว่าคุณค่อนข้างสิ้นเปลือง เนื่องจากการแชร์โฟลเดอร์สามารถทำได้ แต่ Nuitka ไม่รองรับจริงๆ
เข้าสู่ Multidist มีตัวเลือก --main ที่แทนที่หรือเพิ่มอาร์กิวเมนต์ตำแหน่งที่กำหนด และสามารถให้ได้หลายครั้ง เมื่อได้รับหลายครั้ง Nuitka จะสร้างไบนารี่ที่มีโค้ดของโปรแกรมทั้งหมดที่ให้มา แต่จะแชร์โมดูลที่ใช้ในโปรแกรมเหล่านั้น จึงไม่จำเป็นต้องแจกหลายครั้ง
ลองเรียกชื่อฐานของเส้นทางหลักและจุดเริ่มต้น แน่นอนว่าชื่อของสิ่งเหล่านี้จะต้องแตกต่างออกไป จากนั้นไบนารีที่สร้างขึ้นสามารถดำเนินการจุดเข้าใช้งานจุดใดจุดหนึ่งได้ และจะตอบสนองต่อสิ่งที่ sys.argv[0] ปรากฏ ดังนั้นหากดำเนินการด้วยวิธีที่ถูกต้อง (ด้วย subprocess หรือ OS API คุณสามารถควบคุมชื่อนี้ได้) หรือโดยการเปลี่ยนชื่อหรือคัดลอกไบนารี่หรือเชื่อมโยงไปยังมัน คุณก็จะสามารถบรรลุปาฏิหาริย์ได้
ทำให้สามารถรวมโปรแกรมที่แตกต่างกันมากเข้าไว้ในโปรแกรมเดียวได้
บันทึก
คุณลักษณะนี้ยังอยู่ในช่วงทดลอง ใช้ด้วยความระมัดระวังและรายงานการค้นพบของคุณหากคุณพบสิ่งใดก็ตามที่เป็นพฤติกรรมที่ไม่พึงประสงค์
โหมดนี้ใช้งานได้กับไฟล์สแตนด์อโลน ไฟล์เดียว และการเร่งความเร็วเพียงอย่างเดียว มันไม่ทำงานกับโหมดโมดูล
สำหรับการผสานรวมกับเวิร์กโฟลว์ GitHub มี Nuitka-Action ที่คุณควรใช้ซึ่งทำให้ง่ายต่อการรวมเข้าด้วยกัน คุณควรเริ่มต้นด้วยการรวบรวมในเครื่อง แต่จะง่ายที่สุดสำหรับการรวบรวมข้ามแพลตฟอร์มด้วย Nuitka
นี่คือตัวอย่างขั้นตอนการทำงานที่สร้างขึ้นบนทั้ง 3 OS
งาน: สร้าง: กลยุทธ์: เมทริกซ์: ระบบปฏิบัติการ: [macos-ล่าสุด, ubuntu-ล่าสุด, windows-ล่าสุด]
วิ่งบน: ${{ matrix.os }}
ขั้นตอน:
- ชื่อ: พื้นที่เก็บข้อมูลการเช็คเอาท์ใช้: actions/checkout@v4 - ชื่อ: การตั้งค่า Python ใช้: actions/setup-python@v5 พร้อมด้วย: python-version: แคช '3.10': 'pip' cache-dependency-path: | **/requirements*.txt - ชื่อ: ติดตั้งการพึ่งพาของคุณ: | pip install -r needs.txt -r needs-dev.txt - ชื่อ: Build Executable with Nuitka ใช้: Nuitka/Nuitka-Action@main with: nuitka-version: main script-name: your_main_program.py # ตัวเลือก Nuitka อื่นๆ อีกมากมาย ดูเอกสารการดำเนินการ แต่วิธีที่ดีที่สุดคือ # ที่จะใช้ตัวเลือก nuitka-project: ในโค้ดของคุณ ดังนั้น เช่น คุณสามารถสร้าง # ความแตกต่างสำหรับ macOS และสร้างชุดแอปได้ ที่นั่น. onefile: จริง - ชื่อ: อัปโหลดสิ่งประดิษฐ์ใช้: actions/upload-artifact@v3 ด้วย: ชื่อ: ${{ runner.os }} เส้นทางการสร้าง: | # ตรงกับสิ่งที่สร้างขึ้นสำหรับ 3 OSes build/*.exe build/*.bin build/*.app/**/* หากแอปของคุณเป็น GUI เช่น your_main_program.py ควรมีความคิดเห็นเหล่านี้ตามที่อธิบายไว้ในตัวเลือก Nuitka ในโค้ด เนื่องจากบน macOS นี่ควรเป็นชุดรวม
# โหมดการคอมไพล์แบบสแตนด์อโลนทุกที่ ยกเว้น macOS มีชุดแอป # nuitka-project-if: {OS} ใน ("Windows", "Linux", "FreeBSD"):# nuitka-project: --onefile# nuitka-project -if: {OS} == "ดาร์วิน":# nuitka-project: --standalone# nuitka-project: --macos-create-app-bundle#เพื่อความดูดีคุณสามารถระบุไอคอนได้ บน Windows คุณสามารถจัดเตรียมไฟล์ไอคอน ไฟล์ปฏิบัติการเทมเพลต หรือไฟล์ PNG ได้ ทั้งหมดนี้ใช้งานได้และอาจรวมกันได้:
# สิ่งเหล่านี้สร้างไบนารีพร้อมไอคอนบน Windowspython -m nuitka --onefile --windows-icon-from-ico=your-icon.png program.py หลาม -m nuitka --onefile --windows-icon-from-ico=your-icon.ico program.py python -m nuitka --onefile --windows-icon-template-exe=your-icon.ico program.py# สิ่งเหล่านี้สร้างชุดแอปพลิเคชันที่มีไอคอนบน macOSpython -m nuitka --macos-create-app-bundle --macos- app-icon=your-icon.png program.py หลาม -m nuitka --macos-create-app-bundle --macos-app-icon=your-icon.icns program.py
บันทึก
ด้วย Nuitka คุณไม่จำเป็นต้องสร้างไอคอนเฉพาะแพลตฟอร์ม แต่จะแปลงเป็น PNG แทน แต่ยังรวมถึงรูปแบบอื่น ๆ ได้ทันทีระหว่างการสร้าง
สามารถเพิ่มการให้สิทธิ์สำหรับชุดแอปพลิเคชัน macOS ด้วยตัวเลือก --macos-app-protected-resource ค่าทั้งหมดจะแสดงรายการในหน้านี้จาก Apple
ค่าตัวอย่างจะเป็น --macos-app-protected-resource=NSMicrophoneUsageDescription:Microphone access สำหรับการร้องขอการเข้าถึงไมโครโฟน หลังจากเครื่องหมายทวิภาค จะต้องระบุข้อความอธิบาย
บันทึก
ระวังว่าในกรณีที่มีแนวโน้มว่าจะใช้ช่องว่างในส่วนคำอธิบาย คุณจะต้องอ้างอิงคำพูดเพื่อให้เชลล์ของคุณผ่านไปยัง Nuitka และไม่ถูกตีความว่าเป็นอาร์กิวเมนต์ของ Nuitka
บน Windows โปรแกรมจะไม่เปิดคอนโซลเว้นแต่คุณจะพูดเช่นนั้น Nuitka มีค่าเริ่มต้นที่จะไม่แสดง คุณสามารถบังคับได้โดยใช้ --console=force จากนั้นโปรแกรมจะเปิดหน้าต่างเทอร์มินัลใหม่เมื่อดำเนินการ
หน้าจอสแปลชมีประโยชน์เมื่อโปรแกรมเริ่มทำงานช้า การเริ่มต้น Onefile นั้นไม่ได้ช้า แต่โปรแกรมของคุณอาจจะช้า และคุณไม่สามารถทราบได้จริง ๆ ว่าคอมพิวเตอร์ที่ใช้จะเร็วแค่ไหน ดังนั้นจึงอาจเป็นความคิดที่ดีที่จะมีมัน โชคดีที่ Nuitka สามารถเพิ่มลงใน Windows ได้อย่างง่ายดาย
สำหรับหน้าจอเริ่มต้น คุณต้องระบุเป็นไฟล์ PNG จากนั้นตรวจสอบให้แน่ใจว่าได้ปิดการใช้งานหน้าจอเริ่มต้นเมื่อโปรแกรมของคุณพร้อม เช่น นำเข้าเสร็จสิ้น เตรียมหน้าต่าง เชื่อมต่อกับฐานข้อมูล และต้องการหน้าจอเริ่มต้น ที่จะจากไป ที่นี่เราใช้ไวยากรณ์ของโครงการเพื่อรวมโค้ดเข้ากับการสร้าง คอมไพล์สิ่งนี้:
# nuitka-project: --onefile# nuitka-project: --onefile-windows-splash-screen-image={MAIN_DIRECTORY}/Splash-Screen.png# ไม่ว่าจะเป็นอะไรก็ตาม ให้พิมพ์อย่างชัดเจน ("การหน่วงเวลาการเริ่มต้นระบบ 10 วินาที ... " )เวลานำเข้า, tempfile, ostime.sleep(10)# ใช้รหัสนี้เพื่อส่งสัญญาณการลบหน้าจอเริ่มต้นหาก "NUITKA_ONEFILE_PARENT" ใน os.environ: Splash_filename = os.path.join( tempfile.gettempdir(), "onefile_%d_splash_feedback.tmp" % int(os.environ["NUITKA_ONEFILE_PARENT"]),
) ถ้า os.path.exists(splash_filename): os.unlink(splash_filename)print("เสร็จสิ้น... Splash ควรจะหายไป")
...# โปรแกรมที่เหลือของคุณอยู่ที่นี่สำหรับการวิเคราะห์โปรแกรมและแพ็คเกจ Nuitka ของคุณ จะมีรายงานการรวบรวมให้พร้อม คุณยังสามารถสร้างรายงานแบบกำหนดเองได้โดยจัดเตรียมเทมเพลตของคุณ โดยมีบางส่วนอยู่ใน Nuitka รายงานเหล่านี้มีข้อมูลรายละเอียดทั้งหมด เช่น เมื่อมีการพยายามนำเข้าโมดูล แต่ไม่พบ คุณสามารถดูได้ว่าเกิดอะไรขึ้น สำหรับการรายงานข้อผิดพลาด ขอแนะนำอย่างยิ่งให้จัดทำรายงาน
คุณสามารถแนบข้อมูลลิขสิทธิ์และเครื่องหมายการค้า ชื่อบริษัท ชื่อผลิตภัณฑ์ และอื่นๆ ลงในการรวบรวมของคุณได้ จากนั้นจะใช้ในข้อมูลเวอร์ชันสำหรับไบนารีที่สร้างขึ้นบน Windows หรือชุดแอปพลิเคชันบน macOS หากคุณพบสิ่งที่ขาดกรุณาแจ้งให้เราทราบ
ตามค่าเริ่มต้น Nuitka คอมไพล์โดยไม่มี --deployment ซึ่งจะเหลือชุดเจ้าหน้าที่รักษาความปลอดภัยและผู้ช่วยไว้ ซึ่งมีจุดมุ่งหมายเพื่อแก้ไขจุดบกพร่องการใช้งาน Nuitka ที่ไม่ถูกต้อง
นี่เป็นคุณสมบัติใหม่ และใช้การป้องกันและตัวช่วยมากมาย ดังที่บันทึกไว้ที่นี่
ดังนั้นหลังจากการคอมไพล์ sys.executable จึงเป็นไบนารีที่คอมไพล์แล้ว ในกรณีของแพ็คเกจเช่น multiprocessing joblib หรือ loky สิ่งเหล่านี้โดยทั่วไปคือการคาดหวังว่าจะทำงานจาก python เต็มรูปแบบกับ sys.executable และจากนั้นสามารถใช้ตัวเลือกของมันเช่น -c command หรือ -m module_name เรียกใช้รหัสอื่นชั่วคราวหรือถาวรเป็นบริการเสิร์ฟ
อย่างไรก็ตามด้วย Nuitka สิ่งนี้จะดำเนินการโปรแกรมของคุณอีกครั้งและวางข้อโต้แย้งเหล่านี้ใน sys.argv ที่ซึ่งคุณอาจเพิกเฉยต่อพวกเขาแล้วคุณก็แยกตัวเองอีกครั้งเพื่อเปิดตัว Helper Daemons บางครั้งสิ่งนี้จบลงด้วยกระบวนการนับ CPU ที่วางไข่ซึ่งวางไข่ CPU นับกระบวนการที่ ... สิ่งนี้เรียกว่าระเบิดส้อมและด้วยเกือบทุกระบบที่ทำให้พวกเขาหยุดตายได้อย่างง่ายดาย
นั่นคือเหตุผลที่สิ่งนี้เกิดขึ้นกับ Nuitka เริ่มต้น:
./hello.dist/hello.bin -l fool -m foom -n foon -o fooo -p ข้อผิดพลาดโปรแกรมพยายามเรียกตัวเองด้วยอาร์กิวเมนต์ '-m' ปิดการใช้งานด้วย '-การปรับใช้-การใช้งาน = execution ด้วยตนเอง'
โปรแกรมของคุณอาจมีการแยกวิเคราะห์บรรทัดคำสั่งของตัวเองและไม่ใช้แพ็คเกจที่ไม่ได้รับการสนับสนุนซึ่งพยายามที่จะทำการ execute อีกครั้ง ในกรณีนี้คุณต้องใช้ เวลาคอมไพล์ ในการใช้ --no-deployment-flag=self-execution ซึ่งปิดใช้งานตัวป้องกันเฉพาะนี้
บางแพ็คเกจส่งออกสิ่งที่พวกเขาคิดว่าเป็นข้อมูลที่เป็นประโยชน์เกี่ยวกับสาเหตุของการนำเข้าที่ล้มเหลวอาจหมายถึงอะไร ด้วยโปรแกรมที่รวบรวมมักจะมีความผิดปกติมาก เราพยายามซ่อมแซมผู้ที่อยู่ในโหมดที่ไม่ได้ใช้งาน นี่คือตัวอย่างที่เราเปลี่ยนข้อความที่ขอให้ติดตั้ง PIP (ซึ่งไม่ใช่ปัญหา) เพื่อชี้ผู้ใช้ไปยังคำสั่งรวมที่ทำให้ปลั๊กอิน imageio ทำงานได้
- Module-Name: 'Imageio.core.imopen'
Anti-Bloat:
-Replacements_plain: '`pip ติดตั้ง imageio [{config.install_name}]` ในการติดตั้ง': '`-include-module = {config.module_name}` ด้วย nuitka runtimeRorror 'เมื่อ:' ไม่ปรับใช้ ' โหมดการปรับใช้ค่อนข้างใหม่และมีการเพิ่มคุณสมบัติเพิ่มเติมอย่างต่อเนื่องเช่นบางสิ่งบางอย่างสำหรับ FileNotFoundError ควรจะมาเร็ว ๆ นี้
แน่นอนว่าผู้ช่วยเหล่านี้สามารถปิดการใช้งานได้ทันทีด้วย --deployment แต่โปรดทราบว่าสำหรับการดีบักคุณอาจต้องการเปิดใช้งานอีกครั้ง คุณอาจต้องการใช้ตัวเลือกโครงการ Nuitka และตัวแปรสภาพแวดล้อมเพื่อให้มีเงื่อนไขนี้
คุณควรปิดการใช้งานทั้งหมดหรือไม่?
เราเชื่อว่าการปิดการใช้งานควรเกิดขึ้นอย่างเลือก แต่ด้วยการอัพเกรด PYPI การเปลี่ยนแปลงรหัสของคุณปัญหาทั้งหมดเหล่านี้สามารถแอบเข้ามาได้ หากคุณรู้ว่ามันไม่สามารถส่งผลกระทบต่อคุณหรือเป็นเช่นนั้นคุณจะไม่ต้องการมัน อนาคตบางอย่างจะถูกกำหนดอย่างชัดเจนในการใช้งานระดับเริ่มต้น
ไบนารีที่รวบรวมบน Windows ด้วยการตั้งค่าเริ่มต้นของ Nuitka และไม่มีการดำเนินการใด ๆ เพิ่มเติมอาจได้รับการยอมรับจากผู้ขาย AV บางรายเป็นมัลแวร์ สิ่งนี้สามารถหลีกเลี่ยงได้ แต่เฉพาะในเชิงพาณิชย์ของ Nuitka เท่านั้นที่มีการสนับสนุนและคำแนะนำที่แท้จริงสำหรับวิธีการทำโดยเห็นว่านี่เป็นความต้องการเชิงพาณิชย์ทั่วไปเท่านั้น https://nuitka.net/doc/commercial.html
สำหรับ Linux Standalone มันค่อนข้างยากที่จะสร้างไบนารีที่ใช้งานได้กับเวอร์ชัน Linux อื่น ๆ นี่เป็นส่วนใหญ่เป็นเพราะใน Linux ซอฟต์แวร์จำนวนมากถูกสร้างขึ้นโดยเฉพาะกับ DLLs คอนกรีต สิ่งต่าง ๆ เช่น Glibc ที่ใช้แล้วจะถูกเข้ารหัสลงในไบนารีที่สร้างขึ้นและมันจะไม่ทำงานกับ Glibc รุ่นเก่าเพียงเพื่อให้ตัวอย่างที่สำคัญอย่างหนึ่ง
ทางออกคือการสร้างระบบปฏิบัติการที่เก่าแก่ที่สุดที่คุณต้องการเห็น การเลือกสิ่งนั้นและการตั้งค่าอาจเป็นเรื่องน่าเบื่อดังนั้นสามารถเข้าสู่ระบบและเก็บไว้ได้
