Free python 1.2.2 software for linux

EasyEclipse for Python is for Python development.
This distribution includes the following plugins:
Core components:
- Eclipse Platform 3.2.1 - Shared platform services from Eclipse.
- Eclipse Tools 3.2.1 - Common libraries for various Eclipse projects.
- Java for Windows 1.5.0.09 - Run Java application on Sun Java(tm) runtime, packaged for Eclipse use. (Windows only)
- Java for Linux 1.5.0.09 - Run Java application on Sun Java(tm) runtime, packaged for Eclipse use. (Linux only)
Tools for general Java development:
- Eclipse Java Development Tools 3.2.1 - Edit, compile, run, debug, test, refactor, document and deploy Java applications.
Some essential utilities:
- AnyEdit Tools 1.5.6.2 - Useful right-click menus in editors: "Open file under cursor", "Open type under cursor", et cetera.
- Eclipse Utils Plugins 1.0.0.1 - Save the cursor position of editors when closing and re-opening a file. Access common team actions with explorer buttons.
- Color Editor 1.2.4 - Edit with syntax highlighting over 100+ file formats.
IDE for Python development:
- PyDev 1.2.4 - Edit, run, debug and refactor Python and Jython applications.
Version Control tools (note that CVS support is included in the Eclipse Platform):
- Subclipse 1.1.8 - Access and manage Subversion repositories within Eclipse.

Raptor project is a vertical scrolling shoot-em up game like the original Raptor: Call of the shadows and Tyrian.

Dee-Python project is an implementation of a truly relational database language with Python. Inspired by Date and Darwens Third Manifesto, it addresses the problems of impedance mismatch between programming languages and databases and the weakness of SQL.

Mind The Gap

Most of todays programs handle data in one way or another and often this data is stored in some kind of relational database. To read and modify this data, a program must bridge the gap between its representation and the one used by the dialect of SQL that the database provides. This bridge typically comprises a database API that sends queries as text strings, often accompanied by some kind of table-to-object mapper that has to coerce data and relationships in both directions, usually with elaborate layers of abstraction in an effort to keep the two sides loosely coupled.

"Yet by obscuring the true data source these solutions end up throwing away the most compelling feature of relational databases; the ability for the data to be queried."

Microsoft, DLinq .NET Language-Integrated Query for Relational Data, May 2006.

This approach not only adds complexity and increases the need for data transformations but, most importantly, it destroys the significant advantages provided by the relational model of data. The relational model is built upon predicate logic which brings the power of formal reasoning to data: it is the only sound foundation available.

Gst-Python provides Python bindings for the GStreamer project. These bindings provide access to almost all of the GStreamer C API through an object oriented Python API.

Python OpenID is a set of Python packages that support use of the OpenID decentralized identity system in your applications.
Python OpenID can be used to enable single sign-on for your Web sites or for running an OpenID server. Example code is supplied and a variety of storage back-ends are supported.
Main features:
- Refined and easy-to-use API.
- Extensive documentation.
- Many storage implemetations including file-based, SQL, and memcached.
- Simple examples to help you get started.
- Licensed under the LGPL.
Enhancements:
- This release includes support for Yadis discovery of OpenID servers and OpenID extensions.

python-gammu are Python bindings for Gammu library. It currently does not support all Gammu features, but range of covered functions is increasing, if you need some specific, feel free to use bug tracking system for feature requests.

Python-LDAP provides an object-oriented API to access LDAP directory servers from Python programs. Mainly it wraps the OpenLDAP 2.x libs for that purpose.

Additionally the package contains modules for other LDAP-related stuff (e.g. processing LDIF, LDAPURLs, LDAPv3 schema, etc.).

rope is a Python IDE. Python ropes main goal is to provide features like auto-completion, refactorings, content assistance, and outlines.

Refactoring: In recent years refactoring has become a basic task of everyday programing, specially in java community. In the agile programing methodologies, like Extreme Programing, Refactoring is one of the core practices.
Some IDEs support some basic refactorings like PyDev (which uses bicycle repair man). These IDEs have a limited set of refactorings and fail when doing refactorings that need to know the type of objects in the source code (specially for relatively large projects). rope tries to provide a rich set of refactorings. Some of the refactorings require type inferencing which is described later.
Auto Completion: One of the basic features of modern IDEs is the availability of auto-completion. Some Python IDEs have auto-completion support but in a limited form. Since the type of many variables cannot be deduced from simple analysis of the source code. Auto-completing modules names, class names, static methods, class methods, function names and variable names are easy. But auto-completing the methods and attributes of an object is hard. Because the IDE needs to know the type of the object that cannot be achieved easily most of the time in dynamic languages. rope uses Type Inferencing algorithms to solve this problem.
Type Inferencing: One disadvantage of dynamic languages like python is that you cannot know the type of variables by a simple analysis of program source code most of the time. Knowing the type of variables is very essential for providing many of the refactorings and auto-completions. rope will use type inferencing to overcome this problem.

Static type inferencing uses program source code to guess the type of objects. But type inferencing python programs is very hard. There have been some attempts though not very successful (examples: psycho: only str and int types, StarKiller: wasnt released and ShedSkin: good but limited). They where mostly directed at speeding up python programs by transforming its code to other typed languages rather than building IDEs. Such algorithms might be helpful.

There is another approach toward type inferencing. That is the analysis of running programs. This dynamic approach records the types variables are assigned to during the program execution. Although this approach is a lot easier to implement than the alternative, it is limited. Only the parts of the program that are executed are analyzed. If developers write unit tests and use test driven development this approach works very well.