I am creating virtual environments in Python using virtualenv, with the command
virtualenv env_name and activating in the Linux terminal using source env_name/bin/activate.
But the virtual environment I created is not automatically visible in the jupyter notebook kernels. What should I do to make these environments access through Jupyter notebook?
The answer is quite trivial only.
We just need to add one more line in command for adding the kernel into the python. Say, I'm creating a new environment av
creating environment
virtualenv av
adding the kernel to ipython
python3 -m ipykernel install --user --name=av
This will give an output
Installed kernelspec av in /Users/sreekiran/Library/Jupyter/kernels/av
And voila!
I got the solution thanks to this blog.
Typically one runs jupyter notebook or jupyter-notebook or ipython notebook in a terminal to
start a Jupyter notebook webserver locally (and open the URL in the browser). When using conda
and conda environments, what is the best way to run a Jupyter notebook which allows to
import Python modules installed in the conda environment?
As it seems, this is not quite straight forward and many
users have similar troubles.
Most common error message seems to be: after installing a package XYZ in a conda environment
my-env one can run import XYZ in a python console started in my-env, but running the same
code in the Jupyter notebook will lead to an ImportError.
This question has been asked many times, but there is no good place to answer it, most Q&A's and
Github tickets are quite messy so let's start a new Q&A here.
Disclaimer: ATM tested only in Ubuntu and Windows (see comments to this answer).
Jupyter runs the user's code in a separate process called kernel. The kernel can be a different Python installation (in a different conda environment or virtualenv or Python 2 instead of Python 3) or even an interpreter for a different language (e.g. Julia or R). Kernels are configured by specifying the interpreter and a name and some other parameters (see Jupyter documentation) and configuration can be stored system-wide, for the active environment (or virtualenv) or per user. If nb_conda_kernels is used, additional to statically configured kernels, a separate kernel for each conda environment with ipykernel installed will be available in Jupyter notebooks.
In short, there are three options how to use a conda environment and Jupyter:
Option 1: Run Jupyter server and kernel inside the conda environment
Do something like:
conda create -n my-conda-env # creates new virtual env
conda activate my-conda-env # activate environment in terminal
conda install jupyter # install jupyter + notebook
jupyter notebook # start server + kernel inside my-conda-env
Jupyter will be completely installed in the conda environment. Different versions of Jupyter can be used
for different conda environments, but this option might be a bit of overkill. It is enough to
include the kernel in the environment, which is the component wrapping Python which runs the code.
The rest of Jupyter notebook can be considered as editor or viewer and it is not necessary to
install this separately for every environment and include it in every env.yml file. Therefore one
of the next two options might be preferable, but this one is the simplest one and definitely fine.
Option 2: Create special kernel for the conda environment
Do something like:
conda create -n my-conda-env # creates new virtual env
conda activate my-conda-env # activate environment in terminal
conda install ipykernel # install Python kernel in new conda env
ipython kernel install --user --name=my-conda-env-kernel # configure Jupyter to use Python kernel
Then run jupyter from the system installation or a different conda environment:
conda deactivate # this step can be omitted by using a different terminal window than before
conda install jupyter # optional, might be installed already in system e.g. by 'apt install jupyter' on debian-based systems
jupyter notebook # run jupyter from system
Name of the kernel and the conda environment are independent from each other, but it might make sense to use a similar name.
Only the Python kernel will be run inside the conda environment, Jupyter from system or a different conda environment will be used - it is not installed in the conda environment. By calling ipython kernel install the jupyter is configured to use the conda environment as kernel, see Jupyter documentation and IPython documentation for more information. In most Linux installations this configuration is a *.json file in ~/.local/share/jupyter/kernels/my-conda-env-kernel/kernel.json:
{
"argv": [
"/opt/miniconda3/envs/my-conda-env/bin/python",
"-m",
"ipykernel_launcher",
"-f",
"{connection_file}"
],
"display_name": "my-conda-env-kernel",
"language": "python"
}
Option 3: Use nb_conda_kernels to use a kernel in the conda environment
When the package nb_conda_kernels is installed, a separate kernel is available automatically for each
conda environment containing the conda package ipykernel or a different kernel (R, Julia, ...).
conda activate my-conda-env # this is the environment for your project and code
conda install ipykernel
conda deactivate
conda activate base # could be also some other environment
conda install nb_conda_kernels
jupyter notebook
You should be able to choose the Kernel Python [conda env:my-conda-env]. Note that nb_conda_kernels seems to be available only via conda and not via pip or other package managers like apt.
Troubleshooting
Using Linux/Mac the command which on the command line will tell you which jupyter is used, if you
are using option 1 (running Jupyter from inside the conda environment), it should be an executable
from your conda environment:
$ which jupyter
/opt/miniconda3/envs/my-conda-env/bin/jupyter
$ which jupyter-notebook # this might be different than 'which jupyter'! (see below)
/opt/miniconda3/envs/my-conda-env/bin/jupyter-notebook
Inside the notebook you should see that Python uses Python paths from the conda environment:
[1] !which python
/opt/miniconda3/envs/my-conda-env/bin/python
[2] import sys; sys.executable
'/opt/miniconda3/envs/my-conda-env/bin/python'
['/home/my_user',
'/opt/miniconda3/envs/my-conda-env/lib/python37.zip',
'/opt/miniconda3/envs/my-conda-env/lib/python3.7',
'/opt/miniconda3/envs/my-conda-env/lib/python3.7/lib-dynload',
'',
'/opt/miniconda3/envs/my-conda-env/lib/python3.7/site-packages',
'/opt/miniconda3/envs/my-conda-env/lib/python3.7/site-packages/IPython/extensions',
'/home/my_user/.ipython']
Jupyter provides the command jupyter-troubleshoot or in a Jupyter notebook:
!jupyter-troubleshoot
This will print a lot of helpful information about including the outputs mentioned above as well as installed libraries and others. When
asking for help regarding Jupyter installations questions, it might be good idea to provide this information in bug reports or questions.
To list all configured Jupyter kernels run:
jupyter kernelspec list
Common errors and traps
Jupyter notebook not installed in conda environment
Note: symptoms are not unique to the issue described here.
Symptoms: ImportError in Jupyter notebooks for modules installed in the conda environment (but
not installed system wide), but no error when importing in a Python terminal
Explaination: You tried to run jupyter notebook from inside your conda environment
(option 1, see above), there is no configuration for a kernel for this conda environment (this
would be option 2) and nb_conda_kernels is not installed (option 3), but jupyter notebook is not (fully)
installed in the conda environment, even if which jupyter might make you believe it was.
In GNU/Linux you can type which jupyter to check which executable of Jupyter is run.
This means that system's Jupyter is used, probably because Jupyter is not installed:
(my-conda-env) $ which jupyter-notebook
/usr/bin/jupyter
If the path points to a file in your conda environment, Jupyter is run from inside Jupyter:
(my-conda-env) $ which jupyter-notebook
/opt/miniconda3/envs/my-conda-env/bin/jupyter-notebook
Note that when the conda package ipykernel is installed, an executable jupyter is shipped, but
no executable jupyter-notebook. This means that which jupyter will return a path to the conda
environment but jupyter notebook will start system's jupyter-nootebook (see also here):
$ conda create -n my-conda-env
$ conda activate my-conda-env
$ conda install ipykernel
$ which jupyter # this looks good, but is misleading!
/opt/miniconda3/envs/my-conda-env/bin/jupyter
$ which jupyter-notebook # jupyter simply runs jupyter-notebook from system...
/usr/bin/jupyter-notebook
This happens because jupyter notebook searches for jupyter-notebook, finds
/usr/bin/jupyter-notebook and
calls it
starting a new Python process. The shebang in /usr/bin/jupyter-notebook is #!/usr/bin/python3
and not a dynamic
#!/usr/bin/env python.
Therefore Python manages to break out of the conda environment. I guess jupyter could call
python /usr/bin/jupyter-notebook instead to overrule the shebang, but mixing
system's bin files and the environment's python path can't work well anyway.
Solution: Install jupyter notebook inside the conda environment:
conda activate my-conda-env
conda install jupyter
jupyter notebook
Wrong kernel configuration: Kernel is configured to use system Python
Note: symptoms are not unique to the issue described here.
Symptoms: ImportError in Jupyter notebooks for modules installed in the conda environment (but
not installed system wide), but no error when importing in a Python terminal
Explanation: Typically the system provides a kernel called python3 (display name "Python 3")
configured to use /usr/bin/python3, see e.g. /usr/share/jupyter/kernels/python3/kernel.json.
This is usually overridden by a kernel in the conda environment, which points to the environments
python binary /opt/miniconda3/envs/my-conda-env/bin/python. Both are generated by the package
ipykernel (see here
and here).
A user kernel specification in ~/.local/share/jupyter/kernels/python3/kernel.json might override
the system-wide and environment kernel. If the environment kernel is missing or the user kernel
points to a python installation outside the environment option 1 (installation of jupyter in the
environment) will fail.
For occurrences and discussions of this problem and variants see here,
here,
here
and also here,
here and
here.
Solution: Use jupyter kernelspec list to list the location active kernel locations.
$ conda activate my-conda-env
$ jupyter kernelspec list
Available kernels:
python3 /opt/miniconda3/envs/my-conda-env/share/jupyter/kernels/python3
If the kernel in the environment is missing, you can try creating it manually using
ipython kernel install --sys-prefix in the activated environment, but it is probably better to
check your installation, because conda install ipykernel should have created the environment
(maybe try re-crate the environment and re-install all packages?).
If a user kernel specification is blocking the environment kernel specification, you can either
remove it or use a relative python path which will use $PATH to figure out which python to use.
So something like this, should be totally fine:
$ cat ~/.local/share/jupyter/kernels/python3/kernel.json
{
"argv": [
"python",
"-m",
"ipykernel_launcher",
"-f",
"{connection_file}"
],
"display_name": "Python 3",
"language": "python"
}
Correct conda environment not activated
Symptoms: ImportError for modules installed in the conda environment (but not installed system
wide) in Jupyter notebooks and Python terminals
Explanation: Each terminal has a set of environment variables, which are lost when the terminal
is closed. In order to use a conda environment certain environment variables need to be set, which
is done by activating it using conda activate my-conda-env. If you attempted to run Jupyter
notebook from inside the conda environment (option 1), but did not activate the conda environment
before running it, it might run the system's jupyter.
Solution: Activate conda environment before running Jupyter.
conda activate my-conda-env
jupyter notebook
Broken kernel configuration
Symptoms: Strange things happening. Maybe similar symptoms as above, e.g. ImportError
Explanation: If you attempted to use option 2, i.e. running Jupyter from system and the Jupyter
kernel inside the conda environment by using an explicit configuration for the kernel, but it does
not behave as you expect, the configuration might be corrupted in some way.
Solution: Check configuration in ~/.local/share/jupyter/kernels/my-kernel-name/kernel.json
and fix mistakes manually or remove the entire directory and re-create it using the command
provided above for option 2. If you can't find the kernel configuration there run
jupyter kernelspec list.
Python 2 vs 3
Symptoms: ImportError due to wrong Python version of the Jupyter kernel or other problems
with Python 2/3
Explanation: The kernel configuration can have all sorts of confusing and misleading effects.
For example the default Python 3 kernel configuration will allow me to launch a Jupyter notebook
running on Python 2:
conda create -n my-conda-env
conda activate my-conda-env
conda install python=2
conda install jupyter
jupyter notebook
The default Python 3 kernel:
$ cat ~/.local/share/jupyter/kernels/python3/kernel.json
{
"argv": [
"python",
"-m",
"ipykernel_launcher",
"-f",
"{connection_file}"
],
"display_name": "Python 3",
"language": "python"
}
After creating a new Jupyter Notebook with the Python 3 kernel, Python 2 from the conda
environment will be used even if "Python 3" is displayed by Jupyter.
Solution: Don't use Python 2 ;-)
The following command can also be used as a one liner to create your Conda environment running the latest version of Python and the latest version of Jupyter Notebooks,
conda create -n <env-name> python jupyter
If you want to install specific versions of Python or Jupyter, you can do,
conda create -n <env-name> python=<version> jupyter=<version>
For instance,
conda create -n <env-name> python=3.10.4 jupyter=1.0.0
If there are other packages that you want to use in this environment with your notebooks you can do the following,
conda create -n <env-name> python jupyter <another-package> <another-package> ...
For instance,
conda create -n <env-name> python jupyter scikit-learn
Note that similar to before, these commands will install the latest versions of Python and the relevant packages. If you want specific versions, you can use the =<version> syntax.
Also, you can still install any of the packages that you need using either pip install or conda install once the environment has been created.
After you have created your environment (using any of the methods given above), you can simply run the following commands to activate your environment and run Jupyter Notebooks,
conda activate <env-name>
jupyter notebook
Following worked for me :
Activate the environment that you want to use : conda activate
<env_name>
pip install ipykernel (if you don't already have it)
python -m ipykernel install --user --name=<env_name>
I'm not able to find a package from my notebook when I have installed it via pip / conda in my terminal.
For example, I did pip install trading-calendars and conda install trading-calendars in terminal but from trading_calendars import get_calendar in Jupyter notebook throws a ModuleNotFoundError with the message No module named 'trading_calendars'.
Is it possible that Jupyter takes time to refresh? If this keeps happening despite restarting Jupyter notebook, what should I do?
Duplicates:
How to list imported modules?
Package for listing version of packages used in a Jupyter notebook
Possible solution:
sys.path different in Jupyter and Python - how to import own modules in Jupyter?
This can be pretty confusing with Jupyter. It's very important to realize that your Jupyter client can connect to different "kernels" which equates to various python environments you might have installed. That is, you can start the Jupyter server with one python environment, and be executing your notebook's cells from another.
You need to make sure that you have the libraries installed to the environment that your kernel is using.
You will need to generate a kernelspec for your environment if you haven't already.
You can create a kernelspec using ipykernel. Here's an example of me doing it with conda.
$ conda activate test
$ conda install ipykernel
$ python -m ipykernel install --user --name test \
--display-name "Python (test)"
You can view your kernelspecs with this command
{~/path/to/project} (master *$)$ jupyter kernelspec list
Available kernels:
django_extensions /Users/nicholasbrady/Library/Jupyter/kernels/django_extensions
python3 /Users/nicholasbrady/anaconda3/share/jupyter/kernels/python3
python2 /usr/local/share/jupyter/kernels/python2
When a conda environment is activated in a shell window, the environment is only active in that window (i.e. not persistent). So when I navigate to the project location in another window, the "root" virtual environment is active.
Am I missing something or is this the intended behaviour?
How to give tools such as Jupyter Notebook access to the created environment?
Register a (python) notebook kernel:
Let's suppose you have created a conda environment named jupyter-env35 with conda create -n jupyter-env35 python=3.5 and now want to use it in jupyter.
Installing and registering a python kernel in the environment will make it available over the graphical notebook interface.
To do so, first install the ipython kernel:
conda install -n jupyter-env35 ipykernel
Then activate the environment and register the kernel:
source activate jupyter-env35
ipython kernel install --user --name jupyter-env35
When you now fire up juypter, it will show jupyter-env35 as a kernel in the list of available kernels. If you select it, all packages installed into juypter-env35 will be available.
Unregister a notebook kernel:
If you want delete the kernel from the notebook interface, jupyter --data-dir, will print out jupyter's data directory.
Navigate to the printed folder, find the subfolder kernels and delete the folder with the name of your kernel (here jupyter-env35). After that the kernel will not show up in jupyter anymore.
I have installed the latest version of Anaconda on my Ubuntu Linux virtual machine.
I successfully launched Jupyter in my browser using the following command : ipython notebook .
But when I want to create a new notebook, I have to choose between Python [conda root] and Python [default].
So, what are the differences between them? Which one to choose to create a new Notebook?
(I want to use Jupyter to work with Apache Spark)
Thank you.
// Update 22/10/2016
I created a new Environment python2 using : conda create -n python2 python=2.7 anaconda and I activate this new one : source activate python2.
When I list all environments : $ conda info --envs, I see these two lines :
python2 * /home/opentuto/anaconda2/envs/python2
root /home/opentuto/anaconda2
Now, my notebook, look like this :
Any solution!!?
Python [conda root] and Python [default].
What you are seeing are notebook kernels that you can use to create notebooks. The kernels listed are dependent on anaconda environments that you create and kernels installed. You see only default and conda root, because I'm assuming that you have simply installed the newest version of Anaconda for python 2.7 or 3.5. When installing Anaconda, it creates a root virtual environment and you can change the default environment based on environments that you have set up.
See the following for more information related to your question:
How do I add python3 kernel to jupyter (IPython)
https://github.com/jupyter/notebook/issues/1716
Jupyter and Apache Spark
I recommend setting up jupyter and spark in the following manner w/ your .profile.
export SPARK_PATH=~/...
export PYSPARK_DRIVER_PYTHON="jupyter"
export PYSPARK_DRIVER_PYTHON_OPTS="notebook"
After sourcing these variables you can call $ ./bin/pyspark and you'll have a spark context in a jupyter notebook.
The first approach is removing the extension... not recommanded.
The second approach is to just disable the extensions...recommanded
you can do something like this:
python -m nb_conda_kernels.install --disable --prefix=<ENV_PREFIX>
jupyter-nbextension disable nb_conda --py --sys-prefix
jupyter-serverextension disable nb_conda --py --sys-prefix
In this case, you just disable nb_conda_kernels and nb_conda that depend on the first one, but still keep the other ones active.
NOTE: Replace ENV_PREFIX with your root environment or another conda environment where the extensions have been installed.