I am using a fresh installation from conda, python 3.10.4, no extensions installed.
What's extra weird is that in the traceback it is highlighted correctly.
I already tried deleting ~/.jupyter to reset possible configurations.
Match-case is a recent addition to Python; it seems that CodeMirror, the editor which is used by Jupyter has not added match and case to the list of keywords. It might not be as trivial as it seems, because those are not hard keywords (as raise) but instead soft keywords. The traceback is highlighted using a different library which added support for match and case. I would suggest opening an issue on JupyterLab repo and https://github.com/codemirror/dev/issues to enquire whether CodeMirror proper plans to support match/case for Python.
Related
I am using Julia 1.8.4 in Jupyter, however, I get the following error message when I start it up.
[code_prettify] Sorry, can't use kernel language julia.
Configurations are currently only defined for the following languages: python, r, javascript
See readme for more details.
If I click "Ok", I am able to run the code in the cells but Jupyter does not highlight Julia code. It continues highlighting Python code and syntax. Is there a way I can fix this?
Or could someone refer me to the documentation?
Like the error message indicates, code_prettify only has configurations inbuilt for Python, Javascript, and R. From the docs:
Example implementations are provided for prettifiers for ipython, ir and ijavascript kernels which should work out of the box ...
Other languages may be added as defaults in the future
Support for Julia is yet to be added, hence the error message.
That said, code_prettify is only needed if you want to reformat your code (semi-)automatically. Syntax highlighting should work regardless, without any extension, and based on my testing, it does. Loading a notebook with a Julia kernel, the error message appears in the console, but the code is syntax-highlighted as usual.
So, if the syntax highlighting problem persists across notebook restarts, the issue must be with some other part of your notebook setup.
I am running jupyter via anaconda in a web browser on windows. In nbextensions: I have tried,
calico-spell-check,
calico-spell-check,
spellchecker/main.
All highlight misspelled words fine but none suggest correct words.
Am I missing a set up step, my google fu is letting me down. Is there another extension that works as expected. I find it hard to believe that there is no true spell checker / corrector extension for a system designed around presenting of data, I must be missing a set up step or fundamental understanding of the system.
From what I've seen, such as this you just get highlighting in the classic Jupyter notebook interface. The limitations of what can be done with that interface is one of the reasons the current path forward for Jupyter development is JupyterLab and efforts based on similar underlying modern machinery, i.e., notebook version 7 is intended to look like the classic notebook interface while being based on the more modern components.
JupyterLab has spell check with suggestions available already added for editing markdown cells and editing markdown documents, see here. You can try it out in your browser now by going here and clicking launch binder to bring up a session where the extension is already installed and working.
For code, JupyterLab already has a nice autocomplete implementation that you'll get when you start typing a word and press tab to see suggestions. Additionally, some ideas have been offered for extending the current spell checking extension for JupyterLab to handle code cells, see tracking for this issue.
I have a Jupyter Notebook that plots some data and lets the user interact with it via a slider.
What would be the easiest way to make a web app with a similar functionality? (reusing as much of the code...)
I believe the easiest way is to use voilà.
After installing you just have to run:
voila <path-to-notebook> <options>
And you will have a server running your notebook as a web app, with all the input code omitted.
AppMode is "A Jupyter extension that turns notebooks into web applications".
From the README:
Appmode consist of a server-side and a notebook extension for Jupyter.
Together these two extensions provide the following features:
One can view any notebook in appmode by clicking on the Appmode button in the toolbar. Alternatively one can change the url from
baseurl/notebooks/foo.ipynb to baseurl/apps/foo.ipynb. This also
allows for direct links into appmode.
When a notebook is opened in appmode, all code cells are automatically executed. In order to present a clean UI, all code cells
are hidden and the markdown cells are read-only.
A notebook can be opened multiple times in appmode without interference. This is achieved by creating temporary copies of the
notebook for each active appmode view. Each appmode view has its
dedicated ipython kernel. When an appmode page is closed the kernel is
shutdown and the temporary copy gets removed.
To allow for passing information between notebooks via url parameters, the current url is injected into the variable
jupyter_notebook_url.
To be complete - there exists also https://www.streamlit.io/ .
I still dont understand the exact difference between voila and streamlit.
At the moment I just struggle with the possibility to re-run everything with new parameters... I have bad luck with voila still.
Edit: I see that streamlit requires a raw python, not .ipynb, this fact would mean that this answer is completely wrong, I will search a bit more on streamlit before further action/comment.
Edit2: Voila looks great. However, I found few things that uncover the underlying complexity and thus a troubles that may arise.
callbacks. Widgets work great in jupyter, but since it is not possible to re-run one cell, sometimes the logic must be modified to work in Voila.
interactive java objects need a special treatment, e.g. matplotlib has a cheap solution, but there was nothing for e.g. jsroot
links. It is easy to create (a file and) a download link in jupyter, Voila can also serve a file, but it needs another extra treatment.
After all, I pose myself a question - is it better to learn many tricks and modifications to jupyter or to use some other system? I am going to see if streamlit can give em some answer.
The Jupyter Dashboards Bundlers extension from the Jupyter Incubator is one way to do it while retaining interactivity.
EDIT: While pip installing this package will also install the cms package dependency, like dashboard_bundlers, cms needs to be explicitly enabled/quick-setup as a notebook extension for the dashboard tools to work.
#raphaelts has the right idea and should be the accepted answer. As of Dec 2019, Voila is the most appropriate method to deploy Jupyter notebooks to production as a stand alone webapp. Think internal datascience teams sharing their analytics workload with internal C-Suite teams using SPA stlye Notebooks with all the code hidden and custom GUI/interactions thrown in. Recently discussed on HN
https://news.ycombinator.com/item?id=20160634 and the official announcement from the Jupyter maintainer https://blog.jupyter.org/and-voil%C3%A0-f6a2c08a4a93enter link description here
As mentioned above, voilà is a very powerful tool which hides the input cells from your notebooks and therefore provides a clean interface. In order to deploy your notebook with voilà you need to follow the specific steps of your organization. But if you want to quickly run it on your machine, simply install it with pip install voila. Then you can enter start from the command-line: voila my_notebook.ipynb or use the "Voila" button which should have appeared in your Jupyter notebook.
Note, however, that using voilà is only one part of the story. You also need to build the required interactivity, ie. to set up how to respond to input changes. There are quite a few frameworks for this.
The simplest one is to use the interact function or the observe method from the Ipywidgets library. This is very direct, but things can easily get out of control as you start having more and more widgets and complexity.
There are complete frameworks, some of them mentioned above. E.g. streamlit, dash and holoviz. These are very powerful and suited for larger projects.
But if you want to keep it simple, I also recommend to check out autocalc. It is a very easy-to-use library, which lets you define the dependencies between your widgets/variables and let all the recalculation be triggered automatically. A tutorial can be found here.
Disclaimer: I am the author of the autocalc package.
The easiest way is to use the Mercury framework. You can reuse all your code. To convert the notebook to web app you will need to add the YAML header in the first cell of the notebook (very similar to R Markdown). The widgets are generated based on YAML. The end-user can tweak widgets values and click the Run button to execute the notebook from the top to the bottom. You can easily hide the notebook's code (if you want) by setting the show-code: False in the YAML. The example notebook and corresponding web app are below.
Example of the notebook with YAML header
Example web app generated from notebook with Mercury
In another question:
Juno IDE for Julia, how to interact?
One of the answers stated:
You can't enter commands into the console in Juno--that's for displaying output. Commands can be submitted from within the editor by setting your cursor in the line to submit and pressing Ctrl+Enter or Shift+Enter. The value will then be displayed in a small popup next to the line and the output will be printed to the console if you have the console visible.
Note that the inability to use the console as you desire is by design. See here for information about the console from the Juno docs.
I am encountering an issue that might make this design decision a bit impractical at times.
First, let me say that I am new to Julia and Juno (not to coding, just trying to learn Julia now), so there might be a way to fix this and I do not know about it.
I am using the package RCall, that allows to include R code into Julia, so I am trying to install some R packages. One of the packages is asking me a "y/n:" question and I cannot answer it because I cannot access the console, and sending code from the editor to the console using command+Enter is blocked (because the console line is executing).
To reproduce this issue (note that R 3.2.0 or above needs to be installed, and I had to restart Juno after installing RCall for it to work):
Pkg.add("RCall")
Pkg.build("RCall")
restart Juno
using RCall
reval("install.packages(\"rgdal\")")
A pop-up will appear asking to select a mirror, just choose 0 and OK. Then the package is asking me if I want to install some dependencies "y/n:" and the whole execution is blocked.
I guess that this can be fixed just by using Julia from the command line (and forgetting about Juno), but I like to use IDEs.
Do you have any ideas about how to circumvent this issue? or another IDE for Julia?
I followed the directions in the buildroot documentation but I think they may be wrong. My patch never gets applied.
To be clear, I am not trying to patch files in the "output" directory, which is what I think the directions are describing. I'm trying to patch files in the "package" directory to fix a problem with one of their recipes.
Does build root not allow patching of buildroot during the build? Or is there some trick to it?
Or do I just need to write a script that will apply the patch before running make?
Also, there is no error generated when building the package in question, during the patch step. Should there be one if the patch is malformed or not appliable?
thanks,
Well, just as you discovered, patching in Buildroot (as well as any other build system), does refer to patching the source code of a particular application. (In this case files unpacked somewhere under output/build).
If you need to fix something in how Buildroot builds a certain package, you'll need to manually patch the packages .mk and Config.in (possibly adding patches etc). I'd recommend you to create a local branch, and do your work there. This will allow you to easily merge in updates from the main Buildroot tree.
If you're fixing build issues or something else that might be of interest to others, please submit the patch to the Buildroot mailing list.