Where is a docs for Jupyter front-end extensions JavaScript API? - jupyter-notebook

I've read the docs about writing the Jupyter front-end extensions, and learn the examples, and now can build the simple extension by myself.
But - where is a complete docs for Jupyter extensions JavaScript API? How to find the JavaScript API for notebook properties and methods?

This answer is outdated. Also see answer below.
This might not be the answer you hoped for. However, it might help some readers being new to JavaScript development.
I also was looking for documentation on the Jupyter client API and could not find official docs.
The JavaScript source code can be found on the GitHub repository, for example:
https://github.com/jupyter/notebook/blob/859ae0ac60456c0e38b44f06852b8a24f8a1cfb0/notebook/static/notebook/js/notebook.js
https://github.com/jupyter/notebook/blob/4.2.2/notebook/static/services/kernels/kernel.js
What also helped was to
A. Use Google Chrome development tools, set a break point in the extension and type
Jupyter
in the console. Then you get a browsable tree structure that can be used to inspect the Jupyter object. That tree structure does not seem to contain methods.
B. Log all the properties of an object, including the methods. If you want to know about the methods of the notebook use for example
for(var property in Jupyter.notebook){ console.log(property)}
C. When typing in the console there is code completion. For example you might want to type
Jupyter.notebook.
and see the suggestions on how to complete the command:
Also see
How to inspect Javascript Objects
How to display all methods of an object?
https://www.codeproject.com/Articles/24549/How-to-Inspect-a-JavaScript-Object
Chrome Developer Tools console - inspect JavaScript object
Browsable tree structure in dev tools console:
How to list properties including methods:
...

For newcomers it might be confusing that there are several projects with similar names for historical reasons:
a) Jupyter
https://github.com/jupyter
b) JupyterLab
https://github.com/jupyterlab/
The webpage https://jupyter.org/ references the newer b). However, the sub projects of a) do not include deprecation warnings.
=> If you find some documentation via search engine, you have to be careful if its related to a) or b).
Current documentation for JupyterLab extensions can be found here:
General info:
https://jupyterlab.readthedocs.io/en/3.2.x/user/extensions.html
Javascript API doc:
https://jupyterlab.readthedocs.io/en/stable/api/modules.html
Examples:
https://github.com/jupyterlab/extension-examples
Discussion forum:
https://discourse.jupyter.org/c/jupyterlab/extensions/
Related:
https://www.quora.com/What-is-the-difference-between-JupyterLab-and-Jupyter-Notebook-Is-there-a-use-case-for-one-over-the-other?share=1
https://github.com/jupyterlab/jupyterlab-plugin-playground

Apparently, there are is no front-end API documentation, as there is an open GitHub issue that even references your SO question. Maybe a few +1s on the issue might change this, although I suspect that the answer (if any) will point to JupyterLab, which has a defined front-end API but has no common technical base with Jupyter Notebook front-end extensions.

Related

Where can I find AndroidViewClient documentation?

Is there any documentation on AndroidViewClient covering public classes, methods, and syntax?
It is in the doc directory of the project.
You have to clone or download the project to view it properly in your browser as github's web interface will show the source code instead.
UPDATE
jthurner found a way, I didn't know existed, of showing the docs over github pages. You can now view the documentation online at API Documentation.

Can the GitHub Atom editor show properties and functions of classes?

Recently I moved from NetBeans to GitHub Atom editor. How can I access properties and functions of classes in the editor?
I use a mix with the symbol gen and symbols view packages. First one very good about generating ctag file for your project and second one for inspect code and jump to the definitions of tags. Also, it supports Show all symbols in current file future. It have to show for you the members and properties of your classes.
In short: after installation open a work directory with your project and try alt + cmd + g, wait several seconds, ctags file generating now for you and after that cmd + r and just start typing any part of a method or property in the input.
In addition to all the previous answers, I would recommend you to check Atom's package goto-definition, with its optional "performance mode" (which requires you to install ripgrep).
goto-definition will allow you to find and access properties and
functions/classes definitions even if they are not written in the same file. In combination with ripgrep, goto-definition is extremely fast, and you will not have to wait for file indexing within your project.
If you are referring to the members of a Java class (which I assume, since you've used NetBeans before), then this is currently not supported in Atom.
Atom is a (fairly simple) editor that allows you to edit text files, while full-blown IDEs (Integrated Development Environments) like Eclipse, NetBeans or IntelliJ IDEA have full language support including running, debugging and browsing Java class information. It might be better to stick with one of the IDEs I mentioned if you are looking for this kind of functionality.
Having said that, there's the https://atom.io/packages/atom-ctags package, which supposedly can show some meta information about classes you're working on. It's primarily for C++, although it might work for Java as well (I haven't tried).

Is it still possible to edit a document in google docs from alfresco share 4.2?

I have a 4.0.x binary installation of alfresco and have this menu highlighted below:
I have 2 custom installed 4.2.c versions and this option is missing. I have done the following to try and enable it as read from different parts of the web:
1) added the two following lines to both the share and the repo's alfresco-global.properties file
#enable GoogleDocs integration
googledocs.enabled=true
googledocs.googleeditable.enabled=true
2)Modified the share-custom-config.xml file in attempts to enable this and other google docs functionality.
So far this is the only thing missing. I am not sure whether this is a bug or whether I'm overlooking something else.
Yes, Google Docs integration works fine with Alfresco Community Edition 4.2.c. In fact, here is a video that shows you how to get it working:
http://www.youtube.com/watch?v=EbNDEp1KG1g
The video shows that the out-of-the-box installer will not create a working Google Docs integration due to changes on the Google side. So you need to reinstall the AMPs to both the alfresco and share wars as gagravarr mentioned above.
If you are using Google Docs integration in the repository folders (external to a Share site) you will need to install from head because there is a bug. If you are using the integration only within Share sites the latest released version of the integration, downloadable from the 4.2.c file list page, will be fine.

single secure executable for tidesdk

I just started looking into TideSdk and noticed that when I "compile" (or package) a project (in Win-7), I get all of these dependecies which is actually the un-compiled source code for the app.
Is there any way to:
Have Tide SDK package a file to one executable
Not have the source code visible in any way, shape, or form in the final executable?
If none of those are possible, is there an alternative that can to these things?
We are working on a solution. There are a few possibilities. The only thing that is possible currently is to obfuscate your code using google closure library through a tidebuilder option.
I found this on google when trying to do something similar. It is annoying but seems to work.
http://coffeecone.com/post/36127491095/howto-single-exe-for-tidesdk
I use the application virtualization app Cameyo for this purpose. http://www.cameyo.com/

Documentation for writing GNOME Shell extensions

I've been asked to customise the layout of the GNOME 3 desktop. Apparently the way to do that is by writing an "extension".
I've managed to do some of the things I wanted to do, but I feel utterly starved of information. I cannot find any useful documentation anywhere. I've wasted entire days of my life frantically googling every imaginable search term in a desperate attempt to find useful information.
The GNOME website has hundreds of extensions for download. These are not trivial 3-liners; they're sophisticated pieces of code. It defies belief that anybody could write these without documentation explaining how to do it.
Please, can somebody tell me where the actual documentation is? So far, the best I've managed to do is take apart existing extensions trying to track down the magic command that does the specific bit I'm interested in. (Not an easy task!)
Command names, object paths, example programs, anything would be helpful!
I have recently dug into it myself. The documentation is usually sparse or outdated. Here are some sources which helped me to get started (and through development):
Basic Stuff
Step-by-step tutorial (Gnome 3.4)
Unofficial documentation for the JavaScript bindings of many libraries
The sources of the gnome-shell's JavaScript bindings
Explanation of the St (Shell Toolkit) Ui-Toolkit components.
Some unofficial guidelines to get your extension on extensions.gnome.org
Since the documentation is nearly unavailable (or up to date), you'll need to do a lot of source-reading. I linked the gnome-shell sources above (the JavaScript part) which is a good start when diving into parts that are not covered by the In-official documentation (which is the most complete thing you'll find).
What's also particular helpful is checking extensions.gnome.org for extensions which do similar things to what you want to create, and look at their sources (most of them are open-source on GitHub or Bitbucket. You can also install them and find the sources under ~/.local/share/gnome-shell/extensions/).
When searching for something to use or more documentation on a particular function, you can also consult manuals for bindings in different languages (thought the parameters and return-values might not match).
Last but not least, here is some debugging advice:
LookingGlass is not particularly helpful. It only shows one line of an exception (the description) and only if they occur at startup time (when your extension is first started).
For full StackTraces and runtime-exceptions, consult the ~/.xsession-errors-file. It might be very long and bloated. I use this handy script to read it:
# Grabs the last session-errors from the current X11 session.
# This includes full Stack-Trace of gnome-shell-extension errors.
# See https://live.gnome.org/GnomeShell/Extensions/StepByStepTutorial#lookingGlass
tail -n100 ~/.cache/gdm/session.log | less
Note that since Gnome 3.6, if you are using gdm as display manager, the current session log is the file ~/.cache/gdm/session.log.
On some newer distros using systemd, you can get the error logs with:
journalctl -f /usr/bin/gnome-session
For debugging the prefs-part of your extension, you can launch the preferences by using the gnome-shell-extension-prefs-tool from a terminal, to see any exception-output on the console (you can also call the tool like gnome-shell-extension-prefs [uuid], to directly show your extensions preferences).
Since there is currently no real way of debugging with breakpoints (there is, but it's tricky), you can log on the console for quick checking, use the print()-function. You will see the output as mentioned above (either in the sessions-error file or on the terminal when starting gnome-shell-extension-prefs-tool).
Although it might be a little hard to get into it, the extension framework is quite powerful. Have fun!
I wrote a Blog-Post with somewhat greater detail, which can be found here: Making Gnome-Shell Extensions
An extensive list of references can be found on the Gnome Developer - API Reference page.
I used the following for my extension, but your use may vary:
GTK+ 3
GTK+ is the primary library used to construct user interfaces in GNOME applications. It provides user interface controls and signal callbacks to control user interfaces.
GDK 3
GDK is an intermediate layer which isolates GTK+ from the details of the windowing system.
Clutter
Clutter is a GObject based library for creating fast, visually rich, graphical user interfaces.
GObject Introspection
GObject Introspection is striving to provide a middleware layer between (GObject based) C libraries and language bindings.
Shell
Shell Reference Manual
St
St - Shell Toolkit - is the GNOME Shell's custom Clutter-based toolkit that defines useful actors. Some of these actors, such as StBoxLayout and StBin implement various layout options.
Icon Theme Specification
This freedesktop.org specification describes a common way to store icon themes.
NOTE: These last two are very helpful in finding visual element parameters!
PyGTK
PyGTK is GTK+ for Python. This reference contains a chapter for each Python PyGTK module (that corresponds to the underlying GTK+ library) containing the class descriptions.
PyGObject
PyGObject is a Python extension module that gives clean and consistent access to the entire GNOME software platform through the use of GObject Introspection. Specifically speaking, it is Python Bindings for GLib, GObject, GIO and GTK+.
This reference contains a chapter for each PyGObject module containing the class descriptions.
The documentation is on:
https://gjs.guide/extensions/
For the documentation of libraries:
https://gjs-docs.gnome.org/
More details on https://gjs.guide/extensions/overview/architecture.html
The other stuff you might want to check are
https://gitlab.gnome.org/GNOME/gnome-shell/blob/main/js/ui/popupMenu.js
https://gitlab.gnome.org/GNOME/gnome-shell/blob/main/js/ui/dialog.js
https://gitlab.gnome.org/GNOME/gnome-shell/blob/main/js/ui/modalDialog.js
https://gitlab.gnome.org/GNOME/gnome-shell/blob/main/js/ui/panelMenu.js
https://gitlab.gnome.org/GNOME/gnome-shell/tree/main/js
https://gitlab.gnome.org/GNOME/mutter
You can browse under js/ for more code to be reused.
You might also want to check https://gi.readthedocs.io/en/latest/index.html
Question:
I could not find anything under https://gjs-docs.gnome.org/ except some CSS and Javascript documentation ?!?!
Answer:
You have to first enable the docs to use them. Here, you will be mainly looking for:
clutter
meta
shell
st
Create a file like:
echo '{"docs":"clutter9~9_api/clutterx118~8_api/gobject20~2.66p/meta9~9_api/shell01~0.1_api/st10~1.0_api","hideIntro":"1"}' > devdocs.json
Import this file to https://gjs-docs.gnome.org/settings
Now you will be able to visit:
https://gjs-docs.gnome.org/shell01~0.1_api-global/
https://gjs-docs.gnome.org/shell01~0.1_api/
https://gjs-docs.gnome.org/meta9~9_api/
https://gjs-docs.gnome.org/st10~1.0_api/
https://gjs-docs.gnome.org/clutter9~9_api/
https://gjs-docs.gnome.org/clutter9~9_api-actor/
Warning: The version on the devdocs.json file is hardcoded. It will be outdated in no time, so you might want to check the version. The point is - you can not access docs until you enable them.
P.S. I know, this is a mess. This is how they did it.

Resources