Faites fonctionner Jupyter avec l'API REST pour extraire et enregistrer le code Python

Je voulais exécuter le code Python du notebook jupyter sur une autre machine, j'ai donc décidé de l'extraire et de l'enregistrer en utilisant l'API de jupyter.

environnement

Jupyter (docker image)
jupyter/scipy-notebook:19db0c85c56d

Examinez le jeton Jupyter

Puisqu'un jeton est nécessaire pour faire fonctionner le jupyter de l'extérieur, vérifiez d'abord le jeton.

Je l'ai entré lors du démarrage de jupyter pour la première fois (devrais-je?), Mais je pense que je l'ai généralement oublié, alors vérifiez le conteneur de jupyter dans l'ordre de recherche → affichage du journal → confirmation du jeton.

Trouver un conteneur jupyter Dans l'exemple ci-dessous, l'ID est «022298a2039a» et le nom du conteneur est «jupyter».

$ docker ps
CONTAINER ID     IMAGE                           COMMAND                  CREATED         STATUS       PORTS                    NAMES
022298a2039a     jupyter/scipy-notebook:latest   "tini -g -- start-no…"   11 days ago     Up 2 days    0.0.0.0:8888->8888/tcp   jupyter

Afficher le journal Affichez le journal en spécifiant l'ID ou le nom du conteneur.

#Pour l'ID de conteneur
$ docker logs 022298a2039a
#Pour le nom du conteneur
$ docker logs jupyter
# docker-Pour composer
$ docker-compose logs

Confirmation de jeton Il y a probablement un jeton vers la fin du journal. Étant donné que les journaux d'erreurs tels que l'API sont générés, les journaux seront diffusés si vous effectuez plusieurs essais et erreurs.
```
jupyter    |     Or copy and paste one of these URLs:
jupyter    |         http://022298a2039a:8888/?token=xxxxxxxxxxxxxxxxxxxxxxxxxxxx
jupyter    |      or http://127.0.0.1:8888/?token=xxxxxxxxxxxxxxxxxxxxxxxxxxxx
```

Accédez à l'API Jupyter de l'extérieur

État du bloc-notes

J'ai créé un cahier pour les tests. L'URL est ci-dessous. http://localhost:8888/notebooks/work/test1.ipynb

Environnement d'exécution du côté qui touche l'API

Étant donné que l'opération d'API est effectuée avec python, le package de requêtes est requis. Il n'est pas nécessaire que ce soit Docker car il ne met que des requêtes, mais je pense qu'il sera plus facile d'en faire un service plus tard, donc je vais le mettre dans un conteneur. Détails de l'environnement d'essai (Dockerfile) ci-dessous.

FROM python:3.6-buster
RUN pip install requests

Construire.

$ docker build -t jupyter-api .

Démarrez le conteneur. Vous n'avez pas besoin de monter (-v), mais montez le courant pour le moment pour récupérer le fichier créé.

$ docker run -it --net host -v $(pwd):/tmp jupyter-api bash

Essai d'API

Tout d'abord, vérifiez si l'API jupyter peut être utilisée.

import requests
url_api = 'http://localhost:8888/api'
response = requests.get(url_api)
print(response.status_code, response.text)  # 200 {"version": "6.0.3"}

Je peux accéder à l'API en toute sécurité, donc j'obtiens un notebook.

notebook_path = '/work/test1.ipynb'
url_file = url_api + '/contents' + notebook_path

token = 'xxxxxxxxxxxxxxxxx'   #Définir le jeton
headers =  {'Authorization': 'token ' + token}

response = requests.get(url_file, headers=headers)

Les informations du bloc-notes sont renvoyées au format json dans response.text. Ci-dessous, le résultat de l'exécution de print (response.text) est formaté pour l'affichage.

{
  "name": "test1.ipynb",
  "path": "work/test1.ipynb",
  "last_modified": "2020-03-07T21:08:58.897321Z",
  "created": "2020-03-07T21:08:57.594298Z",
  "content": {
    "cells": [
      {
        "cell_type": "code",
        "execution_count": 1,
        "metadata": {
            "trusted": true
        },
        "outputs": [
          {
            "data": {
              "text/plain": "array([0.83709745, 0.46685874, 0.94285637, 0.03938868, 0.79617107,\n       0.98784776, 0.27798577, 0.96118447, 0.5253161 , 0.0690074 ])"
            },
            "execution_count": 1,
            "metadata": {},
            "output_type": "execute_result"
          }
        ],
        "source": "import numpy as np\nnp.random.random(10)"
      }
    ],
    "metadata": {
      "kernelspec": {
        "display_name": "Python 3",
        "language": "python",
        "name": "python3"
      },
      "language_info": {
        "codemirror_mode": {
          "name": "ipython",
          "version": 3
        },
        "file_extension": ".py",
        "mimetype": "text/x-python",
        "name": "python",
        "nbconvert_exporter": "python",
        "pygments_lexer": "ipython3",
        "version": "3.7.4"
      }
    },
    "nbformat": 4,
    "nbformat_minor": 4
  },
  "format": "json",
  "mimetype": null,
  "size": 921,
  "writable": true,
  "type": "notebook"
}

Cette fois, je veux extraire la partie code du notebook, afin que je puisse extraire la source du bloc de content.cells.cell_type = 'code'. cell_type est cell_type = 'markdown' pour les blocs de démarque.

import json
json_src = json.loads(response.text)
src = [cell['source'] for cell in json_src['content']['cells'] if cell['cell_type'] == 'code']

Le code de chaque cellule est stocké dans src en tant qu'élément de tableau, et comme il n'y a qu'une seule cellule du code source cette fois, il s'agit d'un tableau d'un élément.

['import numpy as np\nnp.random.random(10)']

Sortie dans un fichier. Pour le moment, affichez-le avec une déclaration UTF8.

with open('/tmp/test1.py', 'w') as f:
    print("# -*- coding: utf-8 -*-", file=f)
    for block in src:
        print(block, file=f)

Vérifiez le fichier de sortie. Parfait.

# -*- coding: utf-8 -*-
import numpy as np
np.random.random(10)

Comme j'ai pu le sortir du portable en toute sécurité, il semble que je puisse le faire bouillir, le cuire ou l'exécuter.

Matériel de référence

Commande pour vérifier le jeton après le démarrage de jupyter avec docker J'ai mentionné comment vérifier le jeton.
stack overflow: Interact with Jupyter Notebooks via API J'ai évoqué la syntaxe.
Jupyter Notebook - Contents API
Voir ici pour la structure des données.
Jupyter Notebook Server API
J'ai vérifié l'API.