Python plugin for IDEA has reached an early access preview (EAP) stage. It is alpha-quality software, lacking in many obvious spots, but already allowing to sample some features.

This release concentrates on means for writing code and navigating code.

Things known to work

A module of Python type can be added to a regular IDEA project.

Any reasonable CPython installation can be chosen as project's Python SDK; autodetection works reasonably on Windows, Linux, and Mac OS X.

When Jython code is used in a regular Java-based project, plugin's features kick in.

For Python modules, project window lists your sources and Python's standard libraries, including zips and eggs.

Source code is parsed on the fly and checked for syntax errors. Imports from __future__ are respected for with_statement and nested_scopes .

are respected for and . Ctrl+Click on an identifier leads to the latest definition of this identifier, or first probable out-of-context definition of it. Note that such resolution is not always possible: consider something like foo[i].bar .

. "Find usages" (Alt+F7) works for identifiers, with same limitations as for Ctrl+Click.

Names defined in C-based modules are resolvable as long as the modules are importable.

Classes have usual "inheritors" navigation icons on the gutter.

Methods have usual "overrides" navigation icons on the gutter.

Structure View shows functions, classes, methods, and class variables, with arbitrary nesting.

Names that must definitely resolve but don't are highlighted by an inspection.

Code completion (Ctrl+Space) on a blank space proposes visible identifiers, including imported, with module name as a hint.

Code completion in import statements suggests module names; try typing import th and pressing Ctrl+Space.

and pressing Ctrl+Space. Code completion proposes known items for qualified expressions, including inherited. Try typing "foo".cap and pressing Ctrl+Space.

and pressing Ctrl+Space. Code completion and name resolution also work for attributes dynamically added to an object in immediate scope. Try typing foo = object(); foo.bar = 1; foo.b and pressing Ctrl+Space.

and pressing Ctrl+Space. Quick documentation (Ctrl+Q) for classes shows either doc comment or definition.

Function parameter popup appears on pressing Ctrl+P in argument list, parameters under cursor highlighted. This includes fancier cases of starred and double-starred parameters and arguments, implicit "self", etc.

Pseudo-source is auto-generated for built-in and C-based modules, allowing to navigate to identifiers defined therein.

Rename refactoring (Shift+F6) works reasonably.

A DeMorgan law intention is available for boolean expressions. (Internally it is implemented in Python.)

Function parameters are checked for consistency.

Method parameters are checked for presence of first parameter (the "self").

Where possible, argument lists of function calls are checked against parameter lists of corresponding functions, errors detected. This is an inspection which you can turn off.

Any file from sources can be run, with output going to console, as usual.

Source control must work as for any other IDEA modules.

Things that work only partially

All code is parsed as Python 2.5; version-dependent features are yet to come.

Import statements do not support relative import correctly.

Support for standalone Jython is present but is very limited as of now; Jython installations detection is very limited.

In Structure View, instance variables are not included. The view is not always updated regularly; switch it off and on to refresh.

Keyword completion proposes keywords, but sometimes unsuitable keywords are proposed.

Code navigation does not handle multiple definitions (e.g. when in identifier is defined both in an "if" and in the "else" branches).

Code navigation does not honor class-private names (e.g. __foo ) and the __all__ attribute of modules imported via " from foo import * ", so certain names look more visible than they are.

) and the attribute of modules imported via " ", so certain names look more visible than they are. When an unknown name is found, the choice of possible ways to import it is limited to top-level modules.

Auto-indentation is often incorrect.

Type is inferred only for simplest expressions.

Several special functions from standard library (like super() or dict.fromkeys() ) don't have correct signature.

or ) don't have correct signature. Syntax highlighting is very basic.

Name resolution and completion works somehow for Jython when referencing imported Java objects.

Things that are missing

Decorators are only parsed. They are not included in quick documentation. Their arguments are not correctly checked. The standard @classmethod and @staticmethod decorators are not handled properly.

and decorators are not handled properly. Properties are not detected as properties; assignment to read-only properties is not detected.

Many significant inspections are not implemented yet (unused values, unreachable code, unsafe string handling, definite assignment, endless loops, etc).

There are no significant refactorings yet.

There are no significant quickfixes and intentions yet.

There are no code templates yet.

There is no unit testing support yet.

There is no documentation generators support yet.

There is no support for packaging and deployment yet.

There is no debugger yet.

Please don't hesitate to point us to deficiencies you notice and to suggest features.