Category Archives: releases

Spring Python 1.1.0 released

The final release of Spring Python 1.1.0 is out. Spring Python takes the concepts of Spring and applies them to the Python. This includes functionality like dependency injection, aspect oriented programming, data access, transaction management, security, remoting, and even python-to-java-to-python communication through JMS.

Spring Python has been growing since 2006 and was the first Spring Extension to go live. The project thrives with community involvement. The biggest thanks go to our fellow committers: Dariusz Suchojad and Sven Wilhelm. You can also follow postings at http://twitter.com/springpython.

There is also a Spring Python 1.1 book to help both Java and Python coders alike come to grips with the functionality offered by Spring Python. It covers all the major functional pieces of Spring Python (except the JMS part which is very new) and includes two case studies with lots of code and high level diagrams.

The following is a list of issues worked during this major release:

Bug

Improvement

New Feature

Refactoring

Spring Python 1.1.0.RC1 released

See http://www.springsource.org/node/2490 for the official notice.

Spring Python takes the concepts of the Spring Framework and applies them to Python. This includes features like dependency injection, aop, remoting, data access, transactions, and security, all with a non-invasiveness style.

This is the first release candidate for version 1.1. We are quickly approaching final release. You can read more detail with the online documentation (see official notice for more links, as well as the sidebars of this blog). You can also pre-order your copy of the Spring Python 1.1 from Packt Publishing, due for release in June 2010.

Improvement

  • [SESPRINGPYTHONPY-136] – Stop using Amazon’s S3 browse site, and replace it with SpringSource’s

Spring Python 1.1.0.M2 is released

See http://www.springsource.org/node/2489 for the official notice.

Spring Python takes the concepts of the Spring Framework and applies them to Python. This includes features like dependency injection, aop, remoting, data access, transactions, and security, all with a non-invasiveness style.

This is the last planned milestone for version 1.1. We are quickly approaching final release. You can read more detail with the online documentation (see official notice for more links, as well as the sidebars of this blog). You can also pre-order your copy of the Spring Python 1.1 from Packt Publishing, due for release in June 2010.

Release Notes

Bug

Improvement

New Feature

Refactoring

Spring Python 1.1.0.M1 Released

See http://www.springsource.org/node/2282 for the official announcement.

I chatted with Mark Pollack earlier this week and asked if we wouldn’t mind me taking over. He said no problem, and I was able to get keys later to push releases up to SpringSource’s S3 site.

This release is first milestone in our new 1.1 baseline. More features, improvements, and enhancements will be coming out with the next milestone, as we work towards getting this released.

Spring Python makes final 1.0.0 release

Please read the official press release from SpringSource about this historic release of Spring Python. Please visit http://www.springsource.com/download/community in order to download a copy. NOTE: Spring Python has now been relocated to the top level, instead of being inside EXT.

  • It’s the first Spring Extension to reach live status and also progress to a stable 1.0.0 final release.
  • The trunk has been updated to allow work on next major release 1.1 to begin. This means we aren’t through, but just getting started.
  • Another branch has been created to support backporting critical fixes into the 1.0 baseline, meaning it will have the same type of strong support as other SpringSource projects.

This demonstrates that Spring Python has a nicely honed development process, committed to providing stable APIs, while also focusing on new and innovative changes. While we have worked hard since the start of this project back in 2006, we still lots of ideas and have plenty more work to do.

I wish to thank Mark Pollack, the current sponsor of Spring Python and code geek that developed Spring .NET, for coming on board quickly, and supporting me in every way possible to get this release wrapped up and pushed out for everyone to use. I also want to thank Russ Miles, former SpringSource consultant, who has supported me for over the past year with encouragement and feedback. I also thank the community for its valuable comments, questions, and suggestions that has helped steer this project in a positive direction.

Key changes used to this release include:

Improvement

  • [SESPRINGPYTHONPY-96] – When making builds, use “.” as separator between version and tag; support python 2.4/2.5/2.6

Task

  • [SESPRINGPYTHONPY-56] – Assess impact of python’s deprecation of md5 and sha modules to spring python’s security segment

Spring Python 1.0.0 (RC2) is released

What is Spring Python?

For those of you new to this project, Spring Python takes the concepts implemented by the Spring Framework (Java), and applies them to Python. This provides a powerful library of functionality to help you get back to writing the code that makes you money. You can visit Spring Python’s official web page, or skip right to the downloads.

You’re Late!

Yes, we’re a tad late. Okay, we’re really late, but in case you fell off the planet, SpringSource lost a valuable member of its team, Russ Miles, who was also the sponsor for this project. There were other high priority things happening, so considering this is an extension, it took a little longer than usual to get to making a release. Which brings me to my next point. I want to welcome Mark Pollack as the new sponsor for this extension. He is the code geek that developed Spring .NET. I have had the benefit of meeting him at least year’s SpringOne Americas conference and attending his presentation, and we have also corresponded over email and IM.

So what’s in this release?

You can scroll down to see the release notes. There actually isn’t much change in the code. We are trying to freeze things into a stable API. However, one thing not listed was a key problem we had to solve with coily. coily is the command-line tool that let’s you download Spring Python plugins. Coily was having trouble handling data hosted on the S3 servers used to stage these downloads, so I had to fix it. It now offers you the correct name.

When you query this version to see what plugins are available, you should see this:

$ ./coily --list-available-plugins
Coily v1.0.0 - the command-line management tool for Spring Python
===============================================================================
Copyright 2006-2008 SpringSource (http://springsource.com), All Rights Reserved
Licensed under the Apache License, Version 2.0

Available plugins:
gen-cherrypy-app springpython-plugin-gen-cherrypy-app-1.0.0-RC1.tar.gz 2009-01-22 18:08
gen-cherrypy-app springpython-plugin-gen-cherrypy-app-1.0.0-RC2.tar.gz 2009-06-03 18:23

You may be seeing two copies listed here, but when you try to install, it will grab RC2’s version.

Release Notes

Release Notes – SX Spring Python – Version 1.0.0-RC2

Improvement

Task

What is coming next?

Well, I have been in contact with a company in Germany that is using Spring Python as a key piece of their software solution. They have even granted me access to view their code base. It is exciting seeing them in action, especially since they are writing some extensions to Spring Python and also experimenting with using it inside Jython.

What does this boil down to? Community feedback is a key ingredient to finding out what features need to be added, modified and improved.  Through IM and email, we have already identified some mods to DatabaseTemplate supporting convention-over-configuration, and have already coded a SimpleRowMapper. If your POPO’s attributes match the column names of a query, you don’t need to create a custom RowMapper. Instead, plug-in this one, and it will link them together, without requiring you to extend any of Spring Python’s classes.

self.databaseTemplate.query(
"select name, category from animal",
rowhandler=SimpleRowMapper(testSupportClasses.Animal))

SimpleRowMapper only needs a class name. It will instantiate one of these classes for each row, and then populates the name and category attributes with the results of the query.

There is also a DictionaryRowMapper, which returns a list of dictionaries, instead of tuples. The key point is that convention-over-configuration has become an accepted way to rapidly write essential code without getting caught up the details, and Spring Python embraces this concept.

There is just one wrinkle to make this work: the API used in RowMapper has a slight change (we added metadata as an optional attribute). Since 1.0 is a frozen API, and we are trying to get to a final release, Sven and I agreed to put this change into Spring Python v1.1, so for now, you can only get it from our source repository. Stay tuned for updates!

Spring Python 1.0.0 (RC1) is finally here!

This is an exciting day. The first, production-ready version of Spring Python is finally here. Version 1.0.0-RC1 is out. You can download from the official site, but if you are having trouble, you can go directly to S3, and grab 1.0.0-RC1. Please visit the official website at http://springpython.webfactional.com, where you will find links to up-to-date documentation, support options, and anything else you might need. Please click here to check for any dependencies you may be missing, so you can in turn download and install them.

Be sure to grab:

  • springpython-1.0.0-RC1.tar.gz
  • springpython-samples-1.0.0-RC1.tar.gz

You DON’T have to install the springpython-gen-cherrypy-plugins!!! See later section for the reason why.

What is Spring Python?

For those of you new to this project, Spring Python takes the concepts implemented by the Spring Framework (Java), and applies them to Python. This provides a powerful library of functionality to help you get back to writing the code that makes you money.

A little history

I have been working since October 2006 on this project, and it feels good to make this release. What do we mean by “production-ready?” The APIs are frozen until the next major release, so you have a stable platform to work against. This is a Release Candidate, meaning if there are critical errors, please report them so we can fix and release, until we reach general availability (GA).

I want to personally thank the many people who have helped make this release possible, including: Russ Miles, Sylvain Hellegouarch, and Dennis Mendelson. Also, a big thanks to SpringSource for hosting this project. And I also want to thank the Spring Python community that has posted questions, comments, patches, and ideas. BTW, Uche, your amara toolkit really saved the day in XML parsing!

Release Notes

Release Notes – Spring Python – Version 1.0.0-RC1

** Bug
* [SESPRINGPYTHONPY-87] – Fix object.html documentation to use proper import for ApplicationContext
* [SESPRINGPYTHONPY-88] – Fix PyroServiceExporter so that it has configurable host/port settings (w/defaults)

** Improvement

* [SESPRINGPYTHONPY-62] – Add XML configuration documentation to reference documents.
* [SESPRINGPYTHONPY-84] – Generate digital signatures for uploaded items automatically
* [SESPRINGPYTHONPY-89] – Repair springpython.context.ObjectPostProcessor to work more like BeanPostProcessor

** New Feature
* [SESPRINGPYTHONPY-83] – Create a command-line utility with a plug-in system that can perform useful tasks

Spring Python has a command-line tool with plugins!

While we have been working on many key features over the life cycle of this project, the biggest feature in this release is our command-line/plug-in system. During the SpringOne Americas conference, I was blown away by Graeme Rocher’s demo of Grails, where he built a twitter clone app in 40 minutes. A key part was his command-line grails tool.

Before I left that presentation, my mind was already racing in how to build a similar tool to help Spring Python developers. I realized I needed a pluggable solution, so that many different plugins could be created, whether by me or the community. During a few of the other presentations I attended, I was coding a simple solution that would support version control of plugins, being able to download and install from an official source, having some command-line help, and being able to install/uninstall/reinstall. To go along with this, I cooked up one plugin, gen-cherrpy-app, that creates a skeleton CherryPy web application with an IoC container configured with basic components, including security.

To use this tool, just download and install the main Spring Python package. After installing, you should find coily installed on your path. To get started, see what coily has to offer.

% coily --help

You should get something like this:

Coily - the command-line management tool for Spring Python
==========================================================
Copyright 2006-2008 SpringSource (http://springsource.com), All Rights Reserved
Licensed under the Apache License, Version 2.0

Usage: coily [command]

--help print this help message
--list-installed-plugins list currently installed plugins
--list-available-plugins list plugins available for download
--install-plugin [name] install coily plugin
--uninstall-plugin [name] uninstall coily plugin

--reinstall-plugin [name] reinstall coily plugin

coily will create a local ~/.springpython directory, which contains all installed plugins, on a per-user basis. Currently, there is one official plugin which is used to help you create a CherryPy application. However, the opportunities are endless. Grails has plugins to create apps, modify existing apps, and so on. We can grow in a similar fashion.

Remember when I said you don’t have to install springpython-gen-cherrypy-app? Guess what. coily will grab it for you. You don’t have to install all the plugins. You can pick and choose what you want. At this stage, we don’t have an upgrade feature. But if you reinstall, it should do the trick.

Plugin Explosion

One issue Grails is having to deal with is their explosion of plugins. They have a lot, and only a subset are managed by the core Grails team. Others were developed by the community. This is definitely a good thing, because it reflects widespread adoption of Grails. However, anyone new to the project cannot discern the status of each plugin, and be able to decipher the stable ones from the bleeding edge ones. This is where Spring Extensions comes into play!

Spring Extensions is the official incubator process SpringSource has developed to manage new software development. Each extension has its own life cycle, forum, and tracked issues. Spring Python is an extension, and currently it contains one plugin. New plugins can fit into one of three possibilities:

  • Become an official part of Spring Python, meaning it is managed by the Spring Python team.
  • Become a separate, official Spring Extension, meaning it is not part of the official Spring Python release, but instead, has its own life cycle of releases, and potentially different leader and team.
  • Be managed outside the entire SpringSource system.

All three of these choices are good. They each offer a way to extend Spring Python in a usable way. Maybe you want to start an extension, but want to tip toe a little before diving in. Great! That is how lots of open source projects start. Later on, perhaps your plugin is becoming popular, and you would like to make it more official. A Spring Extension gets branded as officially supported by SpringSource. The amount of support varies, meaning as a minimum you get access to tools and some web space. Perhaps someday, if it becomes really popular, it can potentially join the SpringSource software portfolio. Or…not. No promises are made!

What else have you got?

Enough about plugins. What else is there, you ask?

  • Inversion of Control – a container which supports several formats, allows you to wire your python application together simply and effectively.
  • Aspect Oriented Programming – add extra services to existing code without changing APIs.
  • Data Access – DatabaseTemplate is a very useful abstraction to make writing database calls easier. This isn’t an ORM, but makes it easy to write pure SQL operations.
  • Transaction Management – while database calls are useful for any small, medium, or large application, transactions are the bread and butter of enterprise apps. This makes it easy to wrap business logic in transactions, whether or not it is the data access layer.
  • Security – using AOP, this is another powerful layer to add on. It is based on the architecture of Spring Security, meaning it is just as flexible and powerful, whether you are building a web app or a desktop client.
  • Remoting – RPCs are the building blocks for distributed apps. Most enterprise apps need to grow beyond the limits of a single server at some stage.

Each of these features, when orchestrated together, makes it easy to build enterprise-grade applications. IoC provides the indirection that allows you to convert a simple, one-machine, client-server app into a multi-node, security layered, scaled application with transactional protection. And everything is POPO-based.

What are POPOs?

Spring Java works hard to make sure it support POJO-based solutions. POJOs are plain old java objects. The idea is you don’t have to extend the frameworks classes. Instead, you can retool code you already wrote with minimal effort. Spring Python takes this same concept to Python by using POPOs, or plain old Python objects.

There are useful utility classes you can extend, but you don’t have to in order to use this collection of libraries. And that’s the point! You only use what you need, when you need it. The choice is yours.

Join us at LinkedIn

Please come and join us at the Spring Python group on LinkedIn.

What else is coming?

Whew! It has been some hard work to get to here. But by no means are we done. There is plenty more to do to make Spring Python better. A lot of the work done has been foundational.

Spring Python’s security module has a strong architecture in place. Now, we can start coding authentication providers to support things like LDAP, X.509, SecurId, two-factor authentication. Plenty of places to go there!

Remoting currently supports Pyro (Python Remote Objects) and some basic Hesssian. But there are many other remoting protocols. We have the foundation in place to code more service exporters in order to integrate with other technologies.

There are plenty of places to go from here. And we aren’t slowing down!

Spring Python 0.9.1 has been released

Spring Python is not a web framework, but instead a library of tools that can empower any python application, whether web-based, desktop, or server side utility. For more details, read the list of features below and visit the website at http://springpython.webfactional.com.

I just released Spring Python 0.9.1. One of our users spotted an error in the IoC container involving constructor arguments, and I was able to reproduce the problem, patch it, and get it released quickly to the user community. You can download it right now.

I cannot emphasize enough how valuable community feedback is to the success of this project. If you are having issues, please post an email to the list, or start a thread at the community forum, and we will examine the situation.

Also note, the web site has been updated, which includes a link to API documentation, generated by pydoc.

==============================

Release Notes – Spring Python – Version 0.9.1

Bug

  • [SESPRINGPYTHONPY-86] – XMLConfig doesn’t properly lookup constructor-arg’s, but instead returns ReferenceDef objects

Improvement

  • [SESPRINGPYTHONPY-85] – Add pydoc to website, allowing display of APIs as more documentation

===============================

Key Features of Spring Python include:

* Inversion Of Control – wire your application together using a lightweight set of blueprints. You can use several formats including a pure python code-based configuration.

* Aspect-oriented Programming – Spring Python provides great ways to wrap advice around objects, making it easy to write your own aspects. It is also utilized in other parts of Spring Python including security, transactions, and remoting.

* DatabaseTemplate – Reading from the database requires a monotonous cycle of opening cursors, reading rows, and closing cursors, along with proper exception handling. With this template class, all you need is the SQL query and a row-handling function. Spring Python does the rest.

* Database Transactions – Wrapping multiple database calls with transactions can make your code hard to read. This module provides multiple ways to define transactions without making things complicated.

* Security – Plugin security interceptors to lock down access to your methods, utilizing both authentication and domain authorization.

* Remoting – It is easy to convert your local application into a distributed one. If you have already built your client and server pieces using the IoC container, then going from local to distributed is just a configuration change.

* Samples – to help demonstrate various features of Spring Python, some sample applications have been created:

o PetClinic – Everybody’s favorite Spring sample application has been rebuilt from the ground up using various web containers including: CherryPy. Go check it out for an example of how to use this framework.

o Spring Wiki – Wikis are powerful ways to store and manage content, so we created a simple one as a demo!

o Spring Bot – Use Spring Python to build a tiny bot to manage the IRC channel of your open source project.

Spring Python 0.9.0 is released

Spring Python is not a web framework, but instead a library of tools that can empower any python application, whether web-based, desktop, or server side utility. For more details, read the list of features below and visit the website at http://springpython.webfactional.com.

Spring Python has just released 0.9.0. This release includes a key update to springpython.security.web module, where authorization has been patched to support CherryPy 3.1. Sylvain helped by providing key patches to integrate Spring Wiki with CherryPy 3.1, and I adapted these to support the PetClinic app. This valuable feature will help demonstrate all the various features of Spring Python during the “Introduction to Spring Python” demo scheduled later this week during the SpringOne conference.
===============================
Release Notes – Spring Python – Version 0.9

Bug

Task

===============================
Links:

* For more information, please visit the website at http://springpython.webfactional.com.

* To download the 0.9.0 release, or an archived release, and for access to sample applications use http://www.springsource.com/download/community?project=Spring%20Extensions

Key Features of Spring Python include:

* Inversion Of Control – The idea is to decouple two classes at the interface level. This lets you build many reusable parts in your software, and your whole application becomes more pluggable. You can use either the XmlApplicationContext or the DecoratorBasedApplicationContext.

* Aspect-oriented Programming – Spring Python provides great ways to wrap advice around objects. It is utilized for remoting. Another use is for debug tracers and performance tracing.

* DatabaseTemplate – Reading from the database requires a monotonous cycle of opening cursors, reading rows, and closing cursors, along with exception handlers. With this template class, all you need is the SQL query and row-handling function. Spring Python does the rest.

* Database Transactions – Wrapping multiple database calls with transactions can make your code hard to read. This module provides multiple ways to define transactions without making things complicated.

* Security – Plugin security interceptors to lock down access to your methods, utilizing both authentication and domain authorization.

* Remoting – It is easy to convert your local application into a distributed one. If you have already built your client and server pieces using the IoC container, then going from local to distributed is just a configuration change.

* Samples – to help demonstrate various features of Spring Python, some sample applications have been created:
o PetClinic – Everybody’s favorite Spring sample application has been rebuilt from the ground up using various web containers including: CherryPy. Go check it out for an example of how to use this framework.

o Spring Wiki – Wikis are powerful ways to store and manage content, so we created a simple one as a demo!
o Spring Bot – Use Spring Python to build a tiny bot to manage the IRC channel of your open source project.

Spring Python uses Amara

Link: http://broadcast.oreilly.com/2008/11/spring-python-and-amara.html

For now, we are using Amara 1.2 because we need stable support. We definitely hope to migrate to 2.x someday, and we will have to deal with that python2.5+ requirement. This may require two versions of Spring Python. Supporting Python 2.4, 2.5, 2.6, 3+ all have impact on what we will support. There is always the pressure to upgrade, update, and get to the latest. But community support for older versions, especially big enterprises, has always been a strong point of Spring, so we won’t jump as quickly as some may want us to. Community needs will play a key role in this decision, and how many versions we support.