Opening a specific Julia notebook (via IJulia) in the REPL - julia

the Julia (i'm using 0.6.2) REPL makes it possible to do some work and then execute
julia> using IJulia
julia> notebook(dir=pwd(), detached=true)
which nicely launches jupyter in the directory specified by dir.
is it possible from the REPL to include a specific notebook to open ?

This worked for me recently (julia v 1.5.1, macOS 10.14):
using IJulia
notebook(dir="/path/to/directory/with/my/notebook",detached=true)
One thing I noticed is starting jupyter in the background, julia doesn't give you a link to where to open the notebook in the browser.
I was able to open http://localhost:8888/ in my browser to find the notebook, although I thought there was a URL token needed. This link in the browser also worked:
file:///$HOME/Library/Jupyter/runtime/nbserver-12912-open.html
I got this from the REPL documentation:
?notebook
#search: notebook
# notebook(; dir=homedir(), detached=false)
# ..etc

this kinda works (but feels like a hack):
julia> ;jupyter notebook someJuliaNotebook.ipynb 2>/dev/null &
which produces a relatively clutter free terminal window i can keep using.

Related

JuliaPro: import Jupiter notebook

I usually use Jupyter to have my interactive environment with Julia, now I am switching to JuliaPro, as they claim it is the fastest and easiest way of Julia programming. But, I cannot upload my .ipynb notebooks on JuliaPro. Are they compatible with each other? How can I work with my notebooks on JuliaPro? Thanks!
As was explained in the comments, the .ipynb file format was designed to be rendered in a browser, while Juno/Atom is a text editor that expects a plain text file for display. In general therefore you wouldn't be able to directly use an .ipynb file in Juno.
There is however an option to convert your notebooks to .jl scripts, which is exactly what Juno is expecting: in your Jupyter notebook click on File > Download as > Julia (.jl) (see below)
There's also an answer here that discusses a command line option if you need to batch convert a lot of files.
Also note that your choice of editor / programming environment is unrelated to the version of Julia you're using - while JuliaPro ships with Juno as standard (or potentially the Julia VS Code extension in future), nothing's keeping you from just doing using Pkg; Pkg.add("IJulia"); using IJulia; notebook() in your JuliaPro installation and continuing to work on your notebooks in Jupyter.

Using jupyter R kernel with visual studio code

For python jupyter notebooks I am currently using VSCode python extension. However I cannot find any way to use alternative kernels. I am interested in jupyter R kernel in particular.
Is there any way to work with jupyter notebooks using R kernel in VSCode?
Yes, it is possible. It just requires an additional configuration to connect with the R kernel in VSCode.
It's worth noting that, if you prefer, you can use the notebook in VSCode Insiders where there is native support for notebooks in many languages, including R.
If you're using Jupyter in VSCode, firstly install IRkernel (R kernel).
According to the docs, run both lines to perform the installation:
install.packages('IRkernel')
IRkernel::installspec() # to register the kernel in the current R installation
Now, you should:
Reload Window Ctrl + R
Type Ctrl + Shift + P to search for "Jupyter: Create New Blank Notebook"
Click on the button right below ellipsis in upper right corner to choose kernel
Switch to the desired kernel, in this case, R's
That's it!
Agreed with #essicolo, if you are 100% stuck on using vscode this is a no-go.
[About kernels] Sorry, but as of right now this feature is only supported with Python. We are looking at supporting other languages in the future.
Yeah, that's the case for now, even if you start an external server. I hate having to say that, as we really want to support more of the various language kernels. But we started out with a Python focus and we still are pretty locked into that for the near future. Polyglot support is coming, but it won't be right away
per Microsoft Employee IanMatthewHuff
https://github.com/microsoft/vscode-python/issues/5109#issuecomment-480097310
preface - based on the phrasing of your question, I am making the assumption that you are trying to perform IRkernel in-line execution from your text ide without having to use a jupyter notebook / jupyterlab.
That said, if you're willing to go to the dark side, there might be some alternatives:
nteract's Hydrogen kernel for Atom IDE - the only text ide that I'm aware of that still supports execution against IRkernel. I know, I know - it's not vscode but it's as close as you'll probably get for now.
TwoSigma's Beaker notebook - it's been a lonngggg time for me but this a branch of jupyter that used to support polyglot editing, I'm not sure if that's still supported and it seems like you aren't that interested in notebooks anyway.
#testing_22 it works with me too
just add some note from my experience
It will failed If you run IRkernel::installspec() from RStudio or from Jupyter Conda environment failed way
Please run this syntax with VSCode terminal
install.packages('IRkernel')
IRkernel::installspec()
The rest is same, please restart VSCode and select "R" kernel from VSCode

Julia Jupyter Notebook persists despite logout from browser

Running Julia in a terminal (macOS) and then launching a Jupyter notebook
julia> using IJulia
julia> notebook(detached=true)
This works fine. However when I log out of the notebook and closing the browser, there is still a jupyter-notebook running and I have to kill -2 pid to make it go away.
Is this expected behaviour? Is there a parameter I need to set somewhere?
Yes, this is the expected behaviour for the way you've called notebook. The server doesn't stop when your browser page is closed (you might open another, for example!). Using the detached keyword argument means the server process is started in the background, so doesn't block the Julia session you started it from, so you'd have to do extra work if you wanted to stop it from there. From the IJulia readme:
You can use notebook(detached=true) to launch a notebook server in the background that will persist even when you quit Julia

Unable to create a Julia file using Jupyter Notebook in Chrome browser

I am trying to write Julia using Jupyter Notebook in Google Chrome browser but when I click on New, I do not get the option of creating a new Julia file (shown in the screenshot). I have already added the package- IJulia. What am I missing?
I've seen this before. Doing a Pkg.build("IJulia") and then restart Jupyter fixed it for me.
EDIT: corrected capitalisation

How to develop with ipython notebook

I am new to IPython Notebook. I am using the Anaconda distribution on CrunchBang (Waldorf). My development cycle is as follows:
1. Open Spyder.
2. Open the .py file if not already loaded
3. Start IPython Notebook
4. Open the specific notebook from the main IPython screen
5. Select Cell/Run All
6. Note errors. If none goto step 11.
7. Save and close the notebook
8. Shutdown the notebook from main IPython screen
9. Correct errors in Spyder and save
10. go to step 4
11. Move on to the next part of the project and start the process over.
Is there a better approach for a noob? This really gets monotonous although I am learning quite a bit.
Thanks in advance
Forget Spyder for the time being just use the IPython notebook.
1, write code in notebook
2. test it
3. when done if needed make a py file...
You really will only need Spyder later for starting out it just complicates things for no gain
Use Spyder and .py files for writing big functions, classes, modules, tests, etc.
Use IPython notebooks for interactive work where you want to keep the output together with the code (e.g. data processing and analysis, demos, etc.).
To add to Ian's answer, another useful tool is the autoreload extension, which reloads modules automatically when they are changed.
To use, type into your IPython console or notebook:
%load_ext autoreload
%autoreload 2
For example:
This way you can work on a Python file and an IPython notebook at the same time, without having to reload the Python file after each change.
In addition to #dartdog's answer about developing directly in the notebook, if you must edit .py files used by the notebook then note the reload function which allows you to re-import already imported modules without having to shutdown and reopen the notebook.

Resources