Как написать exe файл на python

Время на прочтение
3 мин

Количество просмотров 190K

С помощью Auto PY to EXE можно с лёгкостью преобразовывать файлы .py в файлы .exe. Благодаря этому ваш проект на Python будет работать как десктопное приложение и вы сможете запускать приложение на других машинах без необходимости установки Python.

В этой статье я расскажу, как преобразовать проект на Python в исполняемый файл. Решение будет работать вне зависимости от количества файлов .py в приложении. Стоит учесть, что Auto PY to EXE работает только с Python 3.5 или выше.

Установка Auto PY to EXE

Установка через pip

При помощи следующей команды можно установить текущую версию Auto PY to EXE.

$ pip install auto-py-to-exe

Установка с GitHub

Также можно выполнить установку напрямую с GitHub. Для установки Auto PY to EXE с GitHub необходимо сначала клонировать репозиторий GitHub.

$ git clone https://github.com/brentvollebregt/auto-py-to-exe.git

Затем нужно перейти в папку auto-py-to-exe.

$ cd auto-py-to-exe

Теперь необходимо запустить файл setup.py.

$ python setup.py install

Можно также проверить версию при помощи следующей команды:

auto-py-to-exe --version

Проверяем версию

Текущая версия Auto PY to EXE 2.9.0 и теперь она установлена на ваш компьютер.

Открываем приложение

Чтобы открыть Auto PY to EXE, нужно выполнить в терминале следующую команду:

$ auto-py-to-exe

Откроется удобное приложение с GUI:

Интерфейс пользователя Auto PY to EXE

Теперь с помощью этого интерфейса можно преобразовать файл .py в .exe.

Процесс преобразования

Шаг 1. Добавляем местоположение файла

Для преобразования .py в .exe сначала необходимо указать путь к файлу Python. Достаточно перейти к местоположению файла, который нужно преобразовать, а затем добавить путь.

Пример:

Добавляем местоположение файла

Я добавил местоположение основного файла Python моего проекта. Здесь я использую для примера один из своих проектов на Python. Это приложение с GUI, визуализирующее различные алгоритмы сортировки. О создании этого проекта можно прочитать здесь: Build a Sorting Algorithm Visualizer in Python

Шаг 2. Выбор «One Directory» или «One File»

В интерфейсе есть опция выбора «One Directory» или «One File». Мой проект на Python содержит несколько других файлов, поэтому я выбрал «One Directory». Эта опция создаст папку со всеми необходимыми файлами, а также с файлом .exe.

One directory или One file

Шаг 3. Выбор «Console Based» или «Window Based»

После этого нужно будет выбрать тип приложения: консольное (Console Based) или оконное (Window Based). Если выбрать «Window Based», то это скроет весь консольный вывод приложения. Если ваш проект генерирует консольный вывод, то нужно выбрать «Console Based». Если у вас приложение с GUI или вам не нужно отображать пользователю консольный вывод, то выберите «Window Based». Я выбрал второй вариант, потому что моё приложение имеет GUI.

Console Based или Window Based

Шаг 4. Преобразование

Далее отобразятся другие опции, такие как добавление значков, дополнительных файлов и т.д. Выберите нужные опции самостоятельно. Ну а наш файл .py уже к преобразованию. Достаточно нажать на кнопку CONVERT .PY TO .EXE .

Нажмите кнопку для преобразования

Для завершения процесса придётся немного подождать.

Папка с результатами

После завершения процесса можно будет выбрать опцию открытия папки с результатами.

По умолчанию папка с результатами будет создана там, откуда вы запускали Auto PY to EXE. Я открывал Auto PY to EXE с рабочего стола, поэтому папка создана на нём. В папке находится множество файлов и папок. Но нам важен файл с расширением .exe. В моём случае это main.exe. При двойном нажатии будет запускаться программа.

Готово! Наш проект на Python теперь преобразован в исполняемый файл. Его можно запускать на других компьютерах без необходимости установки Python.

Ресурсы

  • https://pypi.org/project/auto-py-to-exe/
  • https://github.com/brentvollebregt/auto-py-to-exe

На правах рекламы

Серверы для всех, в том числе, и для разработчиков! VDS с посуточной оплатой на базе новейших процессоров AMD EPYC и хранилища на основе NVMe дисков от Intel для размещения проектов любой сложности, создавайте собственную конфигурацию сервера в пару кликов!

Подписывайтесь на наш чат в Telegram.

Обычно код на Питон запускают двумя способами: через терминал или через текстовый редактор / IDE.

При этом стоит отметить, что файлик Python — это всего лишь скрипт, который сохранён в расширении .py. Да, это очевидно, но в этом и кроется проблема: иногда нужно скрыть исходный код, а поделиться программкой (в виде альфа-версии, например) очень хочется.

Одно из решений, которое закрывают боль с исходным кодом — это конвертация файла Python в исполняемый exe-файлик.

В этой статье мы научимся создавать «экзешники» при помощи двух библиотек: Pyinstaller and auto-py-to-exe.

Перед тем, как продолжить чтение статьи, скачайте этот репозиторий. Он здорово поможет вам понять процесс, если вы будете повторять все шаги вместе с нами.

  1. Код могут украсть. Об этом мы уже говорили выше. Куда проще достать исходный код непосредственно из py-файла, чем из скомпилированного приложение. Py-файл достаточно просто открыть!
  2. Хочется поделиться кодом с другими юзерами. Дело не только в том, что ваш код могут украсть. Зачастую код содержит зависимости, которыми должен владеть другой юзер перед запуском вашего Python-кода. Но что, если он вообще ничего не смыслит в программировании? Не заставишь ведь его сперва выучить программирование, чтобы оценить ваше новое суперприложение. Проще создать исполняемый файл.
  3. Исполняемый файл можно запускать автоматически, по расписанию. Этот пункт актуален, если вы решили написать утилиту для вашего ПК, и эта утилита должна запускаться либо в определенное время, либо вместе с запуском ОС.

Конвертация кода Python в файл .exe

Для начала создадим скрипт на Python. В качестве примера мы используем открытый код бронирования жилья AitBnb в Нью-Йорке. Если у вас уже есть готовый код, можете сразу использовать его.

import pandas as pd
from pandas.api.types import CategoricalDtype

def perform_validation(filename:str):
    """
    A function to validate inputs for NYC Airbnb Open data.
    """
    path_to_data = "../.."
    data = pd.read_csv(f"{path_to_data}{filename}")

    # Convert neighbourhood_group to type category
    neighbourhood_group_to_cat = CategoricalDtype(
        categories=["Manhattan", "Brooklyn", "Queens", "Bronx", "Staten Island"],
        ordered=False
        )
 
    data["neighbourhood_group"] = data["neighbourhood_group"].astype(neighbourhood_group_to_cat)

    # Convert room_type to type category
    room_type_to_cat = CategoricalDtype(
        categories=["Entire home/apt", "Private room", "Shared room"],
        ordered=False
    )

    data["room_type"] = data["room_type"].astype(room_type_to_cat)

    # Convert last_review to datetime
    data["last_review"] = pd.to_datetime(data["last_review"])

    # Minimum nights a person can stay is one night
    assert data["minimum_nights"].min() >= 1

    # Minimum number of reviews is 0
    assert data["number_of_reviews"].min() >= 0
 
    # Minimum number of reviews per month
    assert data["reviews_per_month"].min() >= 0.00

    # Minimum amount of listings per host
    assert data["calculated_host_listings_count"].min() >= 1

    # Number of days when listing is available for books
    # Could be 0 if tennant has long term booking
    assert data["availability_365"].min() >= 0

    # Save validated data
    data.to_csv("validated_ab_nyc_2019.csv", index=False)

if __name__ == "__main__":
    # User inputs filename
    filename = input("Enter filename: ")
 
    # Ensure it's a string
    if not filename.isalpha():
        filename = str(filename)
 
    # Automated validation
    perform_validation(filename)

Вы не забыли скачать библиотеки по ссылке по введении? Сделайте это сейчас.

Вот структура файлов на GitHub:

# Directory structure
|   AB_NYC_2019.csv
|  
+---auto_py_to_exe
|   |   requirements.txt
|   |   validation.py         
+---pyinstaller
    |   requirements.txt
    |   validation.py

Каждая из директорий должна обладать своей виртуальной средой. Убедитесь, что среды развёрнуты и в директории pyinstaller, и в auto-py-to-exe.

Сохраните ваш код и скопируйте его в обе директории.

Что делать в Pyinstaller

Ещё раз убедитесь, что виртуальная среда развёрнута. Да, мы настаиваем. Проверьте, установлены ли все зависимости между библиотеками и кодом.

Всё в порядке? Запускайте команду:

pyinstaller --onefile validation.py

Процесс должен запуститься, и в конце консоль сообщит: «Completed successfully». Значит, всё прошло успешно. 🙂

Успешный процесс компиляции в Pyinstaller // DataCamp

В папке с бибилотекой и кодом должны появиться две новые директории под названиями build и dist. В папке dist вы найдёте заветный exe-файл. Запустите его и проверьте работу приложения.

Что делать в Auto-py-to-exe

Также скиньте файлик с кодом в папку с библиотекой и проверьте зависимости между кодом и библиотекой.

Запустите команду:

auto-py-to-exe

Команда запустит графический интерфейс.

Запускаем компилятор Auto-py-to-exe // DataCamp

  1. В строчке «Script Location» нажмите «Browse» и выберите py-скрипт.
  2. В строчке «Onefile» выберите, скомпилируется код в единый файл или в папку. В папке будет содержаться exe-файл и все зависимости кода.
  3. В строчке «Console Window» выберите настройки отображения exe-приложения, когда оно будет запущено. Если выбрать «Console Based», запустится и программа, и консоль, в которой будут показаны процессы. Опция «Window Based» скрывает консоль.
  4. Нажмите кнопку «Convert .py to .exe». Готово!

Запускаем exe-файл

В обоих случаях, после компиляции и запуска exe-файла, тот запустит консоль и попросит вас ввести имя файла. Придумайте его и укажите расширение, в котором всё должно работать. К примеру, Tproger-is-the-best-it-media-in-the-world.csv. Тогда консоль закроется, а в папке появится заветный файлик с расширением .csv.

И всё — вы великолепны!

Источник: DataCamp

Python – популярный язык разработки, который стал пользоваться спросом в последние несколько лет. Он достаточно прост в изучении, но в некоторых его особенностях непросто разобраться даже опытному программисту.

Изначально Python создает приложение в формате .py. Это не совсем удобно, особенно если пользователь имеет дело в Windows. Для комфортной проверки и формирования утилиты нужно скомпилировать py в exe. Добиться соответствующего результата удается несколькими способами. О них и зайдет речь далее. Предложенные сведения пригодятся всем, кто планирует писать программы на Питоне.

О формате executable

Exe – это формат исполняемого типа. Он знаком всем, кто хотя бы раз запускал MS Windows. Представляет собой набор инструкций, который заставляет компьютер выполнить ту или иную задачу. Не важно, на каком языке написана программа – Питон, C++ или Java. Если проект скомпилирован в exe, он будет успешно прочтен устройством.

Перед тем как думать, как скомпилировать python в exe файл, нужно понимать – создание подобного документа нацелено «на машину». Экзешник считывается устройством, базируется на машинном коде.

Данный вариант применяется в различных операционных системах:

  • Windows;
  • DOS;
  • Symbian;
  • OS/2.

Может предусматривать в своем составе метаданные, включая цифровые подписи. Для обычного пользователя исполняемый файл – это готовое к запуску приложение, которое остается установить или активировать.

Способы преобразования проекта

Python скрипт в exe перевести не слишком сложно. Сборка может проходить как автоматически, так и при помощи online/offline приложений. Все зависит от личных предпочтений разработчика.

Создать исполняемый файл на Питоне (экзешник) – дело нескольких минут. Далее будут представлены популярные и известные методы, позволяющие преобразовывать Python Script в интересующий формат.

Auto PY

Первый вариант – один из самых простых. Он позволит сделать исполняемый файл в несколько кликов. Речь идет об использовании приложения, которое носит название «компилятор». Это – Auto PY to EXE.

Перевод проекта через соответствующее ПО с Python в экзешник позволит запускать утилиты на других машинах. Для этого не нужно предварительно устанавливать Питон.

Инициализация

Чтобы сделать исполняемый файл соответствующим способом, нужно провести инициализацию Auto PY to EXE. Первый вариант – установка «в командной строке». Для этого требуется ввести команду: pip install auto-py-to-exe.

Второй вариант – через GitHub. Для этого нужно:

  1. Клонировать репозиторий .
  2. Перейти в папку с соответствующим компилятором .
  3. Запустить файл setup.py.
  4. Проверить актуальную версию.
  5. Открыть прогу (Python Scripts), с которой планируется дальнейшая работа. Процесс осуществляется в терминале .

Установка завершена. Конвертер готов к непосредственному использованию. Теперь можно сделать исполняемый файл из Python в несколько кликов.

Преобразование

Создание экзешника  (executables) из Питоновского project проводится в несколько этапов:

  1. Добавляем в конвертор местоположение файла. На этом этапе прописывается путь, где лежит интересующий пользователя скрипт. Нужно перейти к местоположению документа и добавить соответствующий «адрес».
  2. Выбор директории. One Directory создаст папку со всеми необходимыми документами и одним исполняемым, когда будет обрабатывать скрипт.
  3. Определить тип приложения. На данном этапе предлагается создать документ или консольного типа, или оконного. Windows Based – вариант, который скроет console. Компиляция типа Console Based используется, если мы преобразуем script, предусматривающий работу с консолью. Window Based – это вариант для GUI.
  4. Компиляция. Здесь компилируем project. На экране появятся дополнительные опции. Их выбор зависит от предпочтений разработчика. Чтобы начать процедуру, необходимо нажать на кнопку Convert.

Completed Project через Auto PY to EXE разместится в отдельной папке. По умолчанию – это место, откуда запускался converter. В папке множество документов, но всего один – с интересующим форматом. При двойном нажатии на него будет запускаться программа на Python.

Py Installer

Сборка exe file может проводиться через компилятор Pyinstaller. Установка – через pip. После этого рекомендуется проверить build компилятора – лишь после делать все необходимые манипуляции. Команда pip install PyInstaller поможет активировать «утилиту». Она включена в стандартный пакет Python. Сохранить py file to exe будет проще простого.

Как собрать проект

Конвертер позволяет сохранить весь проект в единый Python-файл. Создание (сборка) происходит так:

  1. Считывается скрипт.
  2. Активируется код для выявления зависимостей.
  3. Создается файл spec. Он включает в себя название скрипта, библиотеку-зависимости, иные документы.
  4. Converter собирает копии библиотек и файлов вместе с активным интерпретатором Python.
  5. Для того, чтобы перевести код (script) в file исполняемого типа, создается папка Build. В ней фиксируются логи и рабочие документы.
  6. Создается папка DIST. Она расположена в папке со скриптом. Этот этап пропускается при наличии соответствующего компонента.
  7. Сохраняем через converter необходимые документы вместе со скриптом в одну папку или исполняемый файл.

Если задействовать onedir или -D при генерации, code и его files разместятся в одной папке. Это – настройки по умолчанию. Применение onefile или -F – это создание сохранений в едином документе.

Пример

Convert Python код в exe – не так трудно. Все installing и compile code отнимают некоторое время, но требуют минимального вмешательства. Вот – пример того, как перевести (create build) исходный код в интересующую форму:

  1. Дан документ simple.py .
  2. Ввести в командной строке pyinstaller –onefile simple.py.
  3. Дождаться завершения процесса.

Это – compile (возможность сохранить) Python projects code on исполняемый документ. Установка завершится – появятся папки built и dist. А еще – новый spec-файл.

Py2exe

Есть еще поход – convert (compile) coding через Py2exe. Подойдет для Питона 3.4 и версий ниже. Сначала creates визуальное окружение, затем – сохраняем picture и иные компоненты скрипта в единое целое. Приведенный пример – проект с именем myenv.

Для converting python auto py to документ exe, нужно:

  1. Creating визуальное окружение .
  2. Installed py2 exe .
  3. Completed process by creating «windowed» file. В виртуальном окружении выполняется команда .

В ходе процесса сохраняется готовый скрипт. Он при запуске будет открываться и закрываться очень быстро. Чтобы converted файл не закрывал терминал, нужно добавить строчку в документе Питона.

В сети

Задумываясь, как сделать exe из Python, можно created building при помощи online converts. Это специализированные компиляторы, работающие в интернете. Online сервисы не требуют install, функционируют так:

  1. На экране появляется главное окно — main line.
  2. В окне compiler нужно ввести скрипт.
  3. Нажать на кнопку Installation. Иногда – Compiled или Run.
  4. Online сервис compiles файл интересующего формата. Иногда его можно выбрать. При ошибке обработки операции на экране появится надпись «failed».

Остается скачать compiling документацию и (или) его проект с полноценной папкой. Можно запускать документ.

А вот – туториал, в котором наглядно показано, как из файла py сделать exe. Лучше разобраться в теме помогут специализированные онлайн-курсы.

Установка PyInstaller не отличается от установки любой другой библиотеки Python.

pip install PyInstaller

Вот так можно проверить версию PyInstaller.

pyinstaller --version

Я использую PyInstaller версии 4.2.

Создание exe файла с помощью PyInstaller

PyInstaller собирает в один пакет Python-приложение и все необходимые ему библиотеки следующим образом:

  1. Считывает файл скрипта.
  2. Анализирует код для выявления всех зависимостей, необходимых для работы.
  3. Создает файл spec, который содержит название скрипта, библиотеки-зависимости, любые файлы, включая те параметры, которые были переданы в команду PyInstaller.
  4. Собирает копии всех библиотек и файлов вместе с активным интерпретатором Python.
  5. Создает папку BUILD в папке со скриптом и записывает логи вместе с рабочими файлами в BUILD.
  6. Создает папку DIST в папке со скриптом, если она еще не существует.
  7. Записывает все необходимые файлы вместе со скриптом или в одну папку, или в один исполняемый файл.

Если использовать параметр команды onedir или -D при генерации исполняемого файла, тогда все будет помещено в одну папку. Это поведение по умолчанию. Если же использовать параметр onefile или -F, то все окажется в одном исполняемом файле.

Возьмем в качестве примера простейший скрипт на Python c названием simple.py, который содержит такой код.

import time
name = input("Введите ваше имя ")
print("Ваше имя ", name)
time.sleep(5)

Создадим один исполняемый файл. В командной строке введите:

pyinstaller --onefile simple.py

После завершения установки будет две папки, BUILD и DIST, а также новый файл с расширением .spec. Spec-файл будет называться так же, как и файл скрипта.

папки, BUILD и DIST, а также файл .spec

Python создает каталог распространения, который содержит основной исполняемый файл, а также все динамические библиотеки.

 исполняемый файл

Вот что произойдет после запуска файла.

Добавление файлов с данными, которые будут использоваться exe-файлом

Есть CSV-файл netflix_titles.csv, и Python-script, который считывает количество записей в нем. Теперь нужно добавить этот файл в бандл с исполняемым файлом. Файл Python-скрипта назовем просто simple1.py.

import time
# pip install pandas
import pandas as pd


def count_records():
    data = pd.read_csv('netflix_titles.csv')
    print("Всего фильмов:", data.shape[0])


if __name__ == "__main__":
    count_records()
    time.sleep(5)

Создадим исполняемый файл с данными в папке.

pyinstaller --add-data "netflix_titles.csv;." simple1.py

Параметр --add-data позволяет добавить файлы с данными, которые нужно сохранить в одном бандле с исполняемым файлом. Этот параметр можно применить много раз.

Синтаксис add-data:

  • add-data — Windows.
  • add-data — Linux.

Можно увидеть, что файл теперь добавляется в папку DIST вместе с исполняемым файлом.

Добавление файлов с данными

Также, открыв spec-файл, можно увидеть раздел datas, в котором указывается, что файл netflix_titles.csv копируется в текущую директорию.

...
a = Analysis(['simple1.py'],
             pathex=['E:\myProject\pyinstaller-tutorial'],
             binaries=[],
             datas=[('netflix_titles.csv', '.')],
...

Запустим файл simple1.exe, появится консоль с выводом: Всего фильмов: 7787.

Добавление файлов с данными и параметр onefile

Если задать параметр --onefile, то PyInstaller распаковывает все файлы в папку TEMP, выполняет скрипт и удаляет TEMP. Если вместе с add-data указать onefile, то нужно считать данные из папки. Путь папки меняется и похож на «_MEIxxxxxx-folder».

import time
import sys
import os
# pip install pandas
import pandas as pd


def count_records():
    os.chdir(sys._MEIPASS)
    data = pd.read_csv('netflix_titles.csv')
    print("Всего фильмов:", data.shape[0])


if __name__ == "__main__":
    count_records()
    time.sleep(5)

Скрипт обновлен для чтения папки TEMP и файлов с данными. Создадим exe-файл с помощью onefile и add-data.

pyinstaller --onefile --add-data "netflix_titles.csv;." simple1.py

После успешного создания файл simple1.exe появится в папке DIST.

Можно скопировать исполняемый файл на рабочий стол и запустить, чтобы убедиться, что нет никакой ошибки, связанной с отсутствием файла.

Добавление файлов с данными и параметр onefile

Дополнительные импорты с помощью Hidden Imports

Исполняемому файлу требуются все импорты, которые нужны Python-скрипту. Иногда PyInstaller может пропустить динамические импорты или импорты второго уровня, возвращая ошибку ImportError: No module named

Для решения этой ошибки нужно передать название недостающей библиотеки в hidden-import.

Например, чтобы добавить библиотеку os, нужно написать вот так:

pyinstaller --onefile --add-data "netflix_titles.csv;." — hidden-import "os" simple1.py

Файл spec

Файл spec — это первый файл, который PyInstaller создает, чтобы закодировать содержимое скрипта Python вместе с параметрами, переданными при запуске.

PyInstaller считывает содержимое файла для создания исполняемого файла, определяя все, что может понадобиться для него.

Файл с расширением .spec сохраняется по умолчанию в текущей директории.

Если у вас есть какое-либо из нижеперечисленных требований, то вы можете изменить файл спецификации:

  • Собрать в один бандл с исполняемым файлы данных.
  • Включить другие исполняемые файлы: .dll или .so.
  • С помощью библиотек собрать в один бандл несколько программы.

Например, есть скрипт simpleModel.py, который использует TensorFlow и выводит номер версии этой библиотеки.

import time
import tensorflow as tf


def view_model():
    print(tf.__version__)


if __name__ == "__main__" :
    model = view_model()
    time.sleep(5)

Компилируем модель с помощью PyInstaller:

pyinstaller -F simpleModel.py

После успешной компиляции запускаем исполняемый файл, который возвращает следующую ошибку.

...
File "site-packagestensorflow_corepython_init_.py", line 49, in ImportError: cannot import name 'pywrap_tensorflow' from 'tensorflow_core.python' 

Исправим ее, обновив файл spec. Одно из решений — создать файл spec.

$ pyi-makespec simpleModel.py -F
wrote E:pyinstaller-tutorialsimpleModel.spec
now run pyinstaller.py to build the executable

Команда pyi-makespec создает spec-файл по умолчанию, содержащий все параметры, которые можно указать в командной строке. Файл simpleModel.spec создается в текущей директории.

Поскольку был использован параметр --onefile, то внутри файла будет только раздел exe.

...
exe = EXE(pyz,
          a.scripts,
          a.binaries,
          a.zipfiles,
          a.datas,
          [],
          name='simpleModel',
          debug=False,
          bootloader_ignore_signals=False,
          strip=False,
          upx=True,
          upx_exclude=[],
          runtime_tmpdir=None,
          console=True )

Если использовать параметр по умолчанию или onedir, то вместе с exe-разделом будет также и раздел collect.

Можно открыть simpleModel.spec и добавить следующий текст для создания хуков.

# -*- mode: python ; coding: utf-8 -*-

block_cipher = None
import os
spec_root = os.path.realpath(SPECPATH)
options = []
from PyInstaller.utils.hooks import collect_submodules, collect_data_files
tf_hidden_imports = collect_submodules('tensorflow_core')
tf_datas = collect_data_files('tensorflow_core', subdir=None, include_py_files=True)

a = Analysis(['simpleModel.py'],
             pathex=['E:\myProject\pyinstaller-tutorial'],
             binaries=[],
             datas=tf_datas + [],
             hiddenimports=tf_hidden_imports + [],
             hookspath=[],
...

Создаем хуки и добавляем их в hidden imports и раздел данных.

Хуки

Файлы хуков расширяют возможность PyInstaller обрабатывать такие требования, как необходимость включать дополнительные данные или импортировать динамические библиотеки.

Обычно пакеты Python используют нормальные методы для импорта своих зависимостей, но в отдельных случаях, как например TensorFlow, существует необходимость импорта динамических библиотек. PyInstaller не может найти все библиотеки, или же их может быть слишком много. В таком случае рекомендуется использовать вспомогательный инструмент для импорта из PyInstaller.utils.hooks и собрать все подмодули для библиотеки.

Скомпилируем модель после обновления файла simpleModel.spec.

pyinstaller simpleModel.spec

Скопируем исполняемый файл на рабочий стол и увидим, что теперь он корректно отображает версию TensorFlow.

Вывод:

PyInstaller предлагает несколько вариантов создания простых и сложных исполняемых файлов из Python-скриптов:

  • Исполняемый файл может собрать в один бандл все требуемые данные с помощью параметра --add-data.
  • Исполняемый файл и зависимые данные с библиотеками можно собрать в один файл или папку с помощью --onefile или --onedir соответственно.
  • Динамические импорты и библиотеки второго уровня можно включить с помощью hidden-imports.
  • Файл spec позволяет создать исполняемый файл для обработки скрытых импортов и других файлов данных с помощью хуков.

Код, написанный на Python, позволяет решать много прикладных задач: автоматизация отчетности, алгоритмы поиска, анализа и пр. Однако не у всех потенциальных пользователей может быть установлен сам Python и тем более не все являются экспертами в программировании. Выручить может программа, которая будет отрабатывать написанный вами код без установки библиотек Python и необходимой оболочки. Одним из таких решений может быть компиляция кода Python а файл exe. Дальше простым языком мы постараемся объяснить, как его скомпилировать и какие есть нюансы.

Для начала Вам необходимо скачать компилятор pyinstaller, для чего вам понадобится команда:

pip install pyinstaller

Далее ваш код в формате. py необходимо разместить в системную папку Scripts.

Путь к этой папке обычно выглядит так:

Если Вы инсталлировали Python в другое место, соответственно ищите папку там.

Далее приступаем собственно к компиляции, для чего: выделяем путь к папке Scripts в окне браузера, вместо него набираем команду cmd и жмем Enter.

У Вас сразу будет указан верный путь к файлу:

В продолжение строки с директорией файла необходимо набрать команду: pyinstaller Report.py —onefile

Где Report.py – это имя вашего файла, — onefile – означает, что программа будет скомпилирована в единый файл.

Нажимаем Enter. Pyinstaller приступает к сборке программы.

В зависимости от размера кода и количества, используемых в нем библиотек, время сборки программы может занять 5-15 мин. Успешностью завершения будет являться следующее сообщение:

Готовый файл находим в папке dist.

Данный метод компиляции не оптимизирует включение только необходимых библиотек, поэтому нужно быть готовым к тому, что его размер будет занимать достаточно объема. В нашем случае код из 120 строк с библиотекой Pandas и Datetime собран в программу весом почти 220 Mb. Теперь данным файлом может пользоваться любой сотрудник.

Хотелось бы обратить внимание на следующие нюансы: если вы компилируете файл на 64 битной OS Windows 10, то он не запустится на 32 битной OS Windows 7.

Если же файл будет скомпилирован на 32 битной OS Windows 7, то его можно будет запустить как на 32 битных, так и на 64 битных OS Windows 7/10.

The syntax of the pyinstaller command is:

pyinstaller [options] script [script …] | specfile

In the most simple case,
set the current directory to the location of your program myscript.py
and execute:

PyInstaller analyzes myscript.py and:

  • Writes myscript.spec in the same folder as the script.

  • Creates a folder build in the same folder as the script if it does not exist.

  • Writes some log files and working files in the build folder.

  • Creates a folder dist in the same folder as the script if it does not exist.

  • Writes the myscript executable folder in the dist folder.

In the dist folder you find the bundled app you distribute to your users.

Normally you name one script on the command line.
If you name more, all are analyzed and included in the output.
However, the first script named supplies the name for the
spec file and for the executable folder or file.
Its code is the first to execute at run-time.

For certain uses you may edit the contents of myscript.spec
(described under Using Spec Files).
After you do this, you name the spec file to PyInstaller instead of the script:

pyinstaller myscript.spec

The myscript.spec file contains most of the information
provided by the options that were specified when
pyinstaller (or pyi-makespec)
was run with the script file as the argument.
You typically do not need to specify any options when running
pyinstaller with the spec file.
Only a few command-line options
have an effect when building from a spec file.

You may give a path to the script or spec file, for example

pyinstaller options… ~/myproject/source/myscript.py

or, on Windows,

pyinstaller "C:Documents and Settingsprojectmyscript.spec"

Options¶

A full list of the pyinstaller command’s options are as follows:

Positional Arguments¶

scriptname

Name of scriptfiles to be processed or exactly one
.spec file. If a .spec file is specified, most options
are unnecessary and are ignored.

Optional Arguments¶

-h, —help

show this help message and exit

-v, —version

Show program version info and exit.

—distpath DIR

Where to put the bundled app (default: ./dist)

—workpath WORKPATH

Where to put all the temporary work files, .log, .pyz
and etc. (default: ./build)

-y, —noconfirm

Replace output directory (default:
SPECPATH/dist/SPECNAME) without asking for
confirmation

—upx-dir UPX_DIR

Path to UPX utility (default: search the execution
path)

-a, —ascii

Do not include unicode encoding support (default:
included if available)

—clean

Clean PyInstaller cache and remove temporary files
before building.

—log-level LEVEL

Amount of detail in build-time console messages. LEVEL
may be one of TRACE, DEBUG, INFO, WARN, DEPRECATION,
ERROR, FATAL (default: INFO). Also settable via and
overrides the PYI_LOG_LEVEL environment variable.

What To Generate¶

-D, —onedir

Create a one-folder bundle containing an executable
(default)

-F, —onefile

Create a one-file bundled executable.

—specpath DIR

Folder to store the generated spec file (default:
current directory)

-n NAME, —name NAME

Name to assign to the bundled app and spec file
(default: first script’s basename)

What To Bundle, Where To Search¶

—add-data <SRC;DEST or SRC:DEST>

Additional non-binary files or folders to be added to the executable. The
path separator is platform specific, os.pathsep (which is ; on
Windows and : on most unix systems) is used. This option can be used
multiple times.

—add-binary <SRC;DEST or SRC:DEST>

Additional binary files to be added to the executable. See the
--add-data option for more details. This option can be used multiple
times.

-p DIR, —paths DIR

A path to search for imports (like using PYTHONPATH).
Multiple paths are allowed, separated by ':', or
use this option multiple times. Equivalent to
supplying the pathex argument in the spec file.

—hidden-import MODULENAME, —hiddenimport MODULENAME

Name an import not visible in the code of the script(s). This option can be
used multiple times.

—collect-submodules MODULENAME

Collect all submodules from the specified package or module. This option
can be used multiple times.

—collect-data MODULENAME, —collect-datas MODULENAME

Collect all data from the specified package or module. This option can be
used multiple times.

—collect-binaries MODULENAME

Collect all binaries from the specified package or module. This option can
be used multiple times.

—collect-all MODULENAME

Collect all submodules, data files, and binaries from the specified package
or module. This option can be used multiple times.

—copy-metadata PACKAGENAME

Copy metadata for the specified package. This option can be used multiple
times.

—recursive-copy-metadata PACKAGENAME

Copy metadata for the specified package and all its dependencies. This
option can be used multiple times.

—additional-hooks-dir HOOKSPATH

An additional path to search for hooks. This option can be used multiple
times.

—runtime-hook RUNTIME_HOOKS

Path to a custom runtime hook file. A runtime hook is code that is bundled
with the executable and is executed before any other code or module to set
up special features of the runtime environment. This option can be used
multiple times.

—exclude-module EXCLUDES

Optional module or package (the Python name, not the path name) that will
be ignored (as though it was not found). This option can be used multiple
times.

—splash IMAGE_FILE

(EXPERIMENTAL) Add an splash screen with the image
IMAGE_FILE to the application. The splash screen can
display progress updates while unpacking.

How To Generate¶

-d {all,imports,bootloader,noarchive}, —debug {all,imports,bootloader,noarchive}

Provide assistance with debugging a frozen application. This argument may
be provided multiple times to select several of the following options. —
all: All three of the following options. — imports: specify the -v option
to the underlying Python interpreter, causing it to print a message
each time a module is initialized, showing the place (filename or
built-in module) from which it is loaded. See
https://docs.python.org/3/using/cmdline.html#id4. — bootloader: tell the
bootloader to issue progress messages while initializing and starting the
bundled app. Used to diagnose problems with missing imports. —
noarchive: instead of storing all frozen Python source files as an
archive inside the resulting executable, store them as files in the
resulting output directory.

—python-option PYTHON_OPTION

Specify a command-line option to pass to the Python interpreter at runtime.
Currently supports “v” (equivalent to “–debug imports”), “u”, and “W
<warning control>”.

-s, —strip

Apply a symbol-table strip to the executable and
shared libs (not recommended for Windows)

—noupx

Do not use UPX even if it is available (works
differently between Windows and *nix)

—upx-exclude FILE

Prevent a binary from being compressed when using upx.
This is typically used if upx corrupts certain
binaries during compression. FILE is the filename of
the binary without path. This option can be used
multiple times.

Windows And Mac Os X Specific Options¶

-c, —console, —nowindowed

Open a console window for standard i/o (default). On Windows this option
has no effect if the first script is a ‘.pyw’ file.

-w, —windowed, —noconsole

Windows and Mac OS X: do not provide a console window for standard i/o. On
Mac OS this also triggers building a Mac OS .app bundle. On Windows this
option is automatically set if the first script is a ‘.pyw’ file. This
option is ignored on *NIX systems.

-i <FILE.ico or FILE.exe,ID or FILE.icns or Image or «NONE»>, —icon <FILE.ico or FILE.exe,ID or FILE.icns or Image or «NONE»>

FILE.ico: apply the icon to a Windows executable. FILE.exe,ID: extract the
icon with ID from an exe. FILE.icns: apply the icon to the .app bundle on
Mac OS. If an image file is entered that isn’t in the platform format (ico
on Windows, icns on Mac), PyInstaller tries to use Pillow to translate the
icon into the correct format (if Pillow is installed). Use “NONE” to not
apply any icon, thereby making the OS show some default (default: apply
PyInstaller’s icon). This option can be used multiple times.

—disable-windowed-traceback

Disable traceback dump of unhandled exception in windowed (noconsole) mode
(Windows and macOS only), and instead display a message that this feature
is disabled.

Windows Specific Options¶

—version-file FILE

Add a version resource from FILE to the exe.

-m <FILE or XML>, —manifest <FILE or XML>

Add manifest FILE or XML to the exe.

—no-embed-manifest

Generate an external .exe.manifest file instead of
embedding the manifest into the exe. Applicable only
to onedir mode; in onefile mode, the manifest is
always embedded, regardless of this option.

-r RESOURCE, —resource RESOURCE

Add or update a resource to a Windows executable. The RESOURCE is one to
four items, FILE[,TYPE[,NAME[,LANGUAGE]]]. FILE can be a data file or an
exe/dll. For data files, at least TYPE and NAME must be specified. LANGUAGE
defaults to 0 or may be specified as wildcard * to update all resources of
the given TYPE and NAME. For exe/dll files, all resources from FILE will be
added/updated to the final executable if TYPE, NAME and LANGUAGE are
omitted or specified as wildcard *. This option can be used multiple
times.

—uac-admin

Using this option creates a Manifest that will request
elevation upon application start.

—uac-uiaccess

Using this option allows an elevated application to
work with Remote Desktop.

Windows Side-By-Side Assembly Searching Options (Advanced)¶

—win-private-assemblies

Any Shared Assemblies bundled into the application will be changed into
Private Assemblies. This means the exact versions of these assemblies will
always be used, and any newer versions installed on user machines at the
system level will be ignored.

—win-no-prefer-redirects

While searching for Shared or Private Assemblies to bundle into the
application, PyInstaller will prefer not to follow policies that redirect
to newer versions, and will try to bundle the exact versions of the
assembly.

Mac Os Specific Options¶

—argv-emulation

Enable argv emulation for macOS app bundles. If
enabled, the initial open document/URL event is
processed by the bootloader and the passed file paths
or URLs are appended to sys.argv.

—osx-bundle-identifier BUNDLE_IDENTIFIER

Mac OS .app bundle identifier is used as the default unique program name
for code signing purposes. The usual form is a hierarchical name in reverse
DNS notation. For example: com.mycompany.department.appname (default: first
script’s basename)

—target-architecture ARCH, —target-arch ARCH

Target architecture (macOS only; valid values: x86_64, arm64, universal2).
Enables switching between universal2 and single-arch version of frozen
application (provided python installation supports the target
architecture). If not target architecture is not specified, the current
running architecture is targeted.

—codesign-identity IDENTITY

Code signing identity (macOS only). Use the provided identity to sign
collected binaries and generated executable. If signing identity is not
provided, ad- hoc signing is performed instead.

—osx-entitlements-file FILENAME

Entitlements file to use when code-signing the collected binaries (macOS
only).

Rarely Used Special Options¶

—runtime-tmpdir PATH

Where to extract libraries and support files in onefile-mode. If this
option is given, the bootloader will ignore any temp-folder location
defined by the run-time OS. The _MEIxxxxxx-folder will be created here.
Please use this option only if you know what you are doing.

—bootloader-ignore-signals

Tell the bootloader to ignore signals rather than forwarding them to the
child process. Useful in situations where for example a supervisor process
signals both the bootloader and the child (e.g., via a process group) to
avoid signalling the child twice.

Shortening the Command¶

Because of its numerous options, a full pyinstaller command
can become very long.
You will run the same command again and again as you develop
your script.
You can put the command in a shell script or batch file,
using line continuations to make it readable.
For example, in GNU/Linux:

pyinstaller --noconfirm --log-level=WARN 
    --onefile --nowindow 
    --add-data="README:." 
    --add-data="image1.png:img" 
    --add-binary="libfoo.so:lib" 
    --hidden-import=secret1 
    --hidden-import=secret2 
    --upx-dir=/usr/local/share/ 
    myscript.spec

Or in Windows, use the little-known BAT file line continuation:

pyinstaller --noconfirm --log-level=WARN ^
    --onefile --nowindow ^
    --add-data="README;." ^
    --add-data="image1.png;img" ^
    --add-binary="libfoo.so;lib" ^
    --hidden-import=secret1 ^
    --hidden-import=secret2 ^
    --icon=..MLNMFLCN.ICO ^
    myscript.spec

Running PyInstaller from Python code¶

If you want to run PyInstaller from Python code, you can use the run function
defined in PyInstaller.__main__. For instance, the following code:

import PyInstaller.__main__

PyInstaller.__main__.run([
    'my_script.py',
    '--onefile',
    '--windowed'
])

Is equivalent to:

pyinstaller my_script.py --onefile --windowed

Using UPX¶

UPX is a free utility for compressing executable files and libraries.
It is available for most operating systems and can compress a large number
of executable file formats. See the UPX home page for downloads, and for
the list of supported file formats.

When UPX is available, PyInstaller uses it to individually compress
each collected binary file (executable, shared library, or python
extension) in order to reduce the overall size of the frozen application
(the one-dir bundle directory, or the one-file executable). The frozen
application’s executable itself is not UPX-compressed (regardless of one-dir
or one-file mode), as most of its size comprises the embedded archive that
already contains individually compressed files.

PyInstaller looks for the UPX in the standard executable path(s) (defined
by PATH environment variable), or in the path specified via the
--upx-dir command-line option. If found, it is used automatically.
The use of UPX can be completely disabled using the --noupx
command-line option.

Note

UPX is currently used only on Windows. On other operating systems,
the collected binaries are not processed even if UPX is found. The
shared libraries (e.g., the Python shared library) built on modern
linux distributions seem to break when processed with UPX, resulting
in defunct application bundles. On macOS, UPX currently fails to
process .dylib shared libraries; furthermore the UPX-compressed files
fail the validation check of the codesign utility, and therefore
cannot be code-signed (which is a requirement on the Apple M1 platform).

Excluding problematic files from UPX processing¶

Using UPX may end up corrupting a collected shared library. Known examples
of such corruption are Windows DLLs with Control Flow Guard (CFG) enabled, as well as Qt5 and Qt6
plugins. In such cases,
individual files may be need to be excluded from UPX processing, using
the --upx-exclude option (or using the upx_exclude argument
in the .spec file).

Changed in version 4.2: PyInstaller detects CFG-enabled DLLs and automatically excludes
them from UPX processing.

Changed in version 4.3: PyInstaller automatically excludes Qt5 and Qt6 plugins from
UPX processing.

Although PyInstaller attempts to automatically detect and exclude some of
the problematic files from UPX processing, there are cases where the
UPX excludes need to be specified manually. For example, 32-bit Windows
binaries from the PySide2 package (Qt5 DLLs and python extension modules)
have been reported
to be corrupted by UPX.

Changed in version 5.0: Unlike earlier releases that compared the provided UPX-exclude names
against basenames of the collect binary files (and, due to incomplete
case normalization, required provided exclude names to be lowercase
on Windows), the UPX-exclude pattern matching now uses OS-default
case sensitivity and supports the wildcard (*) operator. It also
supports specifying (full or partial) parent path of the file.

The provided UPX exclude patterns are matched against source (origin)
paths of the collected binary files, and the matching is performed from
right to left.

For example, to exclude Qt5 DLLs from the PySide2 package, use
--upx-exclude "Qt*.dll", and to exclude the python extensions
from the PySide2 package, use --upx-exclude "PySide2*.pyd".

Splash Screen (Experimental)

Note

This feature is incompatible with macOS. In the current design, the
splash screen operates in a secondary thread, which is disallowed by
the Tcl/Tk (or rather, the underlying GUI toolkit) on macOS.

Some applications may require a splash screen as soon as the application
(bootloader) has been started, because especially in onefile mode large
applications may have long extraction/startup times, while the bootloader
prepares everything, where the user cannot judge whether the application
was started successfully or not.

The bootloader is able to display a one-image (i.e. only an image) splash
screen, which is displayed before the actual main extraction process starts.
The splash screen supports non-transparent and hard-cut-transparent images as background
image, so non-rectangular splash screens can also be displayed.

This splash screen is based on Tcl/Tk, which is the same library used by the Python
module tkinter. PyInstaller bundles the dynamic libraries of tcl and tk into the
application at compile time. These are loaded into the bootloader at startup of the
application after they have been extracted (if the program has been packaged as an
onefile archive). Since the file sizes of the necessary dynamic libraries are very small,
there is almost no delay between the start of the application and the splash screen.
The compressed size of the files necessary for the splash screen is about 1.5 MB.

As an additional feature, text can optionally be displayed on the splash screen. This
can be changed/updated from within Python. This offers the possibility to
display the splash screen during longer startup procedures of a Python program
(e.g. waiting for a network response or loading large files into memory). You
can also start a GUI behind the splash screen, and only after it is completely
initialized the splash screen can be closed. Optionally, the font, color and
size of the text can be set. However, the font must be installed on the user
system, as it is not bundled. If the font is not available, a fallback font is used.

If the splash screen is configured to show text, it will automatically (as onefile archive)
display the name of the file that is currently being unpacked, this acts as a progress bar.

The pyi_splash Module¶

The splash screen is controlled from within Python by the pyi_splash module, which can
be imported at runtime. This module cannot be installed by a package manager
because it is part of PyInstaller and is included as needed.
This module must be imported within the Python program. The usage is as follows:

import pyi_splash

# Update the text on the splash screen
pyi_splash.update_text("PyInstaller is a great software!")
pyi_splash.update_text("Second time's a charm!")

# Close the splash screen. It does not matter when the call
# to this function is made, the splash screen remains open until
# this function is called or the Python program is terminated.
pyi_splash.close()

Of course the import should be in a try ... except block, in case the program is
used externally as a normal Python script, without a bootloader.
For a detailed description see pyi_splash Module (Detailed).

Supporting Multiple Platforms¶

If you distribute your application for only one combination of OS and Python,
just install PyInstaller like any other package and use it in your
normal development setup.

Supporting Multiple Python Environments¶

When you need to bundle your application within one OS
but for different versions of Python and support libraries – for example,
a Python 3.6 version and a Python 3.7 version;
or a supported version that uses Qt4 and a development version that uses Qt5 –
we recommend you use venv.
With venv you can maintain different combinations of Python
and installed packages, and switch from one combination to another easily.
These are called virtual environments or venvs in short.

  • Use venv to create as many different development environments as you need,
    each with its unique combination of Python and installed packages.

  • Install PyInstaller in each virtual environment.

  • Use PyInstaller to build your application in each virtual environment.

Note that when using venv, the path to the PyInstaller commands is:

  • Windows: ENV_ROOTScripts

  • Others: ENV_ROOT/bin

Under Windows, the pip-Win package makes it
especially easy to set up different environments and switch between them.
Under GNU/Linux and macOS, you switch environments at the command line.

See PEP 405
and the official Python Tutorial on Virtual Environments and Packages
for more information about Python virtual environments.

Supporting Multiple Operating Systems¶

If you need to distribute your application for more than one OS,
for example both Windows and macOS, you must install PyInstaller
on each platform and bundle your app separately on each.

You can do this from a single machine using virtualization.
The free virtualBox or the paid VMWare and Parallels
allow you to run another complete operating system as a “guest”.
You set up a virtual machine for each “guest” OS.
In it you install
Python, the support packages your application needs, and PyInstaller.

A File Sync & Share system like NextCloud is useful with virtual machines.
Install the synchronization client in each virtual machine,
all linked to your synchronization account.
Keep a single copy of your script(s) in a synchronized folder.
Then on any virtual machine you can run PyInstaller thus:

cd ~/NextCloud/project_folder/src # GNU/Linux, Mac -- Windows similar
rm *.pyc # get rid of modules compiled by another Python
pyinstaller --workpath=path-to-local-temp-folder  
            --distpath=path-to-local-dist-folder  
            ...other options as required...       
            ./myscript.py

PyInstaller reads scripts from the common synchronized folder,
but writes its work files and the bundled app in folders that
are local to the virtual machine.

If you share the same home directory on multiple platforms, for
example GNU/Linux and macOS, you will need to set the PYINSTALLER_CONFIG_DIR
environment variable to different values on each platform otherwise
PyInstaller may cache files for one platform and use them on the other
platform, as by default it uses a subdirectory of your home directory
as its cache location.

It is said to be possible to cross-develop for Windows under GNU/Linux
using the free Wine environment.
Further details are needed, see How to Contribute.

Capturing Windows Version Data¶

A Windows app may require a Version resource file.
A Version resource contains a group of data structures,
some containing binary integers and some containing strings,
that describe the properties of the executable.
For details see the Microsoft Version Information Structures page.

Version resources are complex and
some elements are optional, others required.
When you view the version tab of a Properties dialog,
there’s no simple relationship between
the data displayed and the structure of the resource.
For this reason PyInstaller includes the pyi-grab_version command.
It is invoked with the full path name of any Windows executable
that has a Version resource:

pyi-grab_version executable_with_version_resource

The command writes text that represents
a Version resource in readable form to standard output.
You can copy it from the console window or redirect it to a file.
Then you can edit the version information to adapt it to your program.
Using pyi-grab_version you can find an executable that displays the kind of
information you want, copy its resource data, and modify it to suit your package.

The version text file is encoded UTF-8 and may contain non-ASCII characters.
(Unicode characters are allowed in Version resource string fields.)
Be sure to edit and save the text file in UTF-8 unless you are
certain it contains only ASCII string values.

Your edited version text file can be given with the --version-file
option to pyinstaller or pyi-makespec.
The text data is converted to a Version resource and
installed in the bundled app.

In a Version resource there are two 64-bit binary values,
FileVersion and ProductVersion.
In the version text file these are given as four-element tuples,
for example:

filevers=(2, 0, 4, 0),
prodvers=(2, 0, 4, 0),

The elements of each tuple represent 16-bit values
from most-significant to least-significant.
For example the value (2, 0, 4, 0) resolves to
0002000000040000 in hex.

You can also install a Version resource from a text file after
the bundled app has been created, using the pyi-set_version command:

pyi-set_version version_text_file executable_file

The pyi-set_version utility reads a version text file as written
by pyi-grab_version, converts it to a Version resource,
and installs that resource in the executable_file specified.

For advanced uses, examine a version text file as written by pyi-grab_version.
You find it is Python code that creates a VSVersionInfo object.
The class definition for VSVersionInfo is found in
utils/win32/versioninfo.py in the PyInstaller distribution folder.
You can write a program that imports versioninfo.
In that program you can eval
the contents of a version info text file to produce a
VSVersionInfo object.
You can use the .toRaw() method of that object to
produce a Version resource in binary form.
Or you can apply the unicode() function to the object
to reproduce the version text file.

Building macOS App Bundles¶

Under macOS, PyInstaller always builds a UNIX executable in
dist.
If you specify --onedir, the output is a folder named myscript
containing supporting files and an executable named myscript.
If you specify --onefile, the output is a single UNIX executable
named myscript.
Either executable can be started from a Terminal command line.
Standard input and output work as normal through that Terminal window.

If you specify --windowed with either option, the dist folder
also contains a macOS application named myscript.app.

As you probably know, an application is a special type of folder.
The one built by PyInstaller contains a folder always named
Contents which contains:

  • A folder Frameworks which is empty.

  • A folder Resources that contains an icon file.

  • A file Info.plist that describes the app.

  • A folder MacOS that contains the the executable and
    supporting files, just as in the --onedir folder.

Use the --icon argument to specify a custom icon for the application.
It will be copied into the Resources folder.
(If you do not specify an icon file, PyInstaller supplies a
file icon-windowed.icns with the PyInstaller logo.)

Use the --osx-bundle-identifier argument to add a bundle identifier.
This becomes the CFBundleIdentifier used in code-signing
(see the PyInstaller code signing recipe
and for more detail, the Apple code signing overview technical note).

You can add other items to the Info.plist by editing the spec file;
see Spec File Options for a macOS Bundle below.

Platform-specific Notes¶

GNU/Linux¶

Making GNU/Linux Apps Forward-Compatible¶

Under GNU/Linux, PyInstaller does not bundle libc
(the C standard library, usually glibc, the Gnu version) with the app.
Instead, the app expects to link dynamically to the libc from the
local OS where it runs.
The interface between any app and libc is forward compatible to
newer releases, but it is not backward compatible to older releases.

For this reason, if you bundle your app on the current version of GNU/Linux,
it may fail to execute (typically with a runtime dynamic link error) if
it is executed on an older version of GNU/Linux.

The solution is to always build your app on the oldest version of
GNU/Linux you mean to support.
It should continue to work with the libc found on newer versions.

The GNU/Linux standard libraries such as glibc are distributed in 64-bit
and 32-bit versions, and these are not compatible.
As a result you cannot bundle your app on a 32-bit system and run it
on a 64-bit installation, nor vice-versa.
You must make a unique version of the app for each word-length supported.

Note that PyInstaller does bundle other shared libraries that are discovered
via dependency analysis, such as libstdc++.so.6, libfontconfig.so.1,
libfreetype.so.6. These libraries may be required on systems where older
(and thus incompatible) versions of these libraries are available. On the
other hand, the bundled libraries may cause issues when trying to load a
system-provided shared library that is linked against a newer version of the
system-provided library.

For example, system-installed mesa DRI drivers (e.g., radeonsi_dri.so)
depend on the system-provided version of libstdc++.so.6. If the frozen
application bundles an older version of libstdc++.so.6 (as collected from
the build system), this will likely cause missing symbol errors and prevent
the DRI drivers from loading. In this case, the bundled libstdc++.so.6
should be removed. However, this may not work on a different distribution
that provides libstdc++.so.6 older than the one from the build system; in
that case, the bundled version should be kept, because the system-provided
version may lack the symbols required by other collected binaries that depend
on libstdc++.so.6.

Windows¶

The developer needs to take
special care to include the Visual C++ run-time .dlls:
Python 3.5+ uses Visual Studio 2015 run-time, which has been renamed into
“Universal CRT“
and has become part of Windows 10.
For Windows Vista through Windows 8.1 there are Windows Update packages,
which may or may not be installed in the target-system.
So you have the following options:

  1. Build on Windows 7 which has been reported to work.

  2. Include one of the VCRedist packages (the redistributable package files)
    into your application’s installer. This is Microsoft’s recommended way, see
    “Distributing Software that uses the Universal CRT“ in the above-mentioned
    link, numbers 2 and 3.

  3. Install the Windows Software Development Kit (SDK) for Windows 10 and expand the
    .spec-file to include the required DLLs, see “Distributing Software that
    uses the Universal CRT“ in the above-mentioned link, number 6.

    If you think, PyInstaller should do this by itself, please help
    improving
    PyInstaller.

macOS¶

Making macOS apps Forward-Compatible¶

On macOS, system components from one version of the OS are usually compatible
with later versions, but they may not work with earlier versions. While
PyInstaller does not collect system components of the OS, the collected
3rd party binaries (e.g., python extension modules) are built against
specific version of the OS libraries, and may or may not support older
OS versions.

As such, the only way to ensure that your frozen application supports
an older version of the OS is to freeze it on the oldest version of the
OS that you wish to support. This applies especially when building with
Homebrew python, as its binaries usually explicitly target the
running OS.

For example, to ensure compatibility with “Mojave” (10.14) and later versions,
you should set up a full environment (i.e., install python, PyInstaller,
your application’s code, and all its dependencies) in a copy of macOS 10.14,
using a virtual machine if necessary. Then use PyInstaller to freeze
your application in that environment; the generated frozen application
should be compatible with that and later versions of macOS.

Building 32-bit Apps in macOS¶

Note

This section is largely obsolete, as support for 32-bit application
was removed in macOS 10.15 Catalina (for 64-bit multi-arch support
on modern versions of macOS, see here).
However, PyInstaller still supports building 32-bit bootloader,
and 32-bit/64-bit Python installers are still available from
python.org for (some) versions of Python 3.7.

Older versions of macOS supported both 32-bit and 64-bit executables.
PyInstaller builds an app using the the word-length of the Python used to execute it.
That will typically be a 64-bit version of Python,
resulting in a 64-bit executable.
To create a 32-bit executable, run PyInstaller under a 32-bit Python.

To verify that the installed python version supports execution in either
64- or 32-bit mode, use the file command on the Python executable:

$ file /usr/local/bin/python3
/usr/local/bin/python3: Mach-O universal binary with 2 architectures
/usr/local/bin/python3 (for architecture i386):     Mach-O executable i386
/usr/local/bin/python3 (for architecture x86_64):   Mach-O 64-bit executable x86_64

The OS chooses which architecture to run, and typically defaults to 64-bit.
You can force the use of either architecture by name using the arch command:

$ /usr/local/bin/python3
Python 3.7.6 (v3.7.6:43364a7ae0, Dec 18 2019, 14:12:53)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys; sys.maxsize
9223372036854775807

$ arch -i386 /usr/local/bin/python3
Python 3.7.6 (v3.7.6:43364a7ae0, Dec 18 2019, 14:12:53)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys; sys.maxsize
2147483647

Note

PyInstaller does not provide pre-built 32-bit bootloaders for
macOS anymore. In order to use PyInstaller with 32-bit python,
you need to build the bootloader
yourself, using an XCode
version that still supports compiling 32-bit. Depending on the
compiler/toolchain, you may also need to explicitly pass
--target-arch=32bit to the waf command.

Getting the Opened Document Names¶

When user double-clicks a document of a type that is registered with
your application, or when a user drags a document and drops it
on your application’s icon, macOS launches your application
and provides the name(s) of the opened document(s) in the
form of an OpenDocument AppleEvent.

These events are typically handled via installed event handlers in your
application (e.g., using Carbon API via ctypes, or using
facilities provided by UI toolkits, such as tkinter or PyQt5).

Alternatively, PyInstaller also supports conversion of open
document/URL events into arguments that are appended to sys.argv.
This applies only to events received during application launch, i.e.,
before your frozen code is started. To handle events that are dispatched
while your application is already running, you need to set up corresponding
event handlers.

For details, see this section.

AIX¶

Depending on whether Python was build as a 32-bit or a 64-bit executable
you may need to set or unset
the environment variable OBJECT_MODE.
To determine the size the following command can be used:

$ python -c "import sys; print(sys.maxsize <= 2**32)"
True

When the answer is True (as above) Python was build as a 32-bit
executable.

When working with a 32-bit Python executable proceed as follows:

$ unset OBJECT_MODE
$ pyinstaller <your arguments>

When working with a 64-bit Python executable proceed as follows:

$ export OBJECT_MODE=64
$ pyinstaller <your arguments>

You have just created an awesome new application. Maybe it’s a game or maybe it’s an image viewer. Whatever your application is, you want to share it with your friend or a family member. However, you know they won’t know how to install Python or any of the dependencies. What do you do? You need something that will transform your code into an executable!

Python has many different tools you can use to convert your Python code into a Windows executable. Here are a few different tools you can use:

  • PyInstaller
  • py2exe
  • cx_freeze
  • Nuitka
  • Briefcase

These various tools can all be used to create executables for Windows. They work slightly differently, but the end result is that you will have an executable and perhaps some other files that you need to distribute too.

PyInstaller and Briefcase can be used to create Windows and MacOS executables. Nuitka is a little different in that it turns your Python code into C code before converting it into an executable. What this means is that the result ends up much smaller than PyInstaller’s executable.

However, for this article, you will focus on PyInstaller. It is one of the most popular packages for this purpose and has a lot of support. PyInstaller also has good documentation and there are many tutorials available for it.

In this article, you will learn about:

  • Installing PyInstaller
  • Creating an Executable for a Command-Line Application
  • Creating an Executable for a GUI

Let’s transform some code into a Windows executable!

Installing PyInstaller

To get started, you will need to install PyInstaller. Fortunately, PyInstaller is a Python package that can be easily installed using pip:

python -m pip install pyinstaller

This command will install PyInstaller and any dependencies that it needs on your machine. You should now be ready to create an executable with PyInstaller!

Creating an Executable for a Command-Line Application

The next step is to pick some code that you want to turn into an executable. You can use the PySearch utility from chapter 32 of my book, Python 101: 2nd Edition, and turn it into a binary. Here is the code:

# pysearch.py

import argparse
import pathlib

def search_folder(path, extension, file_size=None):
    """
    Search folder for files
    """
    folder = pathlib.Path(path)
    files = list(folder.rglob(f'*.{extension}'))

    if not files:
        print(f'No files found with {extension=}')
        return

    if file_size is not None:
        files = [f for f in files
                 if f.stat().st_size > file_size]

    print(f'{len(files)} *.{extension} files found:')
    for file_path in files:
        print(file_path)


def main():
    parser = argparse.ArgumentParser(
        'PySearch',
        description='PySearch - The Python Powered File Searcher')
    parser.add_argument('-p', '--path',
                        help='The path to search for files',
                        required=True,
                        dest='path')
    parser.add_argument('-e', '--ext',
                        help='The extension to search for',
                        required=True,
                        dest='extension')
    parser.add_argument('-s', '--size',
                        help='The file size to filter on in bytes',
                        type=int,
                        dest='size',
                        default=None)

    args = parser.parse_args()
    search_folder(args.path, args.extension, args.size)

if __name__ == '__main__':
    main()

Next, open up a Command Prompt (cmd.exe) in Windows and navigate to the folder that has your pysearch.py file in it. To turn the Python code into a binary executable, you need to run the following command:

pyinstaller pysearch.py

If Python isn’t on your Windows path, you may need to type out the full path to pyinstaller to get it to run. It will be located in a Scripts folder wherever your Python is installed on your system.

When you run that command, you will see some output that will look similar to the following:

6531 INFO: PyInstaller: 3.6
6576 INFO: Python: 3.8.2
6707 INFO: Platform: Windows-10-10.0.10586-SP0
6828 INFO: wrote C:UsersmikeAppDataLocalProgramsPythonPython38-32pysearch.spec
6880 INFO: UPX is not available.
7110 INFO: Extending PYTHONPATH with paths
['C:\Users\mike\AppData\Local\Programs\Python\Python38-32',
 'C:\Users\mike\AppData\Local\Programs\Python\Python38-32']
7120 INFO: checking Analysis
7124 INFO: Building Analysis because Analysis-00.toc is non existent
7128 INFO: Initializing module dependency graph...
7153 INFO: Caching module graph hooks...
7172 INFO: Analyzing base_library.zip ...

PyInstaller is very verbose and will print out a LOT of output. When it is finished, you will have a dist folder with a pysearch folder inside of it. Within the pysearch folder are many other files, including one called pysearch.exe. You can try navigating to the pysearch folder in your Command Prompt and then run pysearch.exe:

C:UsersmikeAppDataLocalProgramsPythonPython38-32distpysearch>pysearch.exe
usage: PySearch [-h] -p PATH -e EXTENSION [-s SIZE]
PySearch: error: the following arguments are required: -p/--path, -e/--ext

That looks like a pretty successful build! However, if you want to give the executable to your friends, you will have to give them the entire pysearch folder as all those other files in there are also required.

You can fix that issue by passing the --onefile flag, like this:

pyinstaller pysearch.py --onefile

The output from that command is similar to the first command. This time when you go into the dist folder though, you will find a single file in there called pysearch.exe instead of a folder full of files.

Creating an Executable for a GUI

Creating an executable for a GUI is slightly different than it is for a command-line application. The reason is that the GUI is the main interface and PyInstaller’s default is that the user will be using a Command Prompt or console window. If you run either of the PyInstaller commands that you learned about in the previous section, it will successfully create your executable. However, when you go to use your executable, you will see a Command Prompt appear in addition to your GUI.

You usually don’t want that. To suppress the Command Prompt, you need to use the --noconsole flag.

To test out how this would work, grab the code for the image viewer that was created with wxPython from chapter 42 of Python 101: 2nd Edition. Here is the code again for your convenience:

# image_viewer.py

import wx

class ImagePanel(wx.Panel):

    def __init__(self, parent, image_size):
        super().__init__(parent)
        self.max_size = 240

        img = wx.Image(*image_size)
        self.image_ctrl = wx.StaticBitmap(self, 
                                          bitmap=wx.Bitmap(img))

        browse_btn = wx.Button(self, label='Browse')
        browse_btn.Bind(wx.EVT_BUTTON, self.on_browse)

        self.photo_txt = wx.TextCtrl(self, size=(200, -1))

        main_sizer = wx.BoxSizer(wx.VERTICAL)
        hsizer = wx.BoxSizer(wx.HORIZONTAL)

        main_sizer.Add(self.image_ctrl, 0, wx.ALL, 5)
        hsizer.Add(browse_btn, 0, wx.ALL, 5)
        hsizer.Add(self.photo_txt, 0, wx.ALL, 5)
        main_sizer.Add(hsizer, 0, wx.ALL, 5)

        self.SetSizer(main_sizer)
        main_sizer.Fit(parent)
        self.Layout()

    def on_browse(self, event):
        """
        Browse for an image file
        @param event: The event object
        """
        wildcard = "JPEG files (*.jpg)|*.jpg"
        with wx.FileDialog(None, "Choose a file",
                           wildcard=wildcard,
                           style=wx.ID_OPEN) as dialog:
            if dialog.ShowModal() == wx.ID_OK:
                self.photo_txt.SetValue(dialog.GetPath())
                self.load_image()

    def load_image(self):
        """
        Load the image and display it to the user
        """
        filepath = self.photo_txt.GetValue()
        img = wx.Image(filepath, wx.BITMAP_TYPE_ANY)

        # scale the image, preserving the aspect ratio
        W = img.GetWidth()
        H = img.GetHeight()
        if W > H:
            NewW = self.max_size
            NewH = self.max_size * H / W
        else:
            NewH = self.max_size
            NewW = self.max_size * W / H
        img = img.Scale(NewW,NewH)

        self.image_ctrl.SetBitmap(wx.Bitmap(img))
        self.Refresh()


class MainFrame(wx.Frame):

    def __init__(self):
        super().__init__(None, title='Image Viewer')
        panel = ImagePanel(self, image_size=(240,240))
        self.Show()


if __name__ == '__main__':
    app = wx.App(redirect=False)
    frame = MainFrame()
    app.MainLoop()

To turn this into an executable, you would run the following PyInstaller command:

pyinstaller.exe image_viewer.py --noconsole

Note that you are not using the --onefile flag here. Windows Defender will flag GUIs that are created with the --onefile as malware and remove it. You can get around that by not using the --onefile flag or by digitally signing the executable. Starting in Windows 10, all GUI applications need to be signed or they are considered malware.

Microsoft has a Sign Tool you can use, but you will need to purchase a digital certificate or create a self-signed certificate with Makecert, a .NET tool or something similar.

Wrapping Up

There are lots of different ways to create an executable with Python. In this article, you used PyInstaller. You learned about the following topics:

  • Installing PyInstaller
  • Creating an Executable for a Command-Line Application
  • Creating an Executable for a GUI

PyInstaller has many other flags that you can use to modify its behavior when generating executables. If you run into issues with PyInstaller, there is a mailing list that you can turn to. Or you can search with Google and on StackOverflow. Most of the common issues that crop up are covered either in the PyInstaller documentation or are easily discoverable through searching online.

Would you like to learn more about Python?

Python 101 – 2nd Edition

Purchase now on Leanpub or Amazon

Понравилась статья? Поделить с друзьями:
  • Как написать email на компьютере
  • Как написать email на английском примеры
  • Как написать email на английском егэ 2022
  • Как написать email другу на английском языке
  • Как написать email адрес