Cantor’s script editor news

A small blogpost about Cantor before Brazilian Carnival parties.

KDE 4.13 is feature freeze now and I developed some improvements in Cantor’s script editor. It will be available in next KDE stable release around April 16.

Now Python 2 and Scilab backends have support to script editor! See some pictures:

python_script_editorCantor Script Editor for Python

scilab_script_editor Cantor Script Editor for Scilab

You can access script editor in menu bar View -> Show Script Editor. The script editor is based in kate-part, so you have syntax highlighting, line numbering, mini-map, and all cool stuffs from Kate. You have a Run Script button too, so you can just push this button and the script will be load in Cantor worksheet, as you can see in examples.

There is news for others Cantor backends too. Now script editor load default syntax highlighting for each backend – in old versions it did not happen. And, if you push New button, the new script editor will have the default syntax highlighting working too.

It is the news about my work in Cantor for KDE 4.13. I intent improve Python 2 backend and script editor for future releases.

But now it is time to go to Brazilian street parties! Happy Carnival! ;)

Cantor: Python 2 backend feature tour

Introduction

python2_selectCantor backend selection screen

In 2013 I developed a Python 2 backend for Cantor, a project funded in part by Google Summer of Code. Now this backend is available in Cantor released in KDE 4.12.

Cantor is a mathematical/scientific programming software, a frontend providing IDE features (syntax highlighting, tab-complete, variables management, and more) and a advanced terminal. Cantor support a lot of mathematical engines like Octave, Sage, Maxima, Kalgebra, Qualculate, R, Scilab (developed by me too), and now, Python 2. You can see Cantor as a Matlab-like software, but it uses other mathematical environment/software as programming language.

This post I will do a “feature tour” in Python 2 backend to show Cantor software for scientific python developers community.

Initial Screen – Syntax Highlighting and Tab Complete

python2_initialscreenCantor initial screen

After select the Python 2 backend, Cantor will show the initial screen. This window have a big widget for the Python 2 terminal, and two side panels – one to show the Python 2 help and the other to variables management.

Let’s see some commands inputs in the terminal:

python2_syntaxSyntax highlithing

Cantor is highlighting the Python 2 syntax and, in side panel, you can see the variables created.

Now, let’s create new variables with similar names to test the tab complete. See the picture below:

python2_completeTab complete for variables

After create variables variable_x, variable_y e variable_var, we can write in terminal var and type tab key twice – Cantor will show the variables and functions with the same piece of word. Tab complete is available for module functions too.

python2_complete2Tab complete for module functions

Cantor show error messages in terminal too. Next figure show a import error:

python2_errorError message

You can save the terminal state or just the input commands and their outputs in a file. Cantor allows upload/download a terminal example for a remote server. You can explore this features in “File” menu.

Help Panel

Cantor shows Python help from help command in a side panel. The picture below shows the help for complex class:

python2_helpHelp panel

Cantor uses Qt/KDE technologies, so you can change the window format moving the side panels. Next picture show the window with the variables management in the left side and the help panel in the right side.

python2_help_completePanels in different sides

Variables Management

python2_variables Variables management panel

Variables management panel shows the variables created in Cantor session, showing their labels and values. The panel have some additional functions too, in buttons bottom the widget. These functions are, from left to right, Add variableLoad variables, Save variables, and Clear all variables.

Add variable just open a pop-up window to input a label and a value to a variable.

Load variables and Save variables uses shelve module to data persistence. When the buttons are clicked, Cantor loads scripts to, in first case, read and load variables to the session, and, in second case, save the python dictionary in a file. The figures below show this operations:

python2_save_variablesSaving variables

python2_load_variablesLoading variables

The function Clear all variables delete each variable from Python dictionary. The code is below:

python_backend_variable_management_usecase6Graphics

python_command_to_plotCode for graphic creation using matplotlib

python_plot_resultGraphic loaded in Cantor

The figures below show the graphic loaded in Cantor worksheet. When a session is exported, the graphic will be exported too. This feature can be configured to create the graphics in a new window – this is the default option.

Conclusion and Future

This is the first stable version of Python 2 support in Cantor. It is working good, but you can see the bug presence in some parts of software.

I would like to see some feedbacks from mathematical/scientific programming python community. I am not a “pythonist”, so the python community can find bugs and strange behaviours in the software better than me. I would like to see some feature suggestions too.

For the next version, Python 2 backend will have support to script editor – unfortunately, I can not develop it for this release.

If you are interested in the backend development, my blog have a set of posts (in Portuguese and English) about it. You can download the source code in Cantor repository – the license is GPLv2. And you can submit a bug report in KDE bugzilla.

And you can contact me in comments area below or in my mail address filipe at kde.org.

Cantor backends for Python2 and Scilab merged in master

A fast update: now Cantor backends for Python2 and Scilab were merged in master branch. I will do more polishing until the stable release in KDE 4.12. You can follow the new status of development compiling and testing Cantor from master branch.

In a related topic, KDE Edu sprint in A Coruña, Spain, began and runs through the October 30th. Unfortunately I can not participate this time but I expect go to the next meeting (maybe, in Akademy 2014). =)

Have a good work, edu-gearheads!

Scilab backend for Cantor is reviving

Back to 2011 I was a GSoC student at Scilab community. My project was to create a backend for Scilab in Cantor, the KDE mathematical software. My project ended very well and the objectives were accomplished. You can see several features of this project in reports from my blog.

The backend would be working with Scilab 5.4 because I implemented the standard streams support in Scilab. The backend was available in KDE 4.8, released in January 2012, but Scilab 5.4 was released in October 2012. Unfortunately, when this version of Scilab was released, the standard streams support were not working.

Since this date I tried some times fix it but I did not obtained success.

Therefore, Scilab release a 5.5-beta1 version in begin of this October and I did a test with Cantor and… voilá! The standard streams is working now and the Cantor backend is working too!

Now it is time to Scilab backend for Cantor revive! I am doing “nightly-builds” of Scilab to verify if the standard streams are working and I developed new features to the backend. Let me show them:

Predefined functions and variables

In the past Scilab backend had a giant-size XML file listing all predefined functions and variables. Now the backend run getscilabkeywords command to get this information, used in tab-complete and syntax highlighting.

Tab-Complete and Syntax Highlighting

These features were available in previous version of the backend to predefined functions and variables. Now user variables are too used in these features.

scilab-backend-tab-complete

Tab-complete for predefined functions

scilab-backend-tab-complete-variable
Syntax highlighting and Tab-Complete for user variables

 

scilab-backend-syntax-highlithing

Syntax highlighting

Variable Management Panel

Scilab backend now have a preliminary variable management panel. All variable defined by user are showed in this panel.

scilab-backend-variable-management-panelVariable Management panel

With this feature the user can save and load variables, and clean the variable environment.

But it is a preliminary version based in Octave variable management: the user must define the variable presenting it (you can not use “;”). So the label and value will be send to panel.

Scilab backend reviving in KDE 4.12

I am working for this new version of Scilab backend in KDE 4.12.

But you can test it now: the code is hosted in scilab-backend branch from Cantor repository.

Python Backend for Cantor: Append Plot Images in Cantor Workspace

Other feature implemented in python backend for Cantor in last weeks was “append plot image to Cantor Workspace”.

In other backends you can, optionally, generate a plot image and this image will be append in Cantor workspace, not generating a separated window to the picture.

Below we have a command to generate a plot image in python using matplotlib and pyplot:

python_command_to_plot

Now we have the result appended in Cantor workspace:

python_plot_resultIn python, to save a picture using pyplot, we type the command pyplot.savefig(). But, if a picture was saved, it can not be shown in separated window. Otherwise, if a picture is shown in a separated window, it can not be saved to a file.

To solve this problem, the python backend change the show() command to savefig(), with a random name to the picture. The image is saved in a temporary file and loaded in Cantor workspace.

The option to load figure in Cantor workspace or to use a separated window is configured in python backend configuration screen. The default is to use separated window because matplotlib/pyplot have several additional features in image screen.

I would like to see some feedback from you, in special if you are a python developer. The code is hosted in python-backend branch from Cantor repository.

Side panels in Python Backend for Cantor: Help and Variable Management

In last weeks I developed some new features to python backend for Cantor. In this post I will write about two of their: the help and the variable management, implemented as panels.

python_backend_help_panel python_backend_variable_management

 Help Panel on left; Variable Management Panel on right

Help panel

Help panel shows the help output in a separated panel, facilitating the consult of this information. To use it, simply use help command as in python interactive mode, as in example below:

python_backend_help_panel_usecase_1

Below a bigger help output, from a python module:

 python_backend_help_panel_usecase_2

In previous picture, did you see some change in variable management panel?

Variable Management panel

Variable management panel is a great feature provide by Cantor, but until now just Octave backend had it. This feature show the variables defined in the session, their values, and allow some interesting functions to manipulate these variables.

You can define a lot of variables in python session and these variables will be shown in the panel. See:

python_backend_variable_management_usecase1

In previous picture, I defined a integer variables x and y, a string a, and two modules: numpy and scipy, this last as sc. All this values are shown in panel.

Now I will change some values defined previously and will add some others:

python_backend_variable_management_usecase3

See, now I defined a variable aa by the concatenation of two a‘s; the value of a is now aa; div is the division of y by x. I have a 2-dimensional matrix mtr defined by matrix function from numpy module; a python class HelloWorldClass and a object hello.

I can change the value of some these variable manipulating their values in the panel. For example, I can rewrite the x variable from 35 to 350, clicking in value column and typing 350.

But the more interesting features are provide by the buttons bellow this panel. These buttons load python scripts to run some feature. There are: add variable, load variables from a file, save variables to a file and clear all variables in the session.

Add variable is quite simple: a dialog is open and you type the variable and their value:

python_backend_variable_management_usecase4Save/Load use shelve module to save and load the variables of the session. But, it is important to say, this feature don’t save all the variables because shelve module have some limitations. For example, I saved this session to a file named “python_session.txt”. The python code loaded is:

python_backend_variable_management_usecase5

After save, I will clear the session. The python code loaded is:

python_backend_variable_management_usecase6And, finally, I will load the variables. The python code loaded ans the variable panel is show below:

python_backend_variable_management_usecase8

Conclusions

It is working now but I need some more tests, in special the save/load python objects defined by user and modules.

I would like to see some feedback from you. The code is hosted in python-backend branch from Cantor repository, so you can test it.

Cantor – dynamic keywords in python backend

In previous post, I mentioned about dynamic keywords in python backend. The idea is, after import a python module in Cantor workspace, functions, keywords, variables, and more from this module are load by Cantor and available to syntax highlighting and tab complete.

This feature is implemented for now. You can test it compiling Cantor from python-backend branch.

But, let me show more information about this feature.

There are several ways to import a python module in python console. You have “import modulename”, “import modulename as modulevariable”, “from modulename import *”, “from modulename import function_1, function_2, …”, and more. Each import way causes different consequences to user experience.

The four import ways mentioned in previous paragraph are supported by python backend. I will show these different import ways and how python backend behave for each one.

import modulename

The more basic import way. After this command, a variable named “modulename” is defined and the functions and more keywords of this module are available to access using “modulename.keyword”.

python_import_modulenameTab Complete

python_import_modulename_highlighting

Syntax Highlighting

import modulename as modulevariable

This way the user define a name “modulevariable” to reference “modulename”, and “modulename” is not defined. So, you can access the functions and more from “modulename” using “modulevariable.keyword”.

python_import_modulename_as_modulevariable

Tab Complete

python_import_modulename_as_modulevariable_highlithing

Syntax Highlighting

from modulename import *

This way the user import all functions and keywords from “modulename” but anything variable is defined to access “modulename”. The functions of the module are accessed directly.

python_from_modulename_import_all

Tab Complete

python_from_modulename_import_all_highlithing

Syntax Highlighting

from modulename import function_1, function_2, …

The user import only specific functions from a “modulename”, no all functions.

python_from_modulename_import_specific

Tab Complete

python_from_modulename_import_specific_highlithing

Syntax Highlighting

Cantor plugin

I developed a Cantor plugin to import modules. This plugin open a dialog to user enter a modulename and, after press Ok, Cantor run “import modulename” and keywords are available. The diaglog is accessible by “Packaging” menu, in toolbar.

python_import_cantor_plugin

Cantor Plugin

Handling Errors

The backend can identify several errors during import.

python_import_errors

Handling Errors

Conclusions

Well, the feature is working and it is mature for use, however it don’t support all import ways in python. But, I think these five ways cover the most commons import ways used by most python scientific users.

The important thing is, this feature enable python backend to support the several python modules, and no only scipy, numpy, and matplotlib, as I proposed in begin of this project.

Let me know how you import a module in python. I will develop support to more import ways in future versions of the backend.

For now, wait for more news of this project soon!