First read :pep:`8` (the PEP on how to write readable Python code). The PEP gives

a number of good insights. The PEP gives a few options on things, and I shall

try to clarify what I prefer here. Where this document differs from :pep:`8`, you

should use what is presented here, unless you are a zealot in which case you

should listen to the Python people (who are cleverer than me anyway). Also

read :pep:`20` while you are at it.

4 Spaces, no tabs ever ever. This is not negotiable. Emacs users please check

your settings, somehow tabs creep into emacs-written code.

79 characters, perhaps 78 to be safe. This is negotiable, and there are times

when 83 character lines are acceptable. You can be the judge. I am not sure

many people use 80-character terminals these days, so we can be a bit less

hard-line than the PEP.

You can split lines however you wish. I personally use 3 different forms of

splitting depending on the purpose.

Long lists, dicts, or many paramteres to a function::

    service_base_classes =  [

        OptionsMixin,

        commands_mixin,

        events_mixin,

        bindings_mixin,

    ]

Single extra bit::

    def really_long_method_or_function_name(first_parameter, second_paramater,

        third_parameter)

Or::

    def really_long_method_or_function_name(first_parameter, second_paramater,

                                            third_parameter)

It all depends on the use at the time, and we should remember to keep it

readable.

Meta classes

~~~~~~~~~~~~

Never! I have yet to see a use-case for metaclasses which did not

relate to perverting some other library or external class. I am happy

to be enlightened.

Like any other IDE, PIDA provides in one window all the tools you need to edit your files, compile your programs, invoke external tools, explore a project space or a file hierarchy, and so on.  The PIDA window is organized with a menu, a toolbar, multiple views and a status bar.  Many of these elements are optional and can be hidden or displayed at will.

  This menu offers all file related operations, like creating, saving, or closing a document, but also all version control operations.  PIDA also provides sessions management, and the *File* menu permits to save the current session or load a previous one.

  This menu serves two purposes.  First, it provides facilities to search documents throughout a project, or directories.  But PIDA preferences and shortcuts settings are also modifiable from here.

  This menu provides version control at project level.  From there, it is also possible to modify the properties of a project and to start the configured controllers.

  The PIDA window can be customized from there, displaying or hiding special views or elements like the menu bar or the tool bar.  This menu also provides shortcuts to access quickly the most important views of the window, like the file manager.

The editor is the core element of PIDA.  All other views only provide utilities to fill the missing features of the editor, or integrate important accessories -- like a debugger -- or give a quick access to external tools -- like a terminal.  The editor is also the central view of PIDA.  All other views can be moved around it.

PIDA can support any editor. Editor shortcuts and features directly depend on what editor you prefer. It is possible that some features of the chosen editor and PIDA features overlap. In this case, both can be used, but the feature implemented by PIDA will certainly provide better integration with the other tools of the IDE.

All elements in the PIDA window, except the editor, the menu bar, the toolbar and status bar, can be moved (remember that the menu bar and the toolbar can be hidden though).

  python-gtk2 python-vte python-kiwi python-setuptools python-glade2 librsvg2-common

**Installation is the recommended method of running PIDA.  Running from source should be reserved for people who know what they are doing.**

First copy the file moo_stub.so (that was built in the build stage) from the build/ directory to a directory in your PYTHONPATH or the working directory.

    Running from source is generally reserved for developers of PIDA, or those people who really know what they are doing. It is very useful to be able to make a change and test it immediately. It is not recommended to use this as a general execution method.

   This will handle your Python PATH; it will automatically link all the plugins available in the pida-plugins directory

Some pointers on how to install PIDA dependencies and perform a `Windows Installation`_ can be found on the Trac_.

.. Mac OS X

.. --------

.. FIXME.

Many of the very good IDE's out there are "closed" in the sense that they are limited in terms of extensibility and communication with other tools. Further, many writers and programmers want to change their editor to something else while retaining the features of an IDE.

PIDA was designed with these problems in mind.  PIDA's motto is to reuse the tools that proved to be useful and solid; thus, PIDA provides the glue for them.  PIDA is written in Python_ and uses PyGTK_.  It is easily extensible through plugins and can embed any editor provided someone writes an adapter for it.