현재 IPython / Jupyter 노트북 이름을 얻으려면 어떻게 해야 합니까

현재 IPython / Jupyter 노트북 이름을 얻으려면 어떻게 해야 합니까

IPython 노트북을 실행할 때 현재 노트북 이름을 얻으려고 합니다. 나는 내가 공책의 맨 위에서 그것을 볼 수 있다는 것을 안다. 내가 어떤 것을 추구하고 있는지

currentNotebook = IPython.foo.bar.notebookname()

변수에 이름을 입력해야 합니다.

---

이미 언급했듯이, 아마도 당신은 이것을 할 수 없을 것이지만, 나는 방법을 찾았다. 하지만 그것은 불타는 해킹이기 때문에 이것에 전혀 의존하지 마세요:

import json
import os
import urllib2
import IPython
from IPython.lib import kernel
connection_file_path = kernel.get_connection_file()
connection_file = os.path.basename(connection_file_path)
kernel_id = connection_file.split('-', 1)[1].split('.')[0]

# Updated answer with semi-solutions for both IPython 2.x and IPython < 2.x
if IPython.version_info[0] < 2:
    ## Not sure if it's even possible to get the port for the
    ## notebook app; so just using the default...
    notebooks = json.load(urllib2.urlopen('http://127.0.0.1:8888/notebooks'))
    for nb in notebooks:
        if nb['kernel_id'] == kernel_id:
            print nb['name']
            break
else:
    sessions = json.load(urllib2.urlopen('http://127.0.0.1:8888/api/sessions'))
    for sess in sessions:
        if sess['kernel']['id'] == kernel_id:
            print sess['notebook']['name']
            break

적어도 간단한 테스트로 IPython 2.0에서 "작동"하는 솔루션을 포함하도록 답변을 업데이트했습니다. 같은 커널 등에 여러 개의 노트북이 연결되어 있다면 정답을 제시할 수 없을 것입니다.

---

나는 IPython 2.0에서 작동하는 다음이 있다. 나는 노트의 이름이 페이지의 태그에 속성의 값으로 저장되는 것을 관찰했다. 따라서 이 아이디어는 먼저 자바스크립트에 속성을 검색하도록 요청하는 것이다. 자바스크립트는 마법 덕분에 코드 셀에서 호출될 수 있다. 그런 다음 파이썬 변수를 설정하는 명령을 사용하여 파이썬 커널에 대한 호출을 통해 자바스크립트 변수에 액세스할 수 있다. 이 마지막 변수는 커널에서 알 수 있기 때문에 다른 셀에서도 액세스할 수 있습니다.

%%javascript
var kernel = IPython.notebook.kernel;
var body = document.body,  
    attribs = body.attributes;
var command = "theNotebook = " + "'"+attribs['data-notebook-name'].value+"'";
kernel.execute(command);

Python 코드 셀에서

print(theNotebook)

아웃[ ]: 이름을 가져오는 방법노트북.ipynb

이 솔루션의 결함은 노트북의 제목(이름)을 변경할 때 이 이름이 즉시 업데이트되지 않는 것처럼 보인다는 것입니다(아마도 캐시 종류가 있을 것입니다). 새 이름에 액세스하려면 노트북을 다시 로드해야 합니다.

곰곰이 생각해 보면, 더 효율적인 해결책은 태그 대신 노트북 이름의 입력 필드를 찾는 것이다. 소스를 살펴보면 이 필드는 ID가 "notebook_name"인 것 같습니다. 그런 다음 a로 이 값을 잡은 다음 위와 같은 접근법을 따르는 것이 가능하다. 코드는 여전히 자바스크립트 마법을 사용하면서 된다

%%javascript
var kernel = IPython.notebook.kernel;
var thename = window.document.getElementById("notebook_name").innerHTML;
var command = "theNotebook = " + "'"+thename+"'";
kernel.execute(command);

Then, from a ipython cell,

In [11]: print(theNotebook)
Out [11]: HowToGetTheNameOfTheNoteBookSolBis

Contrary to the first solution, modifications of notebook's name are updated immediately and there is no need to refresh the notebook.

---

On Jupyter 3.0 the following works. Here I'm showing the entire path on the Jupyter server, not just the notebook name:

To store the NOTEBOOK_FULL_PATH on the current notebook front end:

%%javascript
var nb = IPython.notebook;
var kernel = IPython.notebook.kernel;
var command = "NOTEBOOK_FULL_PATH = '" + nb.base_url + nb.notebook_path + "'";
kernel.execute(command);

To then display it:

print("NOTEBOOK_FULL_PATH:\n", NOTEBOOK_FULL_PATH)

Running the first Javascript cell produces no output. Running the second Python cell produces something like:

NOTEBOOK_FULL_PATH:
 /user/zeph/GetNotebookName.ipynb

---

adding to previous answers,

to get the notebook name run the following in a cell:

%%javascript
IPython.notebook.kernel.execute('nb_name = "' + IPython.notebook.notebook_name + '"')

this gets you the file name in nb_name

then to get the full path you may use the following in a separate cell:

import os
nb_full_path = os.path.join(os.getcwd(), nb_name)

---

It seems I cannot comment, so I have to post this as an answer.

The accepted solution by @iguananaut and the update by @mbdevpl appear not to be working with recent versions of the Notebook. I fixed it as shown below. I checked it on Python v3.6.1 + Notebook v5.0.0 and on Python v3.6.5 and Notebook v5.5.0.

import jupyterlab
if jupyterlab.__version__.split(".")[0] == "3":
    from jupyter_server import serverapp as app
    key_srv_directory = 'root_dir'
else : 
    from notebook import notebookapp as app
    key_srv_directory = 'notebook_dir'
import urllib
import json
import os
import ipykernel

def notebook_path(key_srv_directory, ):
    """Returns the absolute path of the Notebook or None if it cannot be determined
    NOTE: works only when the security is token-based or there is also no password
    """
    connection_file = os.path.basename(ipykernel.get_connection_file())
    kernel_id = connection_file.split('-', 1)[1].split('.')[0]

    for srv in app.list_running_servers():
        try:
            if srv['token']=='' and not srv['password']:  # No token and no password, ahem...
                req = urllib.request.urlopen(srv['url']+'api/sessions')
            else:
                req = urllib.request.urlopen(srv['url']+'api/sessions?token='+srv['token'])
            sessions = json.load(req)
            for sess in sessions:
                if sess['kernel']['id'] == kernel_id:
                    return os.path.join(srv[key_srv_directory],sess['notebook']['path'])
        except:
            pass  # There may be stale entries in the runtime directory 
    return None

As stated in the docstring, this works only when either there is no authentication or the authentication is token-based.

Note that, as also reported by others, the Javascript-based method does not seem to work when executing a "Run all cells" (but works when executing cells "manually"), which was a deal-breaker for me.

---

Assuming you have the Jupyter Notebook server's host, port, and authentication token, this should work for you. It's based off of this answer.

import os
import json
import posixpath
import subprocess
import urllib.request
import psutil

def get_notebook_path(host, port, token):
    process_id = os.getpid();
    notebooks = get_running_notebooks(host, port, token)
    for notebook in notebooks:
        if process_id in notebook['process_ids']:
            return notebook['path']

def get_running_notebooks(host, port, token):
    sessions_url = posixpath.join('http://%s:%d' % (host, port), 'api', 'sessions')
    sessions_url += f'?token={token}'
    response = urllib.request.urlopen(sessions_url).read()
    res = json.loads(response)
    notebooks = [{'kernel_id': notebook['kernel']['id'],
                  'path': notebook['notebook']['path'],
                  'process_ids': get_process_ids(notebook['kernel']['id'])} for notebook in res]
    return notebooks

def get_process_ids(name):
    child = subprocess.Popen(['pgrep', '-f', name], stdout=subprocess.PIPE, shell=False)
    response = child.communicate()[0]
    return [int(pid) for pid in response.split()]

Example usage:

get_notebook_path('127.0.0.1', 17004, '344eb91bee5742a8501cc8ee84043d0af07d42e7135bed90')

---

The ipyparams package can do this pretty easily.

import ipyparams
currentNotebook = ipyparams.notebook_name

---

Yet another hacky solution since my notebook server can change. Basically you print a random string, save it and then search for a file containing that string in the working directory. The while is needed because save_checkpoint is asynchronous.

from time import sleep
from IPython.display import display, Javascript
import subprocess
import os
import uuid

def get_notebook_path_and_save():
    magic = str(uuid.uuid1()).replace('-', '')
    print(magic)
    # saves it (ctrl+S)
    display(Javascript('IPython.notebook.save_checkpoint();'))
    nb_name = None
    while nb_name is None:
        try:
            sleep(0.1)
            nb_name = subprocess.check_output(f'grep -l {magic} *.ipynb', shell=True).decode().strip()
        except:
            pass
    return os.path.join(os.getcwd(), nb_name)

---

All Json based solutions fail if we execute more than one cell at a time because the result will not be ready until after the end of the execution (its not a matter of using sleep or waiting any time, check it yourself but remember to restart kernel and run all every test)

Based on previous solutions, this avoids using the %% magic in case you need to put it in the middle of some other code:

from IPython.display import display, Javascript

# can have comments here :)
js_cmd = 'IPython.notebook.kernel.execute(\'nb_name = "\' + IPython.notebook.notebook_name + \'"\')'
display(Javascript(js_cmd))

For python 3, the following based on the answer by @Iguananaut and updated for latest python and possibly multiple servers will work:

import os
import json
try:
    from urllib2 import urlopen
except:
    from urllib.request import urlopen
import ipykernel

connection_file_path = ipykernel.get_connection_file()
connection_file = os.path.basename(connection_file_path)
kernel_id = connection_file.split('-', 1)[1].split('.')[0]    
    
running_servers = !jupyter notebook list
running_servers = [s.split('::')[0].strip() for s in running_servers[1:]]
nb_name = '???'
for serv in running_servers:
    uri_parts = serv.split('?')
    uri_parts[0] += 'api/sessions'
    sessions = json.load(urlopen('?'.join(uri_parts)))
    for sess in sessions:
        if sess['kernel']['id'] == kernel_id:
            nb_name = os.path.basename(sess['notebook']['path'])
            break
    if nb_name != '???':
        break
print (f'[{nb_name}]')
    

---

To realize why you can't get notebook name using these JS-based solutions, run this code and notice the delay it takes for the message box to appear after python has finished execution of the cell / entire notebook:

%%javascript

function sayHello() {
    alert('Hello world!');
}

setTimeout(sayHello, 1000);

• More info

Javascript calls are async and hence not guaranteed to complete before python starts running another cell containing the code expecting this notebook name variable to be already created... resulting in NameError when trying to access non-existing variables that should contain notebook name.

I suspect some upvotes on this page became locked before voters could discover that all %%javascript-based solutions ultimately don't work... when the producer and consumer notebook cells are executed together (or in a quick succession).

---

There is no real way yet to do this in Jupyterlab. But there is an official way that's now under active discussion/development as of August 2021:

https://github.com/jupyter/jupyter_client/pull/656

In the meantime, hitting the api/sessions REST endpoint of jupyter_server seems like the best bet. Here's a cleaned-up version of that approach:

from jupyter_server import serverapp
from jupyter_server.utils import url_path_join
from pathlib import Path
import re
import requests

kernelIdRegex = re.compile(r"(?<=kernel-)[\w\d\-]+(?=\.json)")

def getNotebookPath():
    kernelId = kernelIdRegex.search(get_ipython().config["IPKernelApp"]["connection_file"])[0]
    
    for jupServ in serverapp.list_running_servers():
        for session in requests.get(url_path_join(jupServ["url"], "api/sessions"), params={"token": jupServ["token"]}).json():
            if kernelId == session["kernel"]["id"]:
                return Path(jupServ["root_dir"]) / session["notebook"]['path']

Tested working with

python==3.9
jupyter_server==1.8.0
jupyterlab==4.0.0a7

---

Modifying @jfb method, gives the function below which worked fine on ipykernel-5.3.4.

def getNotebookName():
    display(Javascript('IPython.notebook.kernel.execute("NotebookName = " + "\'"+window.document.getElementById("notebook_name").innerHTML+"\'");'))
    try:
        _ = type(NotebookName)
        return NotebookName
    except:
        return None

Note that the display javascript will take some time to reach the browser, and it will take some time to execute the JS and get back to the kernel. I know it may sound stupid, but it's better to run the function in two cells, like this:

nb_name = getNotebookName()

and in the following cell:

for i in range(10):
    nb_name = getNotebookName()
    if nb_name is not None:
        break

However, if you don't need to define a function, the wise method is to run display(Javascript(..)) in one cell, and check the notebook name in another cell. In this way, the browser has enough time to execute the code and return the notebook name.

If you don't mind to use a library, the most robust way is:

import ipynbname
nb_name = ipynbname.name()

---

If you are using Visual Studio Code:

import IPython ; IPython.extract_module_locals()[1]['__vsc_ipynb_file__']

---

just use ipynbname , which is practical

import ipynbname
nb_fname = ipynbname.name()
nb_path = ipynbname.path()
print(f"{nb_fname=}")
print(f"{nb_path=}")

I found this in https://stackoverflow.com/a/65907473/15497427

---

Nowadays this was implemented as a feature in IPython, there is a built-in "vsc_ipynb_file" variable.

This is the fix - https://github.com/microsoft/vscode-jupyter/pull/8531