Google App Engine SDK 1.5.2

Google App Engine SDK 1.5.2 is designed as a professional and perfect tool which lets you run your web applications on Google's infrastructure. App Engine applications are easy to build, easy to maintain, and easy to scale as your traffic and data storage needs grow. With App Engine, there are no servers to maintain: You just upload your application, and it's ready to serve your users.

You can serve your app from your own domain name (such as http://www.example.com/) using Google Apps. Or, you can serve your app using a free name on the appspot.com domain. You can share your application with the world, or limit access to members of your organization.

Google App Engine supports apps written in several programming languages. With App Engine's Java runtime environment, you can build your app using standard Java technologies, including the JVM, Java servlets, and the Java programming language—or any other language using a JVM-based interpreter or compiler, such as JavaScript or Ruby. App Engine also features a dedicated Python runtime environment, which includes a fast Python interpreter and the Python standard library, and a Go runtime environment that runs natively compiled Go code. These runtime environments are built to ensure that your application runs quickly, securely, and without interference from other apps on the system.

With App Engine, you only pay for what you use. There are no set-up costs and no recurring fees. The resources your application uses, such as storage and bandwidth, are measured by the gigabyte, and billed at competitive rates. You control the maximum amounts of resources your app can consume, so it always stays within your budget.

App Engine costs nothing to get started. All applications can use up to 1 GB of storage and enough CPU and bandwidth to support an efficient app serving around 5 million page views a month, absolutely free. When you enable billing for your application, your free limits are raised, and you only pay for resources you use above the free levels.

Major Features:

1. Dynamic Web Serving, With Full Support For Common Web Technologies
2. Persistent Storage With Queries, Sorting And Transactions
3. Automatic Scaling And Load Balancing
4. Apis For Authenticating Users And Sending Email Using Google Accounts
5. A Fully Featured Local Development Environment That Simulates Google App Engine On Your Computer
6. Task Queues For Performing Work Outside Of The Scope Of A Web Request
7. Scheduled Tasks For Triggering Events At Specified Times And Regular Intervals

Enhancements: 

• You can now specify the minimum pending latency for instances and the maximum number of idle instances for your application in the Admin Console.
• The datastore now never requires an exploding index. http://code.google.com/appengine/docs/python/datastore/queries.html#Big_Entities_and_Exploding_Indexes
• The SDK will now never suggest indexes with the same property repeated, as such indexes are likely to be exploding indexes.
• The SDK now supports multiple concurrent transactions.
• Datastore stats are now available on a per-namespace basis.
• The queue details page in the Admin Console now contains request header details, previous run information, and a task payload viewer.
• You can modify the lease on a task leased from a pull queue using the modify_task_lease() method.
• Pull Task maximum size has been increased to 1MB.
• You can now update the number of available backend instances without needing to first stop the backend using the "backend configure" appcfg.py directive.
• You can now set the "References" and "In-Reply-To" headers with the Mail API. http://code.google.com/p/googleappengine/issues/detail?id=2802
• The SDK "application" environment variable will now be prefixed with dev~. The new preferred way of retrieving your app id is to use appidentity.get_application_id(). The --default_partition flag can be used for applications whose code relied on a specific environment variable.
• In the Deferred API, defer() now accepts the _target parameter.
• Added a to_dict() function to db.py which converts a model to a dictionary.
• Added a get_original_metadata() method to the Images API to extract EXIF information from images. http://code.google.com/p/googleappengine/issues/detail?id=4133
• Added an @transactional decorator to db.py for functions that should always be run in a transaction.
• Fixed an issue in the SDK where the Deferred API did not work when using the --backends flag. http://code.google.com/p/googleappengine/issues/detail?id=5072