Join us for a webinar to see how the PyXLL Python for Excel add-in makes it easy to solve your biggest data analysis challenges with advanced Python tools and analytic engines.
Enthought Canopy 1.4 is now available! Users can easily update to this latest version by clicking on the green “Update available” link at the bottom right of the Canopy intro screen window or by going to Help > Canopy Application Updates within the application.
Key additions in this release are a Canopy-configured command prompt, inclusion of new packages in the full installer utilized by IT groups and users running from disconnected networks, and continued stability upgrades. We’ve also updated or added over 50 supported packages in Canopy’s Package Manager on a continual basis since the v.1.3 release. See the full release notes and the full list of currently available Canopy packages.
New Canopy-Configured Command Prompt
An important usability feature added in Enthought Canopy 1.4 is a Canopy-configured command prompt available from the Canopy Editor window on all platforms via Tools > Command Prompt. When selected, this opens a Command Prompt (Windows) or Terminal (Linux, Mac OS) window pre-configured with the correct environment settings to use Canopy’s Python installation from the command line. This avoids having to modify your login environment variables. In particular, on Windows when using standard (ie, non-administrative) user accounts it can be difficult to override some system settings. Continue reading
Authors: Brett Murphy and Aaron Waters
The March 6 New York Quantitative Python User’s Group (NY QPUG) Meetup included presentations by NAG (Numerical Algorithms Group), known for its high quality numerical computing software and high performance computing (HPC) services, and Enthought, a provider of scientific computing solutions powered by Python.
Brian Spector, a technical consultant at NAG, presented “Implied Volatility using Python’s Pandas Library.” He covered a technique and script for calculating implied volatility for option prices in the Black–Scholes formula using Pandas and nag4py. With this technique, you can determine for what volatility the Black–Scholes equation price equals the market price. This volatility is then denoted as the implied volatility observed in the market. Brian fitted varying degrees of polynomials to the volatility curves, then examined the volatility surface and its sensitivity with respect to the interest rate. See the full presentation in the video below:
Today Enthought announced that it is now the worldwide distributor for PyXLL, and we’re excited to offer this key product for deploying Python models, algorithms and code to Excel. Technical teams can use the full power of Enthought Canopy, or another Python distro, and end-users can access the results in their familiar Excel environment. And it’s straightforward to set up and use.
Installing PyXLL from Enthought Canopy
PyXLL is available as a package subscription (with significant discounts for multiple users). Once you’ve purchased a subscription you can easily install it via Canopy’s Package Manager as shown in the screenshots below (note that at this time PyXLL is only available for Windows users). The rest of the configuration instructions are in the Quick Start portion of the documentation. PyXLL itself is a plug-in to Excel. When you start Excel, PyXLL loads into Excel and reads in Python modules that you have created for PyXLL. This makes PyXLL especially useful for organizations that want to manage their code centrally and deploy to multiple Excel users.
Creating Excel Functions with PyXLL
To create a PyXLL Python Excel function, you use the @xl_func decorator to tell PyXLL the following function should be registered with Excel, what its argument types are, and optionally what its return type is. PyXLL also reads the function’s docstring and provides that in the Excel function description. As an example, I created a module my_pyxll_module.py and registered it with PyXLL via the Continue reading
Enthought Canopy 1.3 is now available and users should see the update notification in the bottom right corner of the Canopy welcome screen (as shown in the image below). This is a fairly small update primarily focused on bug fixing and stability improvement. The biggest change is the move to Python 2.7.6 from 2.7.3.
Python 2.7.6 rolls up a couple of minor updates to the core Python environment. The most important changes from our perspective are a number of security fixes required by some users as well as fixes for Mac OS “Mavericks.” Details can be found in the Python release notes, but in general the change should be transparent to most users. The only caveat is for users building Python eggs with native C or FORTRAN extensions and publishing those eggs to users who may still be running earlier versions of Canopy or Python 2.7.3 in general. In this case, it is safest to continue building against earlier versions of Canopy.
But isn’t updating Python versions painful you may ask? In the past, yes, updating to a new Python version often required a new Python install and then re-installing all of your custom packages. However, with Canopy’s auto-update mechanism, it’s simply a matter of clicking the “Update available” link and choosing “Install and relaunch” or “Install after quit.” Canopy will automatically update the core Python installation and restart without impacting your environment. Additionally, whether you are running Canopy 1.1, 1.1.1, or 1.2, Canopy will jump straight to 1.3 and get you all of the latest updates.
We encourage all users to update to Canopy 1.3 as the 1.2 and 1.3 versions include a large number of stability fixes as well as cleaning up a lot of other less serious, but still important aspects of the user experience. For those new to Canopy, you can get Canopy here.
Author: Jason McCampbell
Canopy 1.2 is out! The release of Mac OS “Mavericks” as a free update broke a few features, primarily IPython, so we held the release to try to make sure everything worked. That ended up taking longer than we wanted, but 1.2 is finally out and adds support for Mavericks. There is one Mavericks-specific, Qt font issue that we are working on correcting which causes the wrong system font to be selected so UI’s look less-nice than they should.
The biggest new feature is integration with Microsoft’s Python Tools for Visual Studio (PTVS) package. PTVS is a full, professional-grade development IDE for Python based on Visual Studio and provides mixed Python/C debugging. The ability to do mixed-mode debugging is a huge boon to software developers creating C (or FORTRAN) extensions to Python. Canopy v1.2 includes a custom DLL that allows us to integrate more completely with PTVS and solves some issues with auto-completion of Python standard library calls.
Beyond PTVS, we have added the Qt development tools, such as qmake and the UIC compiler, to the Canopy installation tree. These tools are available on all platforms now and enable Qt developers to access them from Canopy directly rather than having to build the tools themselves.
Canopy 1.2 includes a large number of smaller additions and stability improvements. Highlights can be found in the release notes and we encourage all users to update existing installs. As always, thanks for using Canopy and please don’t hesitate to drop us a note letting us know what you like or what you would like to see improved. You can contact us via the Help -> Suggestions/Feedback menu item or by sending email to email@example.com.
And you can download Canopy from the Enthought Store page.
Authors: Kurt Smith, Robert Grant, and Lauren Johnson
We attended SuperComputing 2013, held November 17-22 in Denver, and saw huge interest around Python. There were several Python related events, including the “Python in HPC” tutorial (Monday), the Python BoF (Tuesday), and a “Python for HPC” workshop held in parallel with the tutorial on Monday. But we had some of our best conversations on the trade show floor.
Python Buzz on the Floor
The Enthought booth had a prominent “Python for HPC: High Productivity Computing” headline, and we looped videos of our parallelized 2D Julia set rendering GUI (video below). The parallelization used Cython’s OpenMP functionality, came in at around 200 lines of code, and generated lots of discussions. We also used a laptop to display an animated 3D Julia set rendered in Mayavi and to demo Canopy.
Many people came up to us after seeing our banner and video and asked “I use Python a little bit, but never in HPC – what can you tell me?” We spoke with hundreds of people and had lots of good conversations.
It really seems like Python has reached an inflection point in HPC.
Python in HPC Tutorial, Monday
Kurt Smith presented a 1/4 day section on Cython, which was a shortened version of what he presented at SciPy 2013. In addition, Andy Terrel presented “Introduction to Python”; Aron Ahmadia presented “Scaling Python with MPI”; and Travis Oliphant presented “Python and Big Data”. You can find all the material on the PyHPC.org website.
The tutorial was generally well attended: about 100–130 people. A strong majority of attendees were already programming in Python, with about half using Python in a performance-critical area and perhaps 10% running Python on supercomputers or clusters directly.
In the Cython section of the tutorial, Kurt went into more detail on how to use OpenMP with Cython, which was of interest to many based on questions during the presentation. For the exercises, students were given temporary accounts on Stampede (TACC’s latest state-of-the-art supercomputer) to help ensure everyone was able to get their exercise environment working.
Andy’s section of the day went well, covering the basics of using Python. Aron’s section was good for establishing that Python+MPI4Py can scale to ~65,000 nodes on massive supercomputers, and also for adressing people’s concerns regarding the import challenge.
Python in HPC workshop, Monday
There was a day-long workshop of presentations on “Python in HPC” which ran in parallel with the “Python for HPC” tutorial. Of particular interest were the talks on “Doubling the performance of NumPy” and “Bohrium: Unmodified NumPy code on CPU, GPU, and Cluster“.
Python for High Performance and Scientific Computing BoF, Tuesday
Andy Terrel, William Scullin, and Andreas Schreiber organized a Birds-of-a-Feather session on Python, which had about 150 attendees (many thanks to all three for organizing a great session!). Kurt gave a lightning talk on Enthought’s SBIR work. The other talks focused on applications of Python in HPC settings, as well as IPython notebooks on the basics of the Navier-Stokes equations.
It was great to see so much interest in Python for HPC!
Authors: The ETS Developers
We’re happy to announce the release of multiple major projects, including:
- Traits 4.4.0
- Chaco 4.4.1
- TraitsUI 4.4.0
- Envisage 4.4.0
- Pyface 4.4.0
- Codetools 4.2.0
- ETS 4.4.1
These packages form the core of the Enthought Tool Suite (ETS, http://code.enthought.com/projects), a collection of free, open-source components developed by Enthought and our partners to construct custom scientific applications. ETS includes a wide variety of components, including:
an extensible application framework (Envisage)
application building blocks (Traits, TraitsUI, Enaml, Pyface, Codetools)
2-D and 3-D graphics libraries (Chaco, Mayavi, Enable)
scientific and math libraries (Scimath)
developer tools (Apptools)
You can install any of the packages using Canopy‘s package manager, using the Canopy or EPD ‘enpkg \’ command, from PyPI (using pip or easy_install), or by building them from source code on github. For more details, see the ETS intallation page.
This set of releases was an 8-month effort of Enthought developers along with:
- Yves Delley
- Pieter Aarnoutse
- Jordan Ilott
- Matthieu Dartiailh
- Ian Delaney
- Gregor Thalhammer
Many thanks to them!
General release notes
The major new feature in this Traits release is a new adaptation mechanism in the “traits.adaptation“ package. The new mechanism is intended to replace the older traits.protocols package. Code written against “traits.protocols“ will continue to work, although the “traits.protocols“ API has been deprecated, and a warning will be logged on first use of “traits.protocols“. See the ‘Advanced Topics’ section of the user manual for more details.
These new releases of TraitsUI, Envisage, Pyface and Codetools include an update to this new adaptation mechanism.
All ETS projects are now on TravisCI, making it easier to contribute to them.
As of this release, the only Python versions that are actively supported are 2.6 and 2.7. As we are moving to future-proof ETS over the coming months, more code that supported Python 2.5 will be removed.
We will retire firstname.lastname@example.org since it is lightly used and are now recommending all users of Chaco to send questions, requests and comments to email@example.com or to StackOverflow (tag “enthought” and possibly “chaco”).
More details about the release of each project are given below. Please see the CHANGES.txt file inside each project for full details of the changes.
The ETS developers
Traits 4.4.0 release notes
The Traits library enhances Python by adding optional type-checking and an event notification system, making it an ideal platform for writing data-driven applications. It forms the foundation of the Enthought Tool Suite.
In addition to the above-mentioned rework of the adaptation mechanism, the release also includes improved support for using Cython with `HasTraits` classes, some new helper utilities for writing unit tests for Traits events, and a variety of bug fixes, stability enhancements, and internal code improvements.
Chaco 4.4.0 release notes
Chaco is a Python package for building efficient, interactive and custom 2-D plots and visualizations. While Chaco generates attractive static plots, it works particularly well for interactive data visualization and exploration.
This release introduces many improvements and bug fixes, including fixes to the generation of image files from plots, improvements to the ArrayPlotData to change multiple arrays at a time, and improvements to multiple elements of the plots such as tick labels and text overlays.
TraitsUI 4.4.0 release notes
The TraitsUI project contains a toolkit-independent GUI abstraction layer, which is used to support the “visualization” features of the Traits package. TraitsUI allows developers to write against the TraitsUI API (views, items, editors, etc.), and let TraitsUI and the selected toolkit and back-end take care of the details of displaying them.
In addition to the above-mentioned update to the new Traits 4.4.0 adaptation mechanism, there have also been a number of improvements to drag and drop support for the Qt backend and some modernization of the use of WxPython to support Wx 2.9. This release also includes a number of bug-fixes and minor functionality enhancements.
Envisage 4.4.0 release notes
Envisage is a Python-based framework for building extensible applications, providing a standard mechanism for features to be added to an
application, whether by the original developer or by someone else.
In addition to the above-mentioned update to the new Traits 4.4.0 adaptation mechanism, this release also adds a new method to retrieve a service that is required by the application and provides documentation and test updates.
Pyface 4.4.0 release notes
The pyface project provides a toolkit-independent library of Traits-aware widgets and GUI components, which are used to support the “visualization” features of Traits.
The biggest change in this release is support for the new adaptation mechanism in Traits 4.4.0. This release also includes Tasks support for Enaml 0.8 and a number of other minor changes, improvements and bug-fixes.
Codetools release notes
The codetools project includes packages that simplify meta-programming and help the programmer separate data from code in Python. This library provides classes for performing dependency-analysis on blocks of Python code, and Traits-enhanced execution contexts that can be used as execution namespaces.
In addition to the above-mentioned update to the new Traits 4.4.0 adaptation mechanism, this release also includes a number of modernizations of the code base, including the consistent use of absolute imports, and a new execution manager for deferring events from Contexts.