На что pip тратит 23 секунды, а uv — меньше двух. Мы разложили установку 89 пакетов по шагам

Скачивание, распаковка, байт-код, создание окружения: оценили вклад каждого шага по разности прогонов. Показываем, где uv экономит время, почему его окружение на 69 МБ меньше и чем за это платит первый запуск.
На что pip тратит 23 секунды, а uv — меньше двух. Мы разложили установку 89 пакетов по шагам

uv ставит пакеты быстрее pip — это известно и без нас. Нас интересовало, из чего складывается разница. Мы взяли список зависимостей реального проекта и по пять раз установили их в чистое окружение двумя инструментами: pip 26.3, который вышел 2 ноября, и uv 0.13.8, выпущенным 12 ноября. Прогоны делали с пустым и заполненным кешем, с компиляцией байт-кода и без неё. Затем разложили время по шагам.

Из 22,87 секунды холодной установки pip около 11 уходит на скачивание и запись кеша, около семи — на компиляцию байт-кода, около четырёх — на распаковку и копирование файлов. Это приблизительная оценка по разности времени прогонов. uv проходит тот же путь за 1,75 секунды: загружает пакеты параллельно, на нашем диске связывает файлы из кеша с окружением жёсткими ссылками, а байт-код по умолчанию не компилирует. За это приходится платить при первом запуске программы: импорт тех же библиотек в свежем окружении занял 3,22 секунды вместо 1,30. Ниже — команды, вывод и разбор каждой цифры.

Что ставили и на чём

Проект — бэкенд из шаблона full-stack-fastapi-template (коммит 77e550a): FastAPI, SQLModel, Alembic, psycopg, Sentry SDK и инструменты разработки — pytest, mypy, Ruff, ty, coverage. Всего 19 прямых зависимостей. Шаблон требует Python 3.14, у нас системный Python 3.12, поэтому из проекта мы взяли только список зависимостей. Вот наш requirements.in: 14 основных зависимостей и пять из группы для разработки.

        fastapi[standard]>=0.141.1,<1.0.0
python-multipart<1.0.0,>=0.0.27
email-validator<3.0.0.0,>=2.1.0.post1
pydantic>=2.13.5
emails>=1.1.2,<2.0
jinja2<4.0.0,>=3.1.4
alembic>=1.19.1,<2.0.0
httpx<1.0.0,>=0.25.1
psycopg[binary]>=3.3.6,<4.0.0
sqlmodel>=0.0.46,<1.0.0
pydantic-settings<3.0.0,>=2.2.1
sentry-sdk[fastapi]>=2.70.0,<3.0.0
pyjwt>=2.15.0,<3.0.0
pwdlib[argon2,bcrypt]>=0.3.1
pytest<10.0.0,>=7.4.3
mypy<3.0.0,>=1.8.0
ty>=0.0.25
ruff<1.0.0,>=0.16.0
coverage<8.0.0,>=7.4.3
    

Версии зафиксировали под Python 3.12:

        uv pip compile requirements.in --python-version 3.12 -o requirements.txt
    

Получилось 89 пакетов, среди них FastAPI 0.163.1, Pydantic 2.14.3, SQLAlchemy 2.1.8, mypy 2.4.1 и Ruff 0.17.5. У 88 есть готовые колёса, один (dkimpy) распространяется только в исходниках, и оба инструмента собирают его сами. Суммарный размер архивов — 72 МБ. Если повторить команду позже, часть версий окажется новее.

Параметр Значение
Процессор AMD Ryzen 9 5900X, 22 логических ядра доступны в WSL2
Система Ubuntu 22.04.5 под WSL2, ядро 6.18, диск ext4
Python 3.12.15
pip 26.3
uv 0.13.8
Ограничение каждый прогон в отдельной группе systemd с лимитом памяти 2 ГБ

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

Почему пакеты раздавал локальный сервер

Первая попытка напрямую с PyPI провалилась. Канал до files.pythonhosted.org в день замера давал около 200 КБ/с, и холодная установка через uv не уложилась в 120 секунд. При такой скорости оба инструмента почти всё время ждут сеть, и сравнивать их бессмысленно.

Поэтому все 89 архивов мы скачали заранее и подняли на той же машине индекс пакетов: каталог со страницами в формате Simple API и маленький сервер на стандартной библиотеке Python. Он отдаёт файлы с теми же заголовками кеширования, что и PyPI.

        # serve.py: локальный индекс пакетов с заголовками кеширования, как у PyPI
import http.server, functools
class H(http.server.SimpleHTTPRequestHandler):
    protocol_version = 'HTTP/1.1'
    def end_headers(self):
        self.send_header('Cache-Control', 'max-age=365000000, immutable' if self.path.startswith('/files/') else 'max-age=600')
        super().end_headers()
    def log_message(self, *a): pass
class S(http.server.ThreadingHTTPServer):
    request_queue_size = 512
S(('127.0.0.1', 8765), functools.partial(H, directory='index')).serve_forever()
    

На этом стенде мы дважды ошиблись, и обе ошибки исказили бы результат. Сначала сервер принимал соединения с очередью по умолчанию, в пять запросов. uv открывает десятки соединений сразу, часть из них, по нашему предположению, ждала повторной отправки, и холодная установка занимала то 4,9, то 18,9 секунды. После request_queue_size = 512 разброс исчез. Вторая ошибка касалась pip: без флага --trusted-host он не складывал в кеш файлы, полученные по обычному HTTP. Каталог кеша после установки весил 1 МБ, и «тёплый» прогон ничем не отличался от холодного. С флагом кеш вырос до 76 МБ.

Отсюда ограничение: цифры ниже показывают работу самих инструментов при быстрой сети. На медленном канале разница между ними сожмётся, потому что скачивание займёт больше времени, чем всё остальное.

Команды замера

Для pip мы создавали окружение стандартным модулем venv, обновляли в нём pip до 26.3 (это время не учитывали) и ставили зависимости:

        python3 -m venv env
env/bin/pip install --index-url http://127.0.0.1:8765/simple/ --trusted-host 127.0.0.1 -r requirements.txt
    

Для uv — то же самое его командами:

        uv venv --python /usr/bin/python3 env
uv pip install --python env/bin/python --index-url http://127.0.0.1:8765/simple/ -r requirements.txt
    

Кеш каждого инструмента лежал в отдельном каталоге, заданном через PIP_CACHE_DIR и UV_CACHE_DIR. Перед холодным прогоном каталог удаляли, перед тёплым оставляли. Окружение каждый раз создавали заново. Третий вариант в таблицах — uv с флагом --compile-bytecode. Зачем он нужен, станет понятно дальше.

Сырые строки одного круга из журнала:

        pip cold run1 rc=0 venv_s=2.00 install_s=21.78 size_mb=293 files=10446 pyc=3777
uv cold run1 rc=0 venv_s=0.08 install_s=1.81 size_mb=224 files=6161 pyc=0
uvc cold run1 rc=0 venv_s=0.08 install_s=2.48 size_mb=279 files=9496 pyc=3335
pip warm run1 rc=0 venv_s=1.94 install_s=10.60 size_mb=293 files=10446 pyc=3777
uv warm run1 rc=0 venv_s=0.02 install_s=0.30 size_mb=224 files=6161 pyc=0
uvc warm run1 rc=0 venv_s=0.01 install_s=0.93 size_mb=279 files=9496 pyc=3335
    

Результат: время установки

Режим pip 26.3 uv 0.13.8 uv с --compile-bytecode
Пустой кеш, медиана 22,87 с 1,75 с 2,55 с
Пустой кеш, разброс 21,42–24,10 с 1,67–1,87 с 2,39–3,90 с
Заполненный кеш, медиана 11,48 с 0,26 с 0,88 с
Заполненный кеш, разброс 9,96–13,28 с 0,23–0,30 с 0,87–0,94 с
Создание окружения 2,01 с 0,08 с 0,08 с

С пустым кешем uv быстрее в 13 раз, с заполненным — в 44 раза. Создание пустого окружения различается ещё сильнее: python3 -m venv тратит около двух секунд, и почти всё это время уходит на установку pip внутрь окружения. С флагом --without-pip та же команда отработала за 0,11 секунды. uv venv укладывается в 0,08 секунды и pip в окружение не кладёт.

У pip заполненный кеш сократил время только вдвое. Файлы он уже не скачивает, но каждый архив распаковывает и копирует в окружение заново, а затем компилирует модули в байт-код. Чтобы оценить долю компиляции, мы повторили тёплую установку pip с флагом --no-compile: медиана пяти прогонов — 4,28 секунды при разбросе 3,91–13,24. Получается, что около семи секунд из 11,48 на нашем стенде уходит на байт-код. uv хранит в кеше уже распакованные пакеты, и на нашем диске вместо копирования связывал их с окружением жёсткими ссылками, об этом ниже.

Та же установка по шагам

Отдельно каждый шаг мы не засекали — это оценка по разности медиан. Холодная установка минус тёплая даёт скачивание и запись кеша, тёплая установка pip с флагом --no-compile — распаковку и копирование, а остаток приходится на байт-код.

Шаг pip 26.3 uv 0.13.8
Создание окружения 2,01 с 0,08 с
Скачивание и запись кеша 11,4 с 1,5 с
Распаковка и размещение файлов 4,3 с 0,26 с
Компиляция байт-кода 7,2 с 0,62 с с флагом --compile-bytecode, по умолчанию не выполняется

Больше всего uv выигрывает на скачивании: 9,9 секунды. Но и два шага, не связанных с сетью, вместе дают 11 секунд: файлы он на нашем стенде не копирует, а байт-код не компилирует. Даже если включить компиляцию, она занимает у него 0,62 секунды против 7,2 у pip.

Почему окружение uv меньше на 69 МБ

Показатель pip uv uv с --compile-bytecode
Размер окружения 293 МБ 224 МБ 279 МБ
Файлов 10 446 6 161 9 496
Из них .pyc 3 777 0 3 335

Разница складывается из двух частей. Первая — байт-код. pip после установки компилирует каждый модуль в файл .pyc, а uv по умолчанию этого не делает: Python скомпилирует модуль сам при первом импорте. С флагом --compile-bytecode окружение uv вырастает с 224 до 279 МБ. Вторая часть — сам pip: пустое окружение от venv весит 14 МБ, потому что в нём лежит копия pip. Сумма сходится точно: 279 + 14 = 293.

То есть на диске uv ничего не сжимает. В его окружении лежат те же пакеты, только без байт-кода и без pip.

Чем uv платит за отсутствие байт-кода

Мы запустили в каждом свежем окружении одну и ту же команду и замерили время:

        env/bin/python -c "import fastapi, sqlmodel, sentry_sdk, pydantic, alembic, httpx, mypy.api"
    
Окружение Первый запуск Повторный запуск
uv 3,22 с 1,23 с
uv с --compile-bytecode 1,33 с не мерили
pip 1,30 с 1,20 с

При первом запуске Python в окружении uv компилирует импортированные модули и записывает 636 файлов .pyc — окружение вырастает с 224 до 240 МБ. Со второго запуска разницы с pip уже нет. Для рабочей машины разовая задержка в две секунды незаметна. С контейнерами иначе: образ собирается один раз, а каждый новый контейнер стартует из него без байт-кода и компилирует модули заново. Документация uv для сборки образов Docker советует включать компиляцию флагом или переменной UV_COMPILE_BYTECODE=1. По нашему замеру, установка с этим флагом всё равно остаётся в 13 раз быстрее pip на заполненном кеше.

Сколько места занимают пять окружений

После серии на диске осталось по пять одинаковых окружений каждого инструмента. Вот что показал du:

Что считаем pip uv
Пять окружений вместе 1 464 МБ 240 МБ
Кеш 76 МБ 230 МБ
Пять окружений и кеш 1 540 МБ 250 МБ

В окружении uv 5 844 файла из 6 161 имеют больше одной жёсткой ссылки: это те же файлы, что лежат в кеше. Пятое окружение добавило к кешу 5 МБ. В настройках uv режимом по умолчанию для Linux указано клонирование с копированием при записи; ext4 его не поддерживает, и на нашем диске uv связал файлы жёсткими ссылками. У pip жёстких ссылок нет: каждое окружение — полная копия.

Отсюда же следует обратная сторона. Кеш uv втрое больше кеша pip, потому что пакеты в нём лежат распакованными. И удаление кеша не освободит это место, если живы окружения: файлы остаются на диске, пока на них указывает хотя бы одна жёсткая ссылка.

Что из этого следует

Это выводы Proglib по одному проекту на одной машине, без претензии на общий закон.

  • Если окружение создаётся редко, выигрыш uv измеряется десятками секунд в месяц. Он заметен там, где окружения пересоздаются постоянно: в CI, в тестовых матрицах, при переключении веток с разными зависимостями.
  • На нашем стенде с заполненным кешем pip тратил время на распаковку, копирование и компиляцию байт-кода: сеть была локальной. Кеш сократил установку примерно вдвое. На другом проекте и с другой сетью соотношение будет иным.
  • Сравнивать размер окружений без оговорки про байт-код некорректно. В равных условиях разница — 14 МБ, и это вес самого pip.
  • Для образов Docker с uv включайте UV_COMPILE_BYTECODE=1, иначе экономия на сборке вернётся задержкой на старте.
  • Несколько окружений с пересекающимися зависимостями у uv почти не занимают места, пока кеш и окружения лежат на одном разделе.

Чего замер не показывает: времени разрешения зависимостей (версии были зафиксированы заранее), поведения на медленной сети и на Windows, работы с частными индексами. Файл requirements.in, скрипт сервера и команды приведены выше, по ним прогон можно повторить на своём проекте.

Источники

Комментарии

ЛУЧШИЕ СТАТЬИ ПО ТЕМЕ