À l'aide de IPython cahiers sous contrôle de version

Nous avons un projet de collaboration où le produit est Jupyter les ordinateurs Portables, et nous avons une approche pour les six derniers mois, c'est génial de travailler: nous activer l'enregistrement de la .py automatiquement les fichiers et le suivi des .ipynb fichiers et les .py fichiers.

De cette façon, si quelqu'un veut voir/télécharger le dernier bloc-notes, ils peuvent le faire via github ou nbviewer, et si quelqu'un veut voir la façon dont l'ordinateur portable code a changé, ils suffit de regarder les modifications apportées à la .py fichiers.

Pour Jupyter cahier des serveurs, cela peut être fait en ajoutant les lignes

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

à la jupyter_notebook_config.py fichier et le redémarrage de l'ordinateur serveur.

Si vous ne savez pas dans quel répertoire pour trouver votre jupyter_notebook_config.py fichier, vous pouvez taper jupyter --config-dir, et si vous ne trouvez pas le fichier, vous pouvez le créer en tapant jupyter notebook --generate-config.

Pour Ipython 3 cahier des serveurs, cela peut être fait en ajoutant les lignes

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

à la ipython_notebook_config.py fichier et le redémarrage de l'ordinateur serveur. Ces lignes sont d'une github questions réponse @minrk fourni et @dror les inclut dans sa réponse ainsi.

Pour Ipython 2 cahier des serveurs, ce qui peut être accompli par le démarrage du serveur à l'aide de:

ipython notebook --script

ou par l'ajout de la ligne

c.FileNotebookManager.save_script = True

à la ipython_notebook_config.py fichier et le redémarrage de l'ordinateur serveur.

Si vous ne savez pas dans quel répertoire pour trouver votre ipython_notebook_config.py fichier, vous pouvez taper ipython locate profile default, et si vous ne trouvez pas le fichier, vous pouvez le créer en tapant ipython profile create.

Voici notre projet sur github qui est de l'utilisation de cette approche: et voici un github exemple d'explorer les changements récents à un ordinateur portable.

Nous avons été très heureux avec cela.

Ici est une nouvelle solution de Cyrille Rossant pour IPython 3.0, qui persiste à démarque plutôt que des fichiers basé sur json ipymd fichiers:

https://github.com/rossant/ipymd

Comme l'a souligné, la --script est obsolète dans 3.x. Cette approche peut être utilisée par l'application d'un post-enregistrement-crochet. En particulier, ajoutez ce qui suit à 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

Le code est pris de #8009.

Malheureusement, je ne sais pas beaucoup sur la Mercurial, mais je peux vous donner une solution qui fonctionne avec Git, dans l'espoir que vous pourriez être en mesure de traduire mes commandes Git dans leurs Mercurial équivalents.

Pour le fond, dans Git le add commande stocke les modifications qui ont été apportées à un fichier dans une zone de transit. Une fois que vous avez fait cela, toute modification ultérieure du fichier sont ignorés par Git sauf si vous lui dites que pour leur bien. Par conséquent, le script suivant, qui, pour chacun des fichiers, des bandes de toutes les outputs et prompt_number sections, les étapes, les dépouillé de fichier, puis de restaurer l'original:

REMARQUE: Si l'exécution de cette, vous reçoit un message d'erreur comme ImportError: No module named IPython.nbformat, puis utilisez ipython pour exécuter le script au lieu de 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)

Une fois que le script a été exécuté sur les fichiers dont les modifications que vous avez voulu commettre, il suffit d'exécuter git commit.

Venez à nous "jupytext" qui ressemble à une solution parfaite. Elle génère .py fichier de l'ordinateur portable et de garde, puis en synchronisation. Vous pouvez le contrôle de version, de comparaison et de fusion entrées via la .py fichier sans perdre les sorties. Lorsque vous ouvrez le bloc-notes il utilise le .py pour les cellules d'entrée et de la .ipynb pour la sortie. Et si vous souhaitez inclure la sortie dans git, alors vous pouvez simplement ajouter le ipynb.

https://github.com/mwouts/jupytext

De suivi sur l'excellent script de Pietro Battiston, si vous obtenez une Unicode erreur d'analyse comme ceci:

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)

Vous pouvez ajouter au début du script:

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

Après creuser autour, j'ai enfin trouvé cette relativement simple pré-enregistrer crochet sur le Jupyter docs. Il supprime la cellule de données de sortie. Vous devez le coller dans le jupyter_notebook_config.py fichier (voir ci-dessous pour les instructions).

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

De Riche Signell réponse:

Si vous ne savez pas dans quel répertoire pour trouver votre jupyter_notebook_config.py fichier, vous pouvez taper jupyter --config-dir [dans l'invite de commande/terminal], et si vous ne trouvez pas le fichier, vous pouvez le créer en tapant jupyter notebook --generate-config.

Après quelques années de retrait de sorties dans des cahiers, j'ai essayé de trouver une meilleure solution. Je vais maintenant utiliser Jupytext, une extension pour les deux Jupyter Portable et Jupyter Laboratoire que j'ai conçu.

Jupytext pouvez convertir Jupyter cahiers de divers formats texte (Scripts, Markdown et R Markdown). Et à l'inverse. Il offre également la possibilité de paire un ordinateur portable à l'un de ces formats, et de synchroniser automatiquement les deux représentations de l'ordinateur portable (un .ipynb et un .md/.py/.R fichier).

Laissez-moi vous expliquer comment Jupytext réponses aux questions ci-dessus:

me permet de choisir entre inclusion ou d'exclusion de sortie,

La .md/.py/.R fichier contient uniquement les cellules d'entrée. Vous devez toujours suivre ce fichier. La Version la .ipynb fichier seulement si vous voulez suivre les sorties.

m'empêche de me accidentellement commettre de sortie si je ne le veux pas,

Ajouter *.ipynb à .gitignore

me permet de garder de sortie dans ma version locale,

Sorties sont conservés dans l' (local) .ipynb fichier

me permet de voir quand j'ai des modifications dans les entrées à l'aide de mon système de contrôle de version (c'est à dire si je n'ai que la version de contrôler les entrées, mais mon fichier local sorties, alors je voudrais être en mesure de voir si les entrées ont changé (nécessitant une validation). À l'aide de la version de l'état de contrôle de commande enregistrez toujours une différence depuis le fichier local a sorties.)

La diff sur le .py/.R ou .md fichier est ce que vous êtes à la recherche pour

me permet de mettre à jour mon ordinateur portable (qui contient la sortie) à partir d'une mise à jour propre ordinateur portable. (mise à jour)

Tirer la dernière révision de la .py/.R ou .md fichier et l'actualisation de votre ordinateur portable dans Jupyter (Ctrl+R). Vous trouverez la dernière entrée des cellules à partir du fichier texte, avec des sorties de la .ipynb fichier. Le noyau n'est pas affecté, ce qui signifie que vos variables locales sont préservées, vous pouvez toujours vous travaillez où vous l'avez laissé.

Ce que j'aime avec Jupytext est que l'ordinateur portable (sous la forme d'un .py/.R ou .md fichier) peut être modifié dans votre IDE favori. Avec cette approche, refactoring un portable devient facile. Une fois que vous avez terminé, vous avez juste besoin de rafraîchissement de l'ordinateur portable dans Jupyter.

Si vous voulez faire un essai: installer Jupytext avec pip install jupytext et redémarrez votre Jupyter ordinateur Portable ou un Laboratoire de l'éditeur. Ouvrez le bloc-notes que vous voulez de contrôle de version, et paire il à un Abattement de fichier (ou un Script) à l'aide de la Jupytext Menu dans Jupyter ordinateur portable (ou le Jupytext commandes dans Jupyter de Laboratoire). Enregistrer votre ordinateur portable, et vous obtiendrez deux fichiers: l'original .ipynb, en plus de la promesse de la représentation de texte de l'ordinateur portable, qui est un ajustement parfait pour le contrôle de version!

Pour ceux qui pourraient être intéressés: Jupytext est également disponible sur le ligne de commande.

Ok, donc il semble que la meilleure solution actuelle, comme par une discussion ici, est de faire un git filtre automatiquement la sortie de la bande de ipynb fichiers sur validation.

Voici ce que j'ai fait pour le faire fonctionner (copié à partir de cette discussion):

J'ai modifié cfriedline de nbstripout fichier légèrement pour donner une information d'erreur lorsque vous ne pouvez pas importer les dernières IPython:
https://github.com/petered/plato/blob/fb2f4e252f50c79768920d0e47b870a8d799e92b/notebooks/config/strip_notebook_output
Et de l'ajouter à mon repo, permet de dire que dans ./relative/path/to/strip_notebook_output

Également ajouté le fichier .gitattributes fichier à la racine de l'opération, contenant:

*.ipynb filter=stripoutput

Et créé un setup_git_filters.sh contenant

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

Et a couru source setup_git_filters.sh. La fantaisie $(git rev-parse...), c'est de trouver le chemin d'accès local de votre repo sur tout (Unix) de la machine.

Comment parler de l'idée discuté dans le post ci-dessous, où la sortie de l'ordinateur portable doit être maintenue, avec l'argument qu'il pourrait prendre un certain temps de génération, et il est pratique depuis GitHub peut désormais rendre des ordinateurs portables. Il y a auto-save crochets ajoutée pour l'exportation .py fichier, utilisé pour les diffs et .html pour les partager avec les membres de l'équipe qui n'utilisent pas les ordinateurs portables ou git.

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