Configure Interpreter

The System libs must contain at least the Lib and the Lib/site-packages directory.

The Forced builtin libs must contain the modules built into the interpreter (and others whose analysis should be done dynamically. See: Forced Builtins).

The System libs are the libraries that will be added to the PYTHONPATH of any project that is using this interpreter.

For Python and IronPython, it's composed of folders, zip files and egg files. Note that if dlls should be added to the PYTHONPATH, the folders actually containing those dlls should be added, and they must have the same name to be imported in the code (the case is important). I.e.: if you want to import iTextDll, it must be called iTextDll.dll (note that .pyd and .so extensions are also accepted).

For Jython, it's composed of folders and jars.

The Forced builtin libs are the libraries that are built-in the interpreter, such as __builtin__, sha, etc or libraries that should forcefully analyzed through a shell (i.e.: to analyze modules in this list, PyDev will spawn a shell and do a dir() on the module to get the available tokens for completions and code-analysis) -- still, sometimes even that is not always possible, in which case, Predefined Completions may be used to let PyDev know about the structure of the code.

For Python, you should have around 50 entries

For Jython around 30 entries.

For IronPython more than 100 entries. All the packages built into .NET should be included here -- e.g.: Microsoft, Microsoft.Windows.Themes, System, System.IO, etc.

Additionally, you may add other libraries that you want to treat as builtins, such as os, wxPython, OpenGL, etc. This is very important, because PyDev works on the java side only with static information, but some modules don't have much information when analyzed statically, so, PyDev creates a shell to get information on those. Another important thing is that they must be on your system pythonpath (otherwise, the shell will be unable to get that information).

Predefined completions are completions acquired from sources that provide only the interfaces for a given Python module (with Python 3.0 syntax).

A predefined completion module may be created by having a module with the extension ".pypredef" with regular Python 3.0 contents, but with attributes having assigns to its type and methods having as the body a sole return statement -- and the docstring may have anything.

Example for a my.source.module (must be declared in a my.source.module.pypredef file):

MyConstantA = int
MyConstantB = int

class MyClass:

    instanceAttribute = QObject

    def __init__(self, parent=None):
        '''

        @type parent: QObject
        '''

    def registerTimer(interval, object):
        '''

        @type interval: int
        @type object: QObject
        '''
        return int

Note 1: the name of the file is the exact name of the module

Note 2: .pypredef files are not searched in subfolders

Optionally a QScintilla .api file may be added. When this is done, PyDev will try to create .pypredef files from that .api file and will add the folder containing those to the PYTHONPATH. Note that this conversion is still in beta and the file may not be correctly generated, so, keep an eye for errors logged when a code-completion that would use those modules (while it will not fail, those completions won't be shown using the .pypredef files). In those situations, please create a bug-report with the .api file that generated incorrect code.

Strings defined here may be used in:

• project configuration for source folders and external libraries
• launch configuration for the main module

They can be used in those places in the format: ${DECLARED_VARIABLE}