;;; python.el --- Python's flying circus support for Emacs

;; Copyright (C) 2003-2012 Free Software Foundation, Inc.

;; Author: Fabián E. Gallina <[email protected]>

;; URL: https://github.com/fgallina/python.el

;; Version: 0.24.2

;; Maintainer: FSF

;; Created: Jul 2010

;; Keywords: languages

;; This file is part of GNU Emacs.

;; GNU Emacs is free software: you can redistribute it and/or modify

;; it under the terms of the GNU General Public License as published

;; by the Free Software Foundation, either version 3 of the License,

;; or (at your option) any later version.

;; GNU Emacs is distributed in the hope that it will be useful, but

;; WITHOUT ANY WARRANTY; without even the implied warranty of

;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

;; General Public License for more details.

;; You should have received a copy of the GNU General Public License

;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;; Major mode for editing Python files with some fontification and

;; indentation bits extracted from original Dave Love's python.el

;; found in GNU/Emacs.

;; Implements Syntax highlighting, Indentation, Movement, Shell

;; interaction, Shell completion, Shell virtualenv support, Pdb

;; tracking, Symbol completion, Skeletons, FFAP, Code Check, Eldoc,

;; Imenu.

;; Syntax highlighting: Fontification of code is provided and supports

;; python's triple quoted strings properly.

;; Indentation: Automatic indentation with indentation cycling is

;; provided, it allows you to navigate different available levels of

;; indentation by hitting <tab> several times. Also when inserting a

;; colon the `python-indent-electric-colon' command is invoked and

;; causes the current line to be dedented automatically if needed.

;; Movement: `beginning-of-defun' and `end-of-defun' functions are

;; properly implemented. There are also specialized

;; `forward-sentence' and `backward-sentence' replacements called

;; `python-nav-forward-block', `python-nav-backward-block'

;; respectively which navigate between beginning of blocks of code.

;; Extra functions `python-nav-forward-statement',

;; `python-nav-backward-statement',

;; `python-nav-beginning-of-statement', `python-nav-end-of-statement',

;; `python-nav-beginning-of-block' and `python-nav-end-of-block' are

;; included but no bound to any key. At last but not least the

;; specialized `python-nav-forward-sexp' allows easy

;; navigation between code blocks.

;; Shell interaction: is provided and allows you to execute easily any

;; block of code of your current buffer in an inferior Python process.

;; Shell completion: hitting tab will try to complete the current

;; word. Shell completion is implemented in a manner that if you

;; change the `python-shell-interpreter' to any other (for example

;; IPython) it should be easy to integrate another way to calculate

;; completions. You just need to specify your custom

;; `python-shell-completion-setup-code' and

;; `python-shell-completion-string-code'.

;; Here is a complete example of the settings you would use for

;; iPython 0.11:

;; (setq

;; python-shell-interpreter "ipython"

;; python-shell-interpreter-args ""

;; python-shell-prompt-regexp "In \\[[0-9]+\\]: "

;; python-shell-prompt-output-regexp "Out\\[[0-9]+\\]: "

;; python-shell-completion-setup-code

;; "from IPython.core.completerlib import module_completion"

;; python-shell-completion-module-string-code

;; "';'.join(module_completion('''%s'''))\n"

;; python-shell-completion-string-code

;; "';'.join(get_ipython().Completer.all_completions('''%s'''))\n")

;; For iPython 0.10 everything would be the same except for

;; `python-shell-completion-string-code' and

;; `python-shell-completion-module-string-code':

;; (setq python-shell-completion-string-code

;; "';'.join(__IP.complete('''%s'''))\n"

;; python-shell-completion-module-string-code "")

;; Unfortunately running iPython on Windows needs some more tweaking.

;; The way you must set `python-shell-interpreter' and

;; `python-shell-interpreter-args' is as follows:

;; (setq

;; python-shell-interpreter "C:\\Python27\\python.exe"

;; python-shell-interpreter-args

;; "-i C:\\Python27\\Scripts\\ipython-script.py")

;; That will spawn the iPython process correctly (Of course you need

;; to modify the paths according to your system).

;; Please note that the default completion system depends on the

;; readline module, so if you are using some Operating System that

;; bundles Python without it (like Windows) just install the

;; pyreadline from http://ipython.scipy.org/moin/PyReadline/Intro and

;; you should be good to go.

;; Shell virtualenv support: The shell also contains support for

;; virtualenvs and other special environment modifications thanks to

;; `python-shell-process-environment' and `python-shell-exec-path'.

;; These two variables allows you to modify execution paths and

;; environment variables to make easy for you to setup virtualenv rules

;; or behavior modifications when running shells. Here is an example

;; of how to make shell processes to be run using the /path/to/env/

;; virtualenv:

;; (setq python-shell-process-environment

;; (list

;; (format "PATH=%s" (mapconcat

;; 'identity

;; (reverse

;; (cons (getenv "PATH")

;; '("/path/to/env/bin/")))

;; ":"))

;; "VIRTUAL_ENV=/path/to/env/"))

;; (python-shell-exec-path . ("/path/to/env/bin/"))

;; Since the above is cumbersome and can be programmatically

;; calculated, the variable `python-shell-virtualenv-path' is

;; provided. When this variable is set with the path of the

;; virtualenv to use, `process-environment' and `exec-path' get proper

;; values in order to run shells inside the specified virtualenv. So

;; the following will achieve the same as the previous example:

;; (setq python-shell-virtualenv-path "/path/to/env/")

;; Also the `python-shell-extra-pythonpaths' variable have been

;; introduced as simple way of adding paths to the PYTHONPATH without

;; affecting existing values.

;; Pdb tracking: when you execute a block of code that contains some

;; call to pdb (or ipdb) it will prompt the block of code and will

;; follow the execution of pdb marking the current line with an arrow.

;; Symbol completion: you can complete the symbol at point. It uses

;; the shell completion in background so you should run

;; `python-shell-send-buffer' from time to time to get better results.

;; Skeletons: 6 skeletons are provided for simple inserting of class,

;; def, for, if, try and while. These skeletons are integrated with

;; dabbrev. If you have `dabbrev-mode' activated and

;; `python-skeleton-autoinsert' is set to t, then whenever you type

;; the name of any of those defined and hit SPC, they will be

;; automatically expanded.

;; FFAP: You can find the filename for a given module when using ffap

;; out of the box. This feature needs an inferior python shell

;; running.

;; Code check: Check the current file for errors with `python-check'

;; using the program defined in `python-check-command'.

;; Eldoc: returns documentation for object at point by using the

;; inferior python subprocess to inspect its documentation. As you

;; might guessed you should run `python-shell-send-buffer' from time

;; to time to get better results too.

;; Imenu: This mode supports Imenu in its most basic form, letting it

;; build the necessary alist via `imenu-default-create-index-function'

;; by having set `imenu-extract-index-name-function' to

;; `python-info-current-defun' and

;; `imenu-prev-index-position-function' to

;; `python-imenu-prev-index-position'.

;; If you used python-mode.el you probably will miss auto-indentation

;; when inserting newlines. To achieve the same behavior you have

;; two options:

;; 1) Use GNU/Emacs' standard binding for `newline-and-indent': C-j.

;; 2) Add the following hook in your .emacs:

;; (add-hook 'python-mode-hook

;; #'(lambda ()

;; (define-key python-mode-map "\C-m" 'newline-and-indent)))

;; I'd recommend the first one since you'll get the same behavior for

;; all modes out-of-the-box.

;;; Installation:

;; Add this to your .emacs:

;; (add-to-list 'load-path "/folder/containing/file")

;; (require 'python)

;;; TODO:

;;; Code:

(require 'ansi-color)

(require 'comint)

;; Avoid compiler warnings

(defvar view-return-to-alist)

(defvar compilation-error-regexp-alist)

(defvar outline-heading-end-regexp)

(autoload 'comint-mode "comint")

;;;###autoload

(add-to-list 'auto-mode-alist (cons (purecopy "\\.py\\'") 'python-mode))

;;;###autoload

(add-to-list 'interpreter-mode-alist (cons (purecopy "python") 'python-mode))

(defgroup python nil

"Python Language's flying circus support for Emacs."

:group 'languages

:version "23.2"

:link '(emacs-commentary-link "python"))



;;; Bindings

(defvar python-mode-map

(let ((map (make-sparse-keymap)))

;; Movement

(define-key map [remap backward-sentence] 'python-nav-backward-block)

(define-key map [remap forward-sentence] 'python-nav-forward-block)

(define-key map [remap backward-up-list] 'python-nav-backward-up-list)

(define-key map "\C-c\C-j" 'imenu)

;; Indent specific

(define-key map "\177" 'python-indent-dedent-line-backspace)

(define-key map (kbd "<backtab>") 'python-indent-dedent-line)

(define-key map "\C-c<" 'python-indent-shift-left)

(define-key map "\C-c>" 'python-indent-shift-right)

(define-key map ":" 'python-indent-electric-colon)

;; Skeletons

(define-key map "\C-c\C-tc" 'python-skeleton-class)

(define-key map "\C-c\C-td" 'python-skeleton-def)

(define-key map "\C-c\C-tf" 'python-skeleton-for)

(define-key map "\C-c\C-ti" 'python-skeleton-if)

(define-key map "\C-c\C-tt" 'python-skeleton-try)

(define-key map "\C-c\C-tw" 'python-skeleton-while)

;; Shell interaction

(define-key map "\C-c\C-p" 'run-python)

(define-key map "\C-c\C-s" 'python-shell-send-string)

(define-key map "\C-c\C-r" 'python-shell-send-region)

(define-key map "\C-\M-x" 'python-shell-send-defun)

(define-key map "\C-c\C-c" 'python-shell-send-buffer)

(define-key map "\C-c\C-l" 'python-shell-send-file)

(define-key map "\C-c\C-z" 'python-shell-switch-to-shell)

;; Some util commands

(define-key map "\C-c\C-v" 'python-check)

(define-key map "\C-c\C-f" 'python-eldoc-at-point)

;; Utilities

(substitute-key-definition 'complete-symbol 'completion-at-point

map global-map)

(easy-menu-define python-menu map "Python Mode menu"

`("Python"

:help "Python-specific Features"

["Shift region left" python-indent-shift-left :active mark-active

:help "Shift region left by a single indentation step"]

["Shift region right" python-indent-shift-right :active mark-active

:help "Shift region right by a single indentation step"]

"-"

["Start of def/class" beginning-of-defun

:help "Go to start of outermost definition around point"]

["End of def/class" end-of-defun

:help "Go to end of definition around point"]

["Mark def/class" mark-defun

:help "Mark outermost definition around point"]

["Jump to def/class" imenu

:help "Jump to a class or function definition"]

"--"

("Skeletons")

"---"

["Start interpreter" run-python

:help "Run inferior Python process in a separate buffer"]

["Switch to shell" python-shell-switch-to-shell

:help "Switch to running inferior Python process"]

["Eval string" python-shell-send-string

:help "Eval string in inferior Python session"]

["Eval buffer" python-shell-send-buffer

:help "Eval buffer in inferior Python session"]

["Eval region" python-shell-send-region

:help "Eval region in inferior Python session"]

["Eval defun" python-shell-send-defun

:help "Eval defun in inferior Python session"]

["Eval file" python-shell-send-file

:help "Eval file in inferior Python session"]

["Debugger" pdb :help "Run pdb under GUD"]

"----"

["Check file" python-check

:help "Check file for errors"]

["Help on symbol" python-eldoc-at-point

:help "Get help on symbol at point"]

["Complete symbol" completion-at-point

:help "Complete symbol before point"]))

map)

"Keymap for `python-mode'.")



;;; Python specialized rx

(eval-when-compile

(defconst python-rx-constituents

`((block-start . ,(rx symbol-start

(or "def" "class" "if" "elif" "else" "try"

"except" "finally" "for" "while" "with")

symbol-end))

(decorator . ,(rx line-start (* space) ?@ (any letter ?_)

(* (any word ?_))))

(defun . ,(rx symbol-start (or "def" "class") symbol-end))

(if-name-main . ,(rx line-start "if" (+ space) "__name__"

(+ space) "==" (+ space)

(any ?' ?\") "__main__" (any ?' ?\")

(* space) ?:))

(symbol-name . ,(rx (any letter ?_) (* (any word ?_))))

(open-paren . ,(rx (or "{" "[" "(")))

(close-paren . ,(rx (or "}" "]" ")")))

(simple-operator . ,(rx (any ?+ ?- ?/ ?& ?^ ?~ ?| ?* ?< ?> ?= ?%)))

;; FIXME: rx should support (not simple-operator).

(not-simple-operator . ,(rx

(not

(any ?+ ?- ?/ ?& ?^ ?~ ?| ?* ?< ?> ?= ?%))))

;; FIXME: Use regexp-opt.

(operator . ,(rx (or "+" "-" "/" "&" "^" "~" "|" "*" "<" ">"

"=" "%" "**" "//" "<<" ">>" "<=" "!="

"==" ">=" "is" "not")))

;; FIXME: Use regexp-opt.

(assignment-operator . ,(rx (or "=" "+=" "-=" "*=" "/=" "//=" "%=" "**="

">>=" "<<=" "&=" "^=" "|=")))

(string-delimiter . ,(rx (and

;; Match even number of backslashes.

(or (not (any ?\\ ?\' ?\")) point

;; Quotes might be preceded by a escaped quote.

(and (or (not (any ?\\)) point) ?\\

(* ?\\ ?\\) (any ?\' ?\")))

(* ?\\ ?\\)

;; Match single or triple quotes of any kind.

(group (or "\"" "\"\"\"" "'" "'''"))))))

"Additional Python specific sexps for `python-rx'")

(defmacro python-rx (&rest regexps)

"Python mode specialized rx macro.

This variant of `rx' supports common python named REGEXPS."

(let ((rx-constituents (append python-rx-constituents rx-constituents)))

(cond ((null regexps)

(error "No regexp"))

((cdr regexps)

(rx-to-string `(and ,@regexps) t))

(t

(rx-to-string (car regexps) t))))))



;;; Font-lock and syntax

(defun python-syntax-context (type &optional syntax-ppss)

"Return non-nil if point is on TYPE using SYNTAX-PPSS.

TYPE can be `comment', `string' or `paren'. It returns the start

character address of the specified TYPE."

(declare (compiler-macro

(lambda (form)

(pcase type

(`'comment

`(let ((ppss (or ,syntax-ppss (syntax-ppss))))

(and (nth 4 ppss) (nth 8 ppss))))

(`'string

`(let ((ppss (or ,syntax-ppss (syntax-ppss))))

(and (nth 3 ppss) (nth 8 ppss))))

(`'paren

`(nth 1 (or ,syntax-ppss (syntax-ppss))))

(_ form)))))

(let ((ppss (or syntax-ppss (syntax-ppss))))

(pcase type

(`comment (and (nth 4 ppss) (nth 8 ppss)))

(`string (and (nth 3 ppss) (nth 8 ppss)))

(`paren (nth 1 ppss))

(_ nil))))

(defun python-syntax-context-type (&optional syntax-ppss)

"Return the context type using SYNTAX-PPSS.

The type returned can be `comment', `string' or `paren'."

(let ((ppss (or syntax-ppss (syntax-ppss))))

(cond

((nth 8 ppss) (if (nth 4 ppss) 'comment 'string))

((nth 1 ppss) 'paren))))

(defsubst python-syntax-comment-or-string-p ()

"Return non-nil if point is inside 'comment or 'string."

(nth 8 (syntax-ppss)))

(define-obsolete-function-alias

'python-info-ppss-context #'python-syntax-context "24.3")

(define-obsolete-function-alias

'python-info-ppss-context-type #'python-syntax-context-type "24.3")

(define-obsolete-function-alias

'python-info-ppss-comment-or-string-p

#'python-syntax-comment-or-string-p "24.3")

(defvar python-font-lock-keywords

;; Keywords

`(,(rx symbol-start

(or

"and" "del" "from" "not" "while" "as" "elif" "global" "or" "with"

"assert" "else" "if" "pass" "yield" "break" "except" "import" "class"

"in" "raise" "continue" "finally" "is" "return" "def" "for" "lambda"

"try"

;; Python 2:

"print" "exec"

;; Python 3:

;; False, None, and True are listed as keywords on the Python 3

;; documentation, but since they also qualify as constants they are

;; fontified like that in order to keep font-lock consistent between

;; Python versions.

"nonlocal"

;; Extra:

"self")

symbol-end)

;; functions

(,(rx symbol-start "def" (1+ space) (group (1+ (or word ?_))))

(1 font-lock-function-name-face))

;; classes

(,(rx symbol-start "class" (1+ space) (group (1+ (or word ?_))))

(1 font-lock-type-face))

;; Constants

(,(rx symbol-start

(or

"Ellipsis" "False" "None" "NotImplemented" "True" "__debug__"

;; copyright, license, credits, quit and exit are added by the site

;; module and they are not intended to be used in programs

"copyright" "credits" "exit" "license" "quit")

symbol-end) . font-lock-constant-face)

;; Decorators.

(,(rx line-start (* (any " \t")) (group "@" (1+ (or word ?_))

(0+ "." (1+ (or word ?_)))))

(1 font-lock-type-face))

;; Builtin Exceptions

(,(rx symbol-start

(or

"ArithmeticError" "AssertionError" "AttributeError" "BaseException"

"DeprecationWarning" "EOFError" "EnvironmentError" "Exception"

"FloatingPointError" "FutureWarning" "GeneratorExit" "IOError"

"ImportError" "ImportWarning" "IndexError" "KeyError"

"KeyboardInterrupt" "LookupError" "MemoryError" "NameError"

"NotImplementedError" "OSError" "OverflowError"

"PendingDeprecationWarning" "ReferenceError" "RuntimeError"

"RuntimeWarning" "StopIteration" "SyntaxError" "SyntaxWarning"

"SystemError" "SystemExit" "TypeError" "UnboundLocalError"

"UnicodeDecodeError" "UnicodeEncodeError" "UnicodeError"

"UnicodeTranslateError" "UnicodeWarning" "UserWarning" "VMSError"

"ValueError" "Warning" "WindowsError" "ZeroDivisionError"

;; Python 2:

"StandardError"

;; Python 3:

"BufferError" "BytesWarning" "IndentationError" "ResourceWarning"

"TabError")

symbol-end) . font-lock-type-face)

;; Builtins

(,(rx symbol-start

(or

"abs" "all" "any" "bin" "bool" "callable" "chr" "classmethod"

"compile" "complex" "delattr" "dict" "dir" "divmod" "enumerate"

"eval" "filter" "float" "format" "frozenset" "getattr" "globals"

"hasattr" "hash" "help" "hex" "id" "input" "int" "isinstance"

"issubclass" "iter" "len" "list" "locals" "map" "max" "memoryview"

"min" "next" "object" "oct" "open" "ord" "pow" "print" "property"

"range" "repr" "reversed" "round" "set" "setattr" "slice" "sorted"

"staticmethod" "str" "sum" "super" "tuple" "type" "vars" "zip"

"__import__"

;; Python 2:

"basestring" "cmp" "execfile" "file" "long" "raw_input" "reduce"

"reload" "unichr" "unicode" "xrange" "apply" "buffer" "coerce"

"intern"

;; Python 3:

"ascii" "bytearray" "bytes" "exec"

;; Extra:

"__all__" "__doc__" "__name__" "__package__")

symbol-end) . font-lock-builtin-face)

;; assignments

;; support for a = b = c = 5

(,(lambda (limit)

(let ((re (python-rx (group (+ (any word ?. ?_)))

(? ?\[ (+ (not (any ?\]))) ?\]) (* space)

assignment-operator)))

(when (re-search-forward re limit t)

(while (and (python-syntax-context 'paren)

(re-search-forward re limit t)))

(if (not (or (python-syntax-context 'paren)

(equal (char-after (point-marker)) ?=)))

t

(set-match-data nil)))))

(1 font-lock-variable-name-face nil nil))

;; support for a, b, c = (1, 2, 3)

(,(lambda (limit)

(let ((re (python-rx (group (+ (any word ?. ?_))) (* space)

(* ?, (* space) (+ (any word ?. ?_)) (* space))

?, (* space) (+ (any word ?. ?_)) (* space)

assignment-operator)))

(when (and (re-search-forward re limit t)

(goto-char (nth 3 (match-data))))

(while (and (python-syntax-context 'paren)

(re-search-forward re limit t))

(goto-char (nth 3 (match-data))))

(if (not (python-syntax-context 'paren))

t

(set-match-data nil)))))

(1 font-lock-variable-name-face nil nil))))

(defconst python-syntax-propertize-function

(syntax-propertize-rules

((python-rx string-delimiter)

(0 (ignore (python-syntax-stringify))))))

(defsubst python-syntax-count-quotes (quote-char &optional point limit)

"Count number of quotes around point (max is 3).

QUOTE-CHAR is the quote char to count. Optional argument POINT is

the point where scan starts (defaults to current point) and LIMIT

is used to limit the scan."

(let ((i 0))

(while (and (< i 3)

(or (not limit) (< (+ point i) limit))

(eq (char-after (+ point i)) quote-char))

(setq i (1+ i)))

i))

(defun python-syntax-stringify ()

"Put `syntax-table' property correctly on single/triple quotes."

(let* ((num-quotes (length (match-string-no-properties 1)))

(ppss (prog2

(backward-char num-quotes)

(syntax-ppss)

(forward-char num-quotes)))

(string-start (and (not (nth 4 ppss)) (nth 8 ppss)))

(quote-starting-pos (- (point) num-quotes))

(quote-ending-pos (point))

(num-closing-quotes

(and string-start

(python-syntax-count-quotes

(char-before) string-start quote-starting-pos))))

(cond ((and string-start (= num-closing-quotes 0))

;; This set of quotes doesn't match the string starting

;; kind. Do nothing.

nil)

((not string-start)

;; This set of quotes delimit the start of a string.

(put-text-property quote-starting-pos (1+ quote-starting-pos)

'syntax-table (string-to-syntax "|")))

((= num-quotes num-closing-quotes)

;; This set of quotes delimit the end of a string.

(put-text-property (1- quote-ending-pos) quote-ending-pos

'syntax-table (string-to-syntax "|")))

((> num-quotes num-closing-quotes)

;; This may only happen whenever a triple quote is closing

;; a single quoted string. Add string delimiter syntax to

;; all three quotes.

(put-text-property quote-starting-pos quote-ending-pos

'syntax-table (string-to-syntax "|"))))))

(defvar python-mode-syntax-table

(let ((table (make-syntax-table)))

;; Give punctuation syntax to ASCII that normally has symbol

;; syntax or has word syntax and isn't a letter.

(let ((symbol (string-to-syntax "_"))

(sst (standard-syntax-table)))

(dotimes (i 128)

(unless (= i ?_)

(if (equal symbol (aref sst i))

(modify-syntax-entry i "." table)))))

(modify-syntax-entry ?$ "." table)

(modify-syntax-entry ?% "." table)

;; exceptions

(modify-syntax-entry ?# "<" table)

(modify-syntax-entry ?\n ">" table)

(modify-syntax-entry ?' "\"" table)

(modify-syntax-entry ?` "$" table)

table)

"Syntax table for Python files.")

(defvar python-dotty-syntax-table

(let ((table (make-syntax-table python-mode-syntax-table)))

(modify-syntax-entry ?. "w" table)

(modify-syntax-entry ?_ "w" table)

table)

"Dotty syntax table for Python files.

It makes underscores and dots word constituent chars.")



;;; Indentation

(defcustom python-indent-offset 4

"Default indentation offset for Python."

:group 'python

:type 'integer

:safe 'integerp)

(defcustom python-indent-guess-indent-offset t

"Non-nil tells Python mode to guess `python-indent-offset' value."

:type 'boolean

:group 'python

:safe 'booleanp)

(defcustom python-indent-trigger-commands

'(indent-for-tab-command yas-expand yas/expand)

"Commands that might trigger a `python-indent-line' call."

:type '(repeat symbol)

:group 'python)

(define-obsolete-variable-alias

'python-indent 'python-indent-offset "24.3")

(define-obsolete-variable-alias

'python-guess-indent 'python-indent-guess-indent-offset "24.3")

(defvar python-indent-current-level 0

"Current indentation level `python-indent-line-function' is using.")

(defvar python-indent-levels '(0)

"Levels of indentation available for `python-indent-line-function'.")

(defvar python-indent-dedenters '("else" "elif" "except" "finally")

"List of words that should be dedented.

These make `python-indent-calculate-indentation' subtract the value of

`python-indent-offset'.")

(defun python-indent-guess-indent-offset ()

"Guess and set `python-indent-offset' for the current buffer."

(interactive)

(save-excursion

(save-restriction

(widen)

(goto-char (point-min))

(let ((block-end))

(while (and (not block-end)

(re-search-forward

(python-rx line-start block-start) nil t))

(when (and

(not (python-syntax-context-type))

(progn

(goto-char (line-end-position))

(python-util-forward-comment -1)

(if (equal (char-before) ?:)

t

(forward-line 1)

(when (python-info-block-continuation-line-p)

(while (and (python-info-continuation-line-p)

(not (eobp)))

(forward-line 1))

(python-util-forward-comment -1)

(when (equal (char-before) ?:)

t)))))

(setq block-end (point-marker))))

(let ((indentation

(when block-end

(goto-char block-end)

(python-util-forward-comment)

(current-indentation))))

(if indentation

(set (make-local-variable 'python-indent-offset) indentation)

(message "Can't guess python-indent-offset, using defaults: %s"

python-indent-offset)))))))

(defun python-indent-context ()

"Get information on indentation context.

Context information is returned with a cons with the form:

\(STATUS . START)

Where status can be any of the following symbols:

* inside-paren: If point in between (), {} or []

* inside-string: If point is inside a string

* after-backslash: Previous line ends in a backslash

* after-beginning-of-block: Point is after beginning of block

* after-line: Point is after normal line

* no-indent: Point is at beginning of buffer or other special case

START is the buffer position where the sexp starts."

(save-restriction

(widen)

(let ((ppss (save-excursion (beginning-of-line) (syntax-ppss)))

(start))

(cons

(cond

;; Beginning of buffer

((save-excursion

(goto-char (line-beginning-position))

(bobp))

'no-indent)

;; Inside string

((setq start (python-syntax-context 'string ppss))

'inside-string)

;; Inside a paren

((setq start (python-syntax-context 'paren ppss))

'inside-paren)

;; After backslash

((setq start (when (not (or (python-syntax-context 'string ppss)

(python-syntax-context 'comment ppss)))

(let ((line-beg-pos (line-beginning-position)))

(when (python-info-line-ends-backslash-p

(1- line-beg-pos))

(- line-beg-pos 2)))))

'after-backslash)

;; After beginning of block

((setq start (save-excursion

(when (progn

(back-to-indentation)

(python-util-forward-comment -1)

(equal (char-before) ?:))

;; Move to the first block start that's not in within

;; a string, comment or paren and that's not a

;; continuation line.

(while (and (re-search-backward

(python-rx block-start) nil t)

(or

(python-syntax-context-type)

(python-info-continuation-line-p))))

(when (looking-at (python-rx block-start))

(point-marker)))))

'after-beginning-of-block)

;; After normal line

((setq start (save-excursion

(back-to-indentation)

(skip-chars-backward (rx (or whitespace ?\n)))

(python-nav-beginning-of-statement)

(point-marker)))

'after-line)

;; Do not indent

(t 'no-indent))

start))))

(defun python-indent-calculate-indentation ()

"Calculate correct indentation offset for the current line."

(let* ((indentation-context (python-indent-context))

(context-status (car indentation-context))

(context-start (cdr indentation-context)))

(save-restriction

(widen)

(save-excursion

(pcase context-status

(`no-indent 0)

;; When point is after beginning of block just add one level

;; of indentation relative to the context-start

(`after-beginning-of-block

(goto-char context-start)

(+ (current-indentation) python-indent-offset))

;; When after a simple line just use previous line

;; indentation, in the case current line starts with a

;; `python-indent-dedenters' de-indent one level.

(`after-line

(-

(save-excursion

(goto-char context-start)

(current-indentation))

(if (progn

(back-to-indentation)

(looking-at (regexp-opt python-indent-dedenters)))

python-indent-offset

0)))

;; When inside of a string, do nothing. just use the current

;; indentation. XXX: perhaps it would be a good idea to

;; invoke standard text indentation here

(`inside-string

(goto-char context-start)

(current-indentation))

;; After backslash we have several possibilities.

(`after-backslash

(cond

;; Check if current line is a dot continuation. For this

;; the current line must start with a dot and previous

;; line must contain a dot too.

((save-excursion

(back-to-indentation)

(when (looking-at "\\.")

;; If after moving one line back point is inside a paren it

;; needs to move back until it's not anymore

(while (prog2

(forward-line -1)

(and (not (bobp))

(python-syntax-context 'paren))))

(goto-char (line-end-position))

(while (and (re-search-backward

"\\." (line-beginning-position) t)

(python-syntax-context-type)))

(if (and (looking-at "\\.")

(not (python-syntax-context-type)))

;; The indentation is the same column of the

;; first matching dot that's not inside a

;; comment, a string or a paren

(current-column)

;; No dot found on previous line, just add another

;; indentation level.

(+ (current-indentation) python-indent-offset)))))

;; Check if prev line is a block continuation

((let ((block-continuation-start

(python-info-block-continuation-line-p)))

(when block-continuation-start

;; If block-continuation-start is set jump to that

;; marker and use first column after the block start

;; as indentation value.

(goto-char block-continuation-start)

(re-search-forward

(python-rx block-start (* space))

(line-end-position) t)

(current-column))))

;; Check if current line is an assignment continuation

((let ((assignment-continuation-start

(python-info-assignment-continuation-line-p)))

(when assignment-continuation-start

;; If assignment-continuation is set jump to that

;; marker and use first column after the assignment

;; operator as indentation value.

(goto-char assignment-continuation-start)

(current-column))))

(t

(forward-line -1)

(goto-char (python-info-beginning-of-backslash))

(if (save-excursion

(and

(forward-line -1)

(goto-char

(or (python-info-beginning-of-backslash) (point)))

(python-info-line-ends-backslash-p)))

;; The two previous lines ended in a backslash so we must

;; respect previous line indentation.

(current-indentation)

;; What happens here is that we are dealing with the second

;; line of a backslash continuation, in that case we just going

;; to add one indentation level.

(+ (current-indentation) python-indent-offset)))))

;; When inside a paren there's a need to handle nesting

;; correctly

(`inside-paren

(cond

;; If current line closes the outermost open paren use the

;; current indentation of the context-start line.

((save-excursion

(skip-syntax-forward "\s" (line-end-position))

(when (and (looking-at (regexp-opt '(")" "]" "}")))

(progn

(forward-char 1)

(not (python-syntax-context 'paren))))

(goto-char context-start)

(current-indentation))))

;; If open paren is contained on a line by itself add another

;; indentation level, else look for the first word after the

;; opening paren and use it's column position as indentation

;; level.

((let* ((content-starts-in-newline)

(indent

(save-excursion

(if (setq content-starts-in-newline

(progn

(goto-char context-start)

(forward-char)

(save-restriction

(narrow-to-region

(line-beginning-position)

(line-end-position))

(python-util-forward-comment))

(looking-at "$")))

(+ (current-indentation) python-indent-offset)

(current-column)))))

;; Adjustments

(cond

;; If current line closes a nested open paren de-indent one

;; level.

((progn

(back-to-indentation)

(looking-at (regexp-opt '(")" "]" "}"))))

(- indent python-indent-offset))

;; If the line of the opening paren that wraps the current

;; line starts a block add another level of indentation to

;; follow new pep8 recommendation. See: http://ur1.ca/5rojx

((save-excursion

(when (and content-starts-in-newline

(progn

(goto-char context-start)

(back-to-indentation)

(looking-at (python-rx block-start))))

(+ indent python-indent-offset))))

(t indent)))))))))))

(defun python-indent-calculate-levels ()

"Calculate `python-indent-levels' and reset `python-indent-current-level'."

(let* ((indentation (python-indent-calculate-indentation))

(remainder (% indentation python-indent-offset))

(steps (/ (- indentation remainder) python-indent-offset)))

(setq python-indent-levels (list 0))

(dotimes (step steps)

(push (* python-indent-offset (1+ step)) python-indent-levels))

(when (not (eq 0 remainder))

(push (+ (* python-indent-offset steps) remainder) python-indent-levels))

(setq python-indent-levels (nreverse python-indent-levels))

(setq python-indent-current-level (1- (length python-indent-levels)))))

(defun python-indent-toggle-levels ()

"Toggle `python-indent-current-level' over `python-indent-levels'."

(setq python-indent-current-level (1- python-indent-current-level))

(when (< python-indent-current-level 0)

(setq python-indent-current-level (1- (length python-indent-levels)))))

(defun python-indent-line (&optional force-toggle)

"Internal implementation of `python-indent-line-function'.

Uses the offset calculated in

`python-indent-calculate-indentation' and available levels

indicated by the variable `python-indent-levels' to set the

current indentation.

When the variable `last-command' is equal to one of the symbols

inside `python-indent-trigger-commands' or FORCE-TOGGLE is

non-nil it cycles levels indicated in the variable

`python-indent-levels' by setting the current level in the

variable `python-indent-current-level'.

When the variable `last-command' is not equal to one of the

symbols inside `python-indent-trigger-commands' and FORCE-TOGGLE

is nil it calculates possible indentation levels and saves it in

the variable `python-indent-levels'. Afterwards it sets the

variable `python-indent-current-level' correctly so offset is

equal to (`nth' `python-indent-current-level'

`python-indent-levels')"

(or

(and (or (and (memq this-command python-indent-trigger-commands)

(eq last-command this-command))

force-toggle)

(not (equal python-indent-levels '(0)))

(or (python-indent-toggle-levels) t))

(python-indent-calculate-levels))

(let* ((starting-pos (point-marker))

(indent-ending-position

(+ (line-beginning-position) (current-indentation)))

(follow-indentation-p

(or (bolp)

(and (<= (line-beginning-position) starting-pos)

(>= indent-ending-position starting-pos))))

(next-indent (nth python-indent-current-level python-indent-levels)))

(unless (= next-indent (current-indentation))

(beginning-of-line)

(delete-horizontal-space)

(indent-to next-indent)

(goto-char starting-pos))

(and follow-indentation-p (back-to-indentation)))

(python-info-closing-block-message))

(defun python-indent-line-function ()

"`indent-line-function' for Python mode.

See `python-indent-line' for details."

(python-indent-line))

(defun python-indent-dedent-line ()

"De-indent current line."

(interactive "*")

(when (and (not (python-syntax-comment-or-string-p))

(<= (point-marker) (save-excursion

(back-to-indentation)

(point-marker)))

(> (current-column) 0))

(python-indent-line t)

t))

(defun python-indent-dedent-line-backspace (arg)

"De-indent current line.

Argument ARG is passed to `backward-delete-char-untabify' when

point is not in between the indentation."

(interactive "*p")

(when (not (python-indent-dedent-line))

(backward-delete-char-untabify arg)))

(put 'python-indent-dedent-line-backspace 'delete-selection 'supersede)

(defun python-indent-region (start end)

"Indent a python region automagically.

Called from a program, START and END specify the region to indent."

(let ((deactivate-mark nil))

(save-excursion

(goto-char end)

(setq end (point-marker))

(goto-char start)

(or (bolp) (forward-line 1))

(while (< (point) end)

(or (and (bolp) (eolp))

(let (word)

(forward-line -1)

(back-to-indentation)

(setq word (current-word))

(forward-line 1)

(when (and word

;; Don't mess with strings, unless it's the

;; enclosing set of quotes.

(or (not (python-syntax-context 'string))

(eq

(syntax-after

(+ (1- (point))

(current-indentation)

(python-syntax-count-quotes (char-after) (point))))