Ответ 1

Вот мое решение с git. Он позволяет вам просто добавлять и фиксировать (и различать), как обычно: эти операции не изменят ваше рабочее дерево, и в то же время (пере) запуск ноутбука не изменит вашу историю git.

Хотя это, вероятно, можно адаптировать к другим VCS, я знаю, что он не удовлетворяет вашим требованиям (по крайней мере, агностичность VSC). Тем не менее, это идеально для меня, и хотя это ничего особенно блестящего, и многие люди, вероятно, уже используют его, я не нашел ясных инструкций о том, как его реализовать, отправляясь в поиски. Поэтому это может быть полезно другим людям.

• Сохраните файл с этот контент где-нибудь (для следующего, допустим ~/bin/ipynb_output_filter.py)
• Сделать его исполняемым (chmod +x ~/bin/ipynb_output_filter.py)

• Создайте файл ~/.gitattributes со следующим содержимым

  *.ipynb    filter=dropoutput_ipynb
  

• Выполните следующие команды:

  git config --global core.attributesfile ~/.gitattributes
  git config --global filter.dropoutput_ipynb.clean ~/bin/ipynb_output_filter.py
  git config --global filter.dropoutput_ipynb.smudge cat
  

Готово!

Ограничения:

• он работает только с git
• в git, если вы находитесь в ветке somebranch, и вы делаете git checkout otherbranch; git checkout somebranch, вы обычно ожидаете, что рабочее дерево не изменится. Здесь вместо этого вы потеряете выходную и ячеистую нумерацию ноутбуков, источник которых отличается от двух ветвей.
• В общем случае вывод не является версией вообще, как в случае с решением Gregory. Чтобы не просто выбросить его каждый раз, когда вы делаете что-либо, связанное с проверкой, этот подход можно изменить, сохранив его в отдельных файлах (но обратите внимание, что во время выполнения вышеуказанного кода идентификатор фиксации неизвестен!), и, возможно, их версию (но обратите внимание, что для этого потребуется нечто большее, чем git commit notebook_file.ipynb, хотя он, по крайней мере, сохранит git diff notebook_file.ipynb бесплатно от мусора base64).
• который сказал, кстати, если вы делаете код (т.е. совершенным кем-то другим, не использующим этот подход), который содержит некоторый вывод, выход проверяется нормально. Только локально произведенный выход теряется.

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

EDIT:

• Если вы примете решение, как я предложил, то есть во всем мире - у вас возникнут проблемы, если для некоторых git repo вы хотите для вывода версии. Поэтому, если вы хотите отключить фильтрацию вывода для определенного репозитория git, просто создайте внутри него файл .git/info/attributes, с

  **. ipynb filter =

как содержимое. Ясно, что таким же образом можно сделать обратное: включить фильтрацию только для определенного репозитория.

• код теперь поддерживается в своем собственном git repo

• если приведенные выше инструкции приводят к ImportErrors, попробуйте добавить "ipython" до пути к script:

  git config --global filter.dropoutput_ipynb.clean ipython ~/bin/ipynb_output_filter.py
  

EDIT: май 2016 года (обновлено в феврале 2017 года): для полноты моей версии script есть несколько альтернатив, вот список тех, что я знаю: nbstripout (другое варианты), nbstrip, jq.

Ответ 2

У нас есть совлокальный проект, в котором продукт Jupyter Notebooks, и мы используем подход за последние шесть месяцев, который отлично работает: мы автоматически активируем файлы .py и отслеживаем как файлы .ipynb, так и .py.

Таким образом, если кто-то хочет просмотреть/загрузить последний ноутбук, он может сделать это через github или nbviewer, и если кто-то хочет увидеть, как изменился код ноутбука, они могут просто посмотреть на изменения в .py файлы.

Для серверов Jupyter для ноутбуков это можно сделать, добавив строки

import os
from subprocess import check_call

def post_save(model, os_path, contents_manager):
    """post-save hook for converting notebooks to .py scripts"""
    if model['type'] != 'notebook':
        return # only do this for notebooks
    d, fname = os.path.split(os_path)
    check_call(['jupyter', 'nbconvert', '--to', 'script', fname], cwd=d)

c.FileContentsManager.post_save_hook = post_save

в файл jupyter_notebook_config.py и перезапустить сервер ноутбука.

Если вы не знаете, в каком каталоге вы найдете свой файл jupyter_notebook_config.py, вы можете ввести jupyter --config-dir, и если вы не найдете там файл, его можно создать, набрав jupyter notebook --generate-config.

Для серверов Ipython 3 для ноутбуков это можно сделать, добавив строки

import os
from subprocess import check_call

def post_save(model, os_path, contents_manager):
    """post-save hook for converting notebooks to .py scripts"""
    if model['type'] != 'notebook':
        return # only do this for notebooks
    d, fname = os.path.split(os_path)
    check_call(['ipython', 'nbconvert', '--to', 'script', fname], cwd=d)

c.FileContentsManager.post_save_hook = post_save

в файл ipython_notebook_config.py и перезагрузите сервер ноутбука. Эти строки связаны с ответом github answer @minrk, предоставленным, а @dror также включает их в свой ответ SO.

Для серверов Ipython 2 для ноутбуков это можно выполнить, запустив сервер, используя:

ipython notebook --script

или добавив строку

c.FileNotebookManager.save_script = True

в файл ipython_notebook_config.py и перезагрузите сервер ноутбука.

Если вы не знаете, в каком каталоге вы найдете свой ipython_notebook_config.py файл, вы можете ввести ipython locate profile default, и если вы не найдете там файл, вы можете создать его, набрав ipython profile create.

Здесь наш проект по github, который использует этот подход: и здесь пример github изучения недавних изменений в ноутбуке.

Мы были очень довольны этим.

Ответ 3

Я создал nbstripout на основе MinRKs gist, который поддерживает как Git, так и Mercurial (благодаря mforbes). Он предназначен для использования как автономно в командной строке, так и в виде фильтра, который легко (un) устанавливается в текущем репозитории через nbstripout install/nbstripout uninstall.

Получите его от PyPI или просто

pip install nbstripout

Ответ 4

Вот новое решение от Cyrille Rossant для IPython 3.0, которое сохраняется в файлах markdown, а не в json файлах ipymd:

https://github.com/rossant/ipymd

Ответ 5

(2017-02)

стратегии

• on_commit():
  • разделите вывод > name.ipynb(nbstripout,)
  • разделите вывод > name.clean.ipynb(nbstripout,)
  • всегда nbconvert в python: name.ipynb.py(nbconvert)
  • всегда конвертировать в уценку: name.ipynb.md(nbconvert, ipymd)
• vcs.configure():
  • git diffftool, mergetool: nbdiff и nbmerge из nbdime

инструменты

• nbstripout: выньте выходы из ноутбука
  • src: https://gist.github.com/minrk/6176788
  • src: https://github.com/kynan/nbstripout
    • pip install nbstripout; nbstripout install
• ipynb_output_filter: выньте выходы из ноутбука
  • src: https://github.com/toobaz/ipynb_output_filter/blob/master/ipynb_output_filter.py
• ipymd: конвертировать между {Jupyter, Markdown, O'Reilly Atlas Markdown, OpenDocument,.py}
  • src: https://github.com/rossant/ipymd
• nbdime: "Инструменты для разметки и слияния ноутбуков Jupyter". (2015)
  • src: https://github.com/jupyter/nbdime
  • docs: http://nbdime.readthedocs.io/
    • nbdiff: сравнить ноутбуки в терминальном режиме
      • nbdime nbdiff работает как инструмент git diff: https://nbdime.readthedocs.io/en/latest/#git-integration-quickstart
    • nbmerge: трехстороннее слияние ноутбуков с автоматическим разрешением конфликтов
      • nbdime nbmerge работает как инструмент слияния git
    • nbdiff-web: показывает богатый рендеринг для ноутбуков.
    • nbmerge-web: предоставляет веб-инструмент для трехстороннего слияния для ноутбуков.
    • nbshow: представить один ноутбук в терминальном режиме

Ответ 6

  Обновление: теперь вы можете редактировать блокнот Jupyter файлы непосредственно в коде Visual Studio. Вы можете редактировать записная книжка или преобразованный файл Python.

Наконец-то я нашел продуктивный и простой способ заставить Jupyter и Git хорошо играть вместе. Я все еще на первых шагах, но уже думаю, что это намного лучше, чем все другие запутанные решения.

Visual Studio Code - это классный и открытый редактор исходного кода от Microsoft. Он имеет отличное расширение Python, которое теперь позволяет импортировать блокнот Jupyter в виде кода Python. Теперь вы также можете напрямую редактировать блокноты Jupyter.

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

В вашем файле python просто есть содержимое входных ячеек ноутбука. Вывод будет создан в разделенном окне. У вас есть чистый код в блокноте, он не меняется, пока вы просто его исполняете. Нет смешанного вывода с вашим кодом. Нет странного непонятного формата Json для анализа ваших различий.

Просто чистый код Python, где вы можете легко идентифицировать каждый отдельный diff.

Мне даже не нужно больше версии моих файлов .ipynb. Я могу вставить строку *.ipynb в .gitignore.

Нужно создать блокнот, чтобы опубликовать или поделиться с кем-то? Нет проблем, просто нажмите кнопку экспорта в интерактивном окне Python

Если вы редактируете записную книжку напрямую, там теперь значок Convert and save to a python script.

Вот снимок экрана ноутбука внутри кода Visual Studio:

Я использовал его всего один день, но, наконец, я могу с радостью использовать Jupyter с Git.

П.С.: Завершение кода VSCode намного лучше, чем у Jupyter.

Ответ 7

После нескольких лет удаления выводов в ноутбуках я попытался найти лучшее решение. Теперь я использую Jupytext, расширение для Jupyter Notebook и Jupyter Lab, которое я разработал.

Jupytext может конвертировать блокноты Jupyter в различные текстовые форматы (Scripts, Markdown и R Markdown). И наоборот. Он также предлагает вариант сопряжения записной книжки с одним из этих форматов и автоматической синхронизации двух представлений записной книжки (файл .ipynb и .md/.py/.R).

Позвольте мне объяснить, как Jupytext отвечает на поставленные выше вопросы:

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

Файл .md/.py/.R содержит только входные ячейки. Вы должны всегда отслеживать этот файл. Версии файла .ipynb, только если вы хотите отслеживать результаты.

предотвращает случайное принятие вывода, если я этого не хочу,

Добавить *.ipynb в .gitignore

позволяет сохранить вывод в локальной версии,

Выходы сохраняются в (локальном) файле .ipynb

позволяет мне видеть, когда у меня есть изменения во входах, используя мою систему контроля версий (то есть, если я только управляю версиями входов, но мой локальный файл имеет выходы, то я бы хотел видеть, изменились ли входы (требующий фиксации Использование команды управления версиями статуса всегда регистрирует разницу, поскольку локальный файл имеет выходные данные.)

Разница в файле .py/.R или .md - это то, что вы ищете

позволяет мне обновить мою рабочую записную книжку (которая содержит вывод) из обновленной чистой записной книжки. (Обновление)

Вытащите последнюю версию файла .py/.R или .md и обновите свой блокнот в Jupyter (Ctrl + R). Вы получите последние входные ячейки из текстового файла с соответствующими выходными данными из файла .ipynb. На ядро это не влияет, а это значит, что ваши локальные переменные сохраняются - вы можете продолжать работать там, где оставили его.

Что мне нравится в Jupytext, так это то, что ноутбук (в форме файла .py/.R или .md) можно редактировать в вашей любимой IDE. При таком подходе рефакторинг ноутбука становится легким. Когда вы закончите, вам просто нужно обновить блокнот в Jupyter.

Если вы хотите попробовать это: установите Jupytext с pip install jupytext и перезапустите ваш Jupyter Notebook или Lab editor. Откройте блокнот, для которого вы хотите управлять версиями, и соедините его с файлом Markdown (или сценарием), используя Jupytext Menu в блокноте Jupyter (или команды Jupytext в Jupyter Lab)., Сохраните свой блокнот, и вы получите два файла: оригинальный .ipynb плюс обещанное текстовое представление ноутбука, который идеально подходит для контроля версий!

Для тех, кто может быть заинтересован: Jupytext также доступен в командной строке command line.

Ответ 8

Как указано, --script устарел в 3.x. Этот подход можно использовать, применяя post-save-hook. В частности, добавьте следующее в ipython_notebook_config.py:

import os
from subprocess import check_call

def post_save(model, os_path, contents_manager):
    """post-save hook for converting notebooks to .py scripts"""
    if model['type'] != 'notebook':
        return # only do this for notebooks
    d, fname = os.path.split(os_path)
    check_call(['ipython', 'nbconvert', '--to', 'script', fname], cwd=d)

c.FileContentsManager.post_save_hook = post_save

Код взят из # 8009.

Ответ 9

Самые популярные ответы 2016 года - это непоследовательные хаки по сравнению с лучшим способом сделать это в 2019 году.

Существует несколько вариантов, лучший из которых ответ на вопрос - Jupytext.

Jupytext

Поймайте статью "Наука о данных" в Jupytext

Как это работает с контролем версий, вы помещаете файлы .py и .ipynb в систему контроля версий. Посмотрите на .py, если вам нужен ввод diff, посмотрите на .ipynb, если вы хотите последний обработанный вывод.

Примечательные упоминания: VS studio, nbconvert, nbdime, водород

Я думаю, что немного потрудившись, VS studio и/или водород (или аналогичный) станут доминирующими игроками в решении этого рабочего процесса.

Ответ 10

К сожалению, я не знаю много о Mercurial, но я могу дать вам возможное решение, которое работает с Git, в надежде, что вы сможете перевести мои команды Git в их эквиваленты Mercurial.

Для фона в Git команда add сохраняет изменения, внесенные в файл в промежуточную область. После того, как вы это сделаете, любые последующие изменения в файле игнорируются Git, если вы не сообщите об этом также для их создания. Следовательно, следующий script, который для каждого из данных файлов вырезает все outputs и prompt_number sections, разбивает разделяемый файл и восстанавливает оригинал:

ПРИМЕЧАНИЕ.. При запуске это сообщение об ошибке появляется как ImportError: No module named IPython.nbformat, затем используйте ipython для запуска script вместо python.

from IPython.nbformat import current
import io
from os import remove, rename
from shutil import copyfile
from subprocess import Popen
from sys import argv

for filename in argv[1:]:
    # Backup the current file
    backup_filename = filename + ".backup"
    copyfile(filename,backup_filename)

    try:
        # Read in the notebook
        with io.open(filename,'r',encoding='utf-8') as f:
            notebook = current.reads(f.read(),format="ipynb")

        # Strip out all of the output and prompt_number sections
        for worksheet in notebook["worksheets"]:
            for cell in worksheet["cells"]:
               cell.outputs = []
               if "prompt_number" in cell:
                    del cell["prompt_number"]

        # Write the stripped file
        with io.open(filename, 'w', encoding='utf-8') as f:
            current.write(notebook,f,format='ipynb')

        # Run git add to stage the non-output changes
        print("git add",filename)
        Popen(["git","add",filename]).wait()

    finally:
        # Restore the original file;  remove is needed in case
        # we are running in windows.
        remove(filename)
        rename(backup_filename,filename)

Как только script будет запущен в файлах, изменения которых вы хотите зафиксировать, просто запустите git commit.

Ответ 11

Я использую очень прагматичный подход; которые хорошо работают для нескольких ноутбуков, с нескольких сторон. И это даже позволяет мне "переносить" ноутбуки. Он работает как для Windows, так и для Unix/MacOS.
Аль думал, что это просто, решает проблемы выше...

Концепция

В принципе, не отслеживать .ipnyb файлы, только соответствующие .py файлы.
Запустив ноутбук-сервер с опцией --script, этот файл автоматически создается/сохраняется при сохранении записной книжки.

Те .py файлы содержат все входные данные; некод сохраняется в комментариях, равно как и границы ячеек. Этот файл можно прочитать/импортировать (и перетащить) в блокнот-сервер, чтобы (повторно) создать ноутбук. Только выход пропал; пока он не будет повторно запущен.

Лично я использую mercurial для отслеживания версий файлов .py; и используйте обычные (командные строки) команды для добавления, check-in (ect) для этого. Большинство других (D) VCS позволят это.

Его просто отслеживать историю; .py являются небольшими, текстовыми и простыми для разграничения. Время от времени нам нужен клон (только ветка, запустите второй ноутбук), или более старую версию (проверить и импортировать на ноутбук-сервер) и т.д.

Советы и рекомендации

• Добавить *.ipynb в '.hgignore', поэтому Mercurial знает, что он может игнорировать эти файлы.
• Создайте (bash) script, чтобы запустить сервер (с опцией --script) и выполните его версию
• Сохранение ноутбука сохраняет файл .py, но не проверяет его.
  • Это недостаток: можно забыть, что
  • Это функция: возможно сохранить записную книжку (и продолжить ее позже) без кластеризации истории репозитория.

Пожелания

• Было бы неплохо иметь кнопки для регистрации/добавления/etc в панели инструментов ноутбука
• Вы должны проверить на (пример) [email protected]+rev.py) Было бы очень полезно добавить это; и, возможно, я сделаю это один раз. До сих пор я просто делаю это вручную.

Ответ 12

Просто попадайтесь на "Jupytext", который выглядит как идеальное решение. Он генерирует файл .py из записной книжки, а затем синхронизирует оба файла. Вы можете управлять версиями, различать и объединять входные данные через файл .py без потери выходных данных. Когда вы открываете записную книжку, он использует .py для входных ячеек и .ipynb для вывода. И если вы хотите включить вывод в git, вы можете просто добавить ipynb.

https://github.com/mwouts/jupytext

Ответ 13

Поскольку существует множество стратегий и инструментов для управления версиями для ноутбуков, я попытался создать блок-схему, чтобы выбрать подходящую стратегию (создано в апреле 2019 года)

Ответ 14

Чтобы следить за отличным script от Pietro Battiston, если вы получите ошибку синтаксического анализа Unicode, например:

Traceback (most recent call last):
  File "/Users/kwisatz/bin/ipynb_output_filter.py", line 33, in <module>
write(json_in, sys.stdout, NO_CONVERT)
  File "/Users/kwisatz/anaconda/lib/python2.7/site-packages/IPython/nbformat/__init__.py", line 161, in write
fp.write(s)
UnicodeEncodeError: 'ascii' codec can't encode character u'\u2014' in position 11549: ordinal not in range(128)

Вы можете добавить в начале script:

reload(sys)
sys.setdefaultencoding('utf8')

Ответ 15

Я построил пакет python, который решает эту проблему.

https://github.com/brookisme/gitnb

Он предоставляет CLI с синтаксисом git -inspired для отслеживания/обновления/различий ноутбуков внутри вашего репозитория git.

Пример Heres

# add a notebook to be tracked
gitnb add SomeNotebook.ipynb

# check the changes before commiting
gitnb diff SomeNotebook.ipynb

# commit your changes (to your git repo)
gitnb commit -am "I fixed a bug"

Обратите внимание, что последний шаг, когда я использую "gitnb commit", выполняет ваш репозиторий git. Его по существу обертка для

# get the latest changes from your python notebooks
gitnb update

# commit your changes ** this time with the native git commit **
git commit -am "I fixed a bug"

Существует еще несколько методов и может быть сконфигурирован таким образом, чтобы он требовал более или менее ввода пользователем на каждом этапе, но это общая идея.

Ответ 16

После копания я наконец нашел этот относительно простой предварительный сбой в документах Jupyter. Он разделяет выходные данные ячейки. Вы должны вставить его в файл jupyter_notebook_config.py (см. Ниже инструкции).

def scrub_output_pre_save(model, **kwargs):
    """scrub output before saving notebooks"""
    # only run on notebooks
    if model['type'] != 'notebook':
        return
    # only run on nbformat v4
    if model['content']['nbformat'] != 4:
        return

    for cell in model['content']['cells']:
        if cell['cell_type'] != 'code':
            continue
        cell['outputs'] = []
        cell['execution_count'] = None
        # Added by binaryfunt:
        if 'collapsed' in cell['metadata']:
            cell['metadata'].pop('collapsed', 0)

c.FileContentsManager.pre_save_hook = scrub_output_pre_save

Из Ответ Rich Signell:

Если вы не знаете, в каком каталоге вы найдете свой файл jupyter_notebook_config.py, вы можете ввести jupyter --config-dir [в командную строку/терминал], и если вы не найдете там файл, вы можете создать его введите jupyter notebook --generate-config.

Ответ 17

Я делал то, что делал Альберт и Рич. Не делайте файлы с версией .ipynb(так как они могут содержать изображения, которые становятся беспорядочными). Вместо этого всегда выполняйте ipython notebook --script или помещайте c.FileNotebookManager.save_script = True в свой файл конфигурации, чтобы всегда сохранялся файл (версия версии) .py при сохранении вашего ноутбука.

Для восстановления ноутбуков (после проверки репо или переключения ветки) я помещаю script py_file_to_notebooks.py в каталог, где я сохраните мои ноутбуки.

Теперь, после проверки репо, просто запустите python py_file_to_notebooks.py, чтобы сгенерировать файлы ipynb. После переключения ветки вам может потребоваться запустить python py_file_to_notebooks.py -ov, чтобы перезаписать существующие файлы ipynb.

Просто, чтобы быть в безопасности, хорошо также добавить *.ipynb в ваш .gitignore файл.

Изменить: я больше не делаю этого, потому что (A) вам нужно регенерировать свои записные книжки из файлов py каждый раз, когда вы проверяете ветку, и (B) есть другие вещи, такие как уценка в ноутбуках, которые вы теряете. Вместо этого я вывожу вывод из ноутбуков с помощью фильтра git. Обсуждение того, как это сделать, здесь.

Ответ 18

Итак, это похоже на текущее лучшее решение, в соответствии с обсуждением здесь, чтобы сделать фильтр git автоматически отключенным вывод из файлов ipynb при фиксации.

Вот что я сделал, чтобы заставить его работать (скопированный из этого обсуждения):

Я немного изменил файл cfriedline nbstripout, чтобы дать информативную ошибку, когда вы не можете импортировать последний IPython: https://github.com/petered/plato/blob/fb2f4e252f50c79768920d0e47b870a8d799e92b/notebooks/config/strip_notebook_output И добавил его к моему репо, скажем, в ./relative/path/to/strip_notebook_output

Также добавлен файл .gitattributes в корень репо, содержащий:

*.ipynb filter=stripoutput

И создал < <22 > содержащий

git config filter.stripoutput.clean "$(git rev-parse --show-toplevel)/relative/path/to/strip_notebook_output" 
git config filter.stripoutput.smudge cat
git config filter.stripoutput.required true

И запустил source setup_git_filters.sh. Необычная $(git rev-parse...) вещь - найти локальный путь вашего репо на любой (Unix) машине.

Ответ 19

Это расширение Jupyter позволяет пользователям загружать ноутбуки Jupyter непосредственно на GitHub.

Пожалуйста, посмотрите здесь

https://github.com/sat28/githubcommit

Ответ 20

Как насчет идеи, обсуждаемой в посте ниже, где следует сохранять выходные данные записной книжки с аргументом, что ее генерация может занять много времени, и это удобно, поскольку GitHub теперь может отображать записные книжки. Для экспорта .py файла добавлены хуки автосохранения, используемые для diff файлов и .html для совместного использования с членами команды, которые не используют блокноты или git.

https://towardsdatascience.com/version-control-for-jupyter-notebook-3e6cef13392d