Importing an ipynb file from another ipynb file?

Interactive Python (ipython) is simply amazing, especially as you are piecing things together on the fly... and does it in such a way that it is easy to go back.

However, what seems to be interesting is the use-case of having multiple ipython notebooks (ipynb files). It apparently seems like a notebook is NOT supposed to have a relationship with other notebooks, which makes sense, except that I would love to import other ipynb files.

The only workaround I see is converting my *.ipynb files into *.py files, which then can be imported into my notebook. Having one file hold everything in a project is a bit weird, especially if I want to really push for code-reuse (isn't that a core tenet of python?).

Am I missing something? Is this not a supported use case of ipython notebooks? Is there another solution I can be using for this import of an ipynb file into another notebook? I'd love to continue to use ipynb, but it's really messing up my workflow right now :(

It is really simple in newer Jupyter:

%run MyOtherNotebook.ipynb

See here for details.

Official docs: %run IPython magic command

Install my helper library from the command prompt:

pip install import-ipynb

Import it from your notebook:

import import_ipynb

Now import your .ipynb notebook as if it was a .py file

import TheOtherNotebook

This python-ipynb module is just one file and it strictly adheres to the official howto on the jupyter site.

PS It also supports things like from A import foo, from A import * etc

PPS Works with subdirectories: import A.B

Run

!pip install ipynb

and then import the other notebook as

from ipynb.fs.full.<notebook_name> import *

or

from ipynb.fs.full.<notebook_name> import <function_name>

Make sure that all the notebooks are in the same directory.

Edit 1: You can see the official documentation here - https://ipynb.readthedocs.io/en/stable/

Also, if you would like to import only class & function definitions from a notebook (and not the top level statements), you can use ipynb.fs.defs instead of ipynb.fs.full. Full uppercase variable assignment will get evaluated as well.

Install ipynb from your command prompt

pip install import-ipynb

Import in your notebook file

import import_ipynb

Now use regular import command to import your file

import MyOtherNotebook

You can use import nbimporter then import notebookName

The above mentioned comments are very useful but they are a bit difficult to implement. Below steps you can try, I also tried it and it worked:

1. Download that file from your notebook in PY file format (You can find that option in File tab).
2. Now copy that downloaded file into the working directory of Jupyter Notebook
3. You are now ready to use it. Just import .PY File into the ipynb file

%run YourNotebookfile.ipynb is working fine;

if you want to import a specific module then just add the import command after the ipynb i.e YourNotebookfile.ipynb having def Add()

then you can just use it

%run YourNotebookfile.ipynb import Add

The issue is that a notebooks is not a plain python file. The steps to import the .ipynb file are outlined in the following: Importing notebook

I am pasting the code, so if you need it...you can just do a quick copy and paste. Notice that at the end I have the import primes statement. You'll have to change that of course. The name of my file is primes.ipynb. From this point on you can use the content inside that file as you would do regularly.

Wish there was a simpler method, but this is straight from the docs.
Note: I am using jupyter not ipython.

import io, os, sys, types
from IPython import get_ipython
from nbformat import current
from IPython.core.interactiveshell import InteractiveShell


def find_notebook(fullname, path=None):
	"""find a notebook, given its fully qualified name and an optional path

	This turns "foo.bar" into "foo/bar.ipynb"
	and tries turning "Foo_Bar" into "Foo Bar" if Foo_Bar
	does not exist.
	"""
	name = fullname.rsplit('.', 1)[-1]
	if not path:
		path = ['']
	for d in path:
		nb_path = os.path.join(d, name + ".ipynb")
		if os.path.isfile(nb_path):
			return nb_path
		# let import Notebook_Name find "Notebook Name.ipynb"
		nb_path = nb_path.replace("_", " ")
		if os.path.isfile(nb_path):
			return nb_path


class NotebookLoader(object):
	"""Module Loader for Jupyter Notebooks"""
	def __init__(self, path=None):
		self.shell = InteractiveShell.instance()
		self.path = path

	def load_module(self, fullname):
		"""import a notebook as a module"""
		path = find_notebook(fullname, self.path)

		print ("importing Jupyter notebook from %s" % path)

		# load the notebook object
		with io.open(path, 'r', encoding='utf-8') as f:
			nb = current.read(f, 'json')


		# create the module and add it to sys.modules
		# if name in sys.modules:
		#    return sys.modules[name]
		mod = types.ModuleType(fullname)
		mod.__file__ = path
		mod.__loader__ = self
		mod.__dict__['get_ipython'] = get_ipython
		sys.modules[fullname] = mod

		# extra work to ensure that magics that would affect the user_ns
		# actually affect the notebook module's ns
		save_user_ns = self.shell.user_ns
		self.shell.user_ns = mod.__dict__

		try:
		for cell in nb.worksheets[0].cells:
			if cell.cell_type == 'code' and cell.language == 'python':
				# transform the input to executable Python
				code = self.shell.input_transformer_manager.transform_cell(cell.input)
				# run the code in themodule
				exec(code, mod.__dict__)
		finally:
			self.shell.user_ns = save_user_ns
		return mod


class NotebookFinder(object):
	"""Module finder that locates Jupyter Notebooks"""
	def __init__(self):
		self.loaders = {}

	def find_module(self, fullname, path=None):
		nb_path = find_notebook(fullname, path)
		if not nb_path:
			return

		key = path
		if path:
			# lists aren't hashable
			key = os.path.sep.join(path)

		if key not in self.loaders:
			self.loaders[key] = NotebookLoader(path)
		return self.loaders[key]

sys.meta_path.append(NotebookFinder())

import primes

There is no problem at all using Jupyter with existing or new Python .py modules. With Jupyter running, simply fire up Spyder (or any editor of your choice) to build / modify your module class definitions in a .py file, and then just import the modules as needed into Jupyter.

One thing that makes this really seamless is using the autoreload magic extension. You can see documentation for autoreload here:

http://ipython.readthedocs.io/en/stable/config/extensions/autoreload.html

Here is the code to automatically reload the module any time it has been modified:

# autoreload sets up auto reloading of modified .py modules
import autoreload
%load_ext autoreload
%autoreload 2

Note that I tried the code mentioned in a prior reply to simulate loading .ipynb files as modules, and got it to work, but it chokes when you make changes to the .ipynb file. It looks like you need to restart the Jupyter development environment in order to reload the .ipynb 'module', which was not acceptable to me since I am making lots of changes to my code.

Please make sure that you also add a __init__.py file in the package where all your other .ipynb files are located.

This is in addition to the nbviewer link that minrk and syi provided above.

I also had some similar problem and then I wrote the solution as well as a link to my public google drive folder which has a working example :)

My Stackoverflow post with step by step experimentation and Solution:

https://stackoverflow.com/questions/44336087/jupyter-notebook-import-ipynb-file-and-access-its-method-in-other-ipynb-file

Hope this will help others as well. Thanks all!