Turning Sublime Text Into a Lightweight Python IDE¶

Autocompletion¶

By default, Sublime Text will index symbols in open files and projects, but that doesn’t cover installed python packages that may be part of a non-standard run environment.

There are two to choose from:

1. SublimeCodeIntel offers strong support for multiple languages through it’s own plugin system. It is a bit heavy and requires building an index.
2. SublimeJedi only supports Python, but is faster and keeps an index on its own.

I’ve installed SublimeJedi, and used the following settings per project to ensure that all relevant code is found:

{
    "folders":
    [
        // ...
    ],

    "settings": {
        // ...
        "python_interpreter_path": "/Users/cewing/pythons/python-2.7/bin/python",

        "python_package_paths": [
            "/path/to/project/buildout/parts/omelette"
        ]
    }
}

The python_interpreter_path allows me to indicate which Python executable should be introspected for symbol definitions.

The python_package_paths setting allows designating additional paths that will be searched for Python packages containing symbols.

Once configured, you should be able to use the ctrl-shift-G keyboard shortcut to jump directly to the definition of a symbol. You can also use alt-shift-F to find other usages of the same symbol elsewhere in your code.

Code Linting¶

Code linting shows you mistakes you’ve made in your source before you attempt to run the code. This saves time. Sublime Text has an available plugin for code linters called SublimeLinter.

Python has a couple of great tools available for linting, the pep8 and pyflakes packages. Pep8 checks for style violations, lines too long, extra spaces and so on. Pyflakes checks for syntactic violations, like using a symbol that isn’t defined or importing a symbol you don’t use.

Another Python linting package, flake8 combines these two, and adds in mccabe, a tool to check the cyclomatic complexity of code you write. This can be of great help in discovering methods and functions that could be simplified and thus made easier to understand and more testable.

There is a nice plugin for the SublimeLinter that utilizes flake8. For it to work, the plugin will need to have a Python executable that has the Python tools it needs installed.

Make sure that the python packages you need are installed in your main python install, rather than a virtualenv.

Use Python packaging tools to install the required packages:

$ pip install flake8
Downloading/unpacking flake8
[...]
Downloading/unpacking pyflakes>=0.7.3 (from flake8)
[...]
Downloading/unpacking pep8>=1.4.6 (from flake8)
[...]
Downloading/unpacking mccabe>=0.2.1 (from flake8)
[...]
Installing collected packages: flake8, pyflakes, pep8, mccabe
[...]
Successfully installed flake8 pyflakes pep8 mccabe
Cleaning up...
$

Your Python install now has the required packages installed.

try typeing these command to make sure:

$ flake8
Usage: flake8 [options] input ...

flake8: error: input not specified

Now install SublimeLinter and then SublimeLinter-flake8 using Package Control.

Here are the settings you can add to Preferences -> Package Settings -> SublimeLinter -> Settings - User:

{
    //...
    "linters": {
        "flake8": {
            "@disable": false,
            "args": [],
            "builtins": "",
            "excludes": [],
            "ignore": "",
            "max-complexity": 10,
            "max-line-length": null,
            "select": ""
        }
    },
    //...
    "paths": {
        "linux": [],
        "osx": [
            "/Users/cewing/virtualenvs/sublenv/bin"
        ],
        "windows": []
    },
    "python_paths": {
        "linux": [],
        "osx": [
            "/Users/cewing/virtualenvs/sublenv/bin"
        ],
        "windows": []
    },
    //...
}

The paths key points to the path that contains the flake8 executable command.

The python_paths key points to the location of the python executable to be used.

The settings inside the flake8 object control the performance of the linter. Read more about them here.

White Space Management¶

One of the issues highlighted by flake8 is trailing spaces. Sublime text provides a setting that allows you to remove them every time you save a file:

source

{
    "trim_trailing_whitespace_on_save": true
}

Do not use this setting

Removing trailing whitespace by default causes a ton of noise in commits.

Keep commits for stylistic cleanup separate from those that make important changes to code.

The TrailingSpaces SublimeText plugin can help with this.

Here are the settings you can use:

{
    //...
    "trailing_spaces_modified_lines_only": true,
    "trailing_spaces_trim_on_save": true,
    // ...
}

This allows trimming whitespace on save, but only on lines you have directly modified. You can still trim all whitespace manually and keep changesets free of noise.

Follow-Along¶

The final requirement for a reasonable IDE experience is to be able to follow a debugging session in the file where the code exists.

There is no plugin for SublimeText that supports this. But there is a Python package you can install into the virtualenv for each of your projects that does it.

The package is called PDBSublimeTextSupport and its simple to install with pip:

(projectenv)$ pip install PDBSublimeTextSupport

With that package installed in the Python that is used for your project, any breakpoint you set will automatically pop to the surface in SublimeText. And as you step through the code, you will see the current line in your Sublime Text file move along with you.