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

;; Copyright (C) 2010, 2011 Free Software Foundation, Inc.

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

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

;; Version: 0.23.1

;; Maintainer: FSF

;; Created: Jul 2010

;; Keywords: languages

;; This file is NOT part of GNU Emacs.

;; python.el 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.

;; python.el 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 python.el. 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.

;; While it probably has less features than Dave Love's python.el and

;; PSF's python-mode.el it provides the main stuff you'll need while

;; keeping it simple :)

;; 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

;; (`python-nav-forward-sentence', `python-nav-backward-sentence'

;; respectively). Extra functions `python-nav-sentence-start' and

;; `python-nav-sentence-end' are included to move to the beginning and

;; to the end of a setence while taking care of multiline definitions.

;; `python-nav-jump-to-defun' is provided and allows jumping to a

;; function or class definition quickly in the current buffer.

;; 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':

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

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

;; 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 programatically

;; 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. It builds a plain or tree menu

;; depending on the value of `python-imenu-make-tree'. Also you can

;; customize if menu items should include its type using

;; `python-imenu-include-defun-type'.

;; 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)

(eval-when-compile

(require 'cl)

;; 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

(substitute-key-definition 'backward-sentence

'python-nav-backward-sentence

map global-map)

(substitute-key-definition 'forward-sentence

'python-nav-forward-sentence

map global-map)

(define-key map "\C-c\C-j" 'python-nav-jump-to-defun)

;; 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-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" python-nav-jump-to-defun

: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

(list

`(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))

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

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

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

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

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

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

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

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

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

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

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

(defmacro python-rx (&rest regexps)

"Python mode specialized rx macro which 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

(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"

"print" "class" "exec" "in" "raise" "continue" "finally" "is"

"return" "def" "for" "lambda" "try" "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

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

;; site module and since they are not intended to be used in

;; programs they are not added here either.

(or "None" "True" "False" "Ellipsis" "__debug__" "NotImplemented")

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" "BufferError" "BytesWarning" "DeprecationWarning"

"EOFError" "EnvironmentError" "Exception" "FloatingPointError"

"FutureWarning" "GeneratorExit" "IOError" "ImportError"

"ImportWarning" "IndentationError" "IndexError" "KeyError"

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

"NotImplementedError" "OSError" "OverflowError"

"PendingDeprecationWarning" "ReferenceError" "RuntimeError"

"RuntimeWarning" "StandardError" "StopIteration" "SyntaxError"

"SyntaxWarning" "SystemError" "SystemExit" "TabError" "TypeError"

"UnboundLocalError" "UnicodeDecodeError" "UnicodeEncodeError"

"UnicodeError" "UnicodeTranslateError" "UnicodeWarning"

"UserWarning" "ValueError" "Warning" "ZeroDivisionError")

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

;; Builtins

(,(rx symbol-start

(or "_" "__doc__" "__import__" "__name__" "__package__" "abs" "all"

"any" "apply" "basestring" "bin" "bool" "buffer" "bytearray"

"bytes" "callable" "chr" "classmethod" "cmp" "coerce" "compile"

"complex" "delattr" "dict" "dir" "divmod" "enumerate" "eval"

"execfile" "file" "filter" "float" "format" "frozenset"

"getattr" "globals" "hasattr" "hash" "help" "hex" "id" "input"

"int" "intern" "isinstance" "issubclass" "iter" "len" "list"

"locals" "long" "map" "max" "min" "next" "object" "oct" "open"

"ord" "pow" "print" "property" "range" "raw_input" "reduce"

"reload" "repr" "reversed" "round" "set" "setattr" "slice"

"sorted" "staticmethod" "str" "sum" "super" "tuple" "type"

"unichr" "unicode" "vars" "xrange" "zip")

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

;; asignations

;; 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-info-ppss-context 'paren)

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

(if (and (not (python-info-ppss-context 'paren))

(not (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-info-ppss-context 'paren)

(re-search-forward re limit t))

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

(if (not (python-info-ppss-context 'paren))

t

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

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

(defconst python-font-lock-syntactic-keywords

;; Make outer chars of matching triple-quote sequences into generic

;; string delimiters. Fixme: Is there a better way?

;; First avoid a sequence preceded by an odd number of backslashes.

`((,(concat "\\(?:\\([RUru]\\)[Rr]?\\|^\\|[^\\]\\(?:\\\\.\\)*\\)" ;Prefix.

"\\(?:\\('\\)'\\('\\)\\|\\(?2:\"\\)\"\\(?3:\"\\)\\)")

(3 (python-quote-syntax)))))

(defun python-quote-syntax ()

"Put `syntax-table' property correctly on triple quote.

Used for syntactic keywords. N is the match number (1, 2 or 3)."

;; Given a triple quote, we have to check the context to know

;; whether this is an opening or closing triple or whether it's

;; quoted anyhow, and should be ignored. (For that we need to do

;; the same job as `syntax-ppss' to be correct and it seems to be OK

;; to use it here despite initial worries.) We also have to sort

;; out a possible prefix -- well, we don't _have_ to, but I think it

;; should be treated as part of the string.

;; Test cases:

;; ur"""ar""" x='"' # """

;; x = ''' """ ' a

;; '''

;; x '"""' x """ \"""" x

(save-excursion

(goto-char (match-beginning 0))

(let ((syntax (save-match-data (syntax-ppss))))

(cond

((eq t (nth 3 syntax)) ; after unclosed fence

;; Consider property for the last char if in a fenced string.

(goto-char (nth 8 syntax)) ; fence position

(skip-chars-forward "uUrR") ; skip any prefix

;; Is it a matching sequence?

(if (eq (char-after) (char-after (match-beginning 2)))

(put-text-property (match-beginning 3) (match-end 3)

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

((match-end 1)

;; Consider property for initial char, accounting for prefixes.

(put-text-property (match-beginning 1) (match-end 1)

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

(t

;; Consider property for initial char, accounting for prefixes.

(put-text-property (match-beginning 2) (match-end 2)

'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)

(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."

(save-excursion

(save-restriction

(widen)

(goto-char (point-min))

(let ((found-block))

(while (and (not found-block)

(re-search-forward

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

(when (and (not (python-info-ppss-context 'string))

(not (python-info-ppss-context 'comment))

(progn

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

(forward-comment -9999)

(eq ?: (char-before))))

(setq found-block t)))

(if (not found-block)

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

python-indent-offset)

(while (and (progn

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

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

(not (eobp)))

(forward-line 1))

(forward-line 1)

(forward-comment 9999)

(let ((indent-offset (current-indentation)))

(when (> indent-offset 0)

(setq python-indent-offset 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 a paren

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

'inside-paren)

;; Inside string

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

'inside-string)

;; After backslash

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

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

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

(when (eq ?\\ (char-before (1- line-beg-pos)))

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

'after-backslash)

;; After beginning of block

((setq start (save-excursion

(let ((block-regexp (python-rx block-start))

(block-start-line-end ":[[:space:]]*$"))

(back-to-indentation)

(forward-comment -9999)

(back-to-indentation)

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

(and (not (looking-at block-regexp))

(save-excursion

(re-search-forward

block-start-line-end

(line-end-position) t))))

(while (and (forward-line -1)

(python-info-continuation-line-p)

(not (bobp))))

(back-to-indentation)

(when (not (looking-at block-regexp))

(forward-line 1)))

(back-to-indentation)

(when (and (looking-at block-regexp)

(or (re-search-forward

block-start-line-end

(line-end-position) t)

(save-excursion

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

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

(point-marker)))))

'after-beginning-of-block)

;; After normal line

((setq start (save-excursion

(back-to-indentation)

(forward-comment -9999)

(python-nav-sentence-start)

(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

(case context-status

('no-indent 0)

('after-beginning-of-block

(goto-char context-start)

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

('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)))

('inside-string

(goto-char context-start)

(current-indentation))

('after-backslash

(let* ((block-continuation

(save-excursion

(forward-line -1)

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

(assignment-continuation

(save-excursion

(forward-line -1)

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

(dot-continuation

(save-excursion

(back-to-indentation)

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

(forward-line -1)

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

(while (and (re-search-backward "\\." (line-beginning-position) t)

(or (python-info-ppss-context 'comment)

(python-info-ppss-context 'string)

(python-info-ppss-context 'paren))))

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

(not (or (python-info-ppss-context 'comment)

(python-info-ppss-context 'string)

(python-info-ppss-context 'paren))))

(current-column)

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

(indentation (cond

(dot-continuation

dot-continuation)

(block-continuation

(goto-char block-continuation)

(re-search-forward

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

(line-end-position) t)

(current-column))

(assignment-continuation

(goto-char assignment-continuation)

(re-search-forward

(python-rx simple-operator)

(line-end-position) t)

(forward-char 1)

(re-search-forward

(python-rx (* space))

(line-end-position) t)

(current-column))

(t

(goto-char context-start)

(if (not

(save-excursion

(back-to-indentation)

(looking-at

"\\(?:return\\|from\\|import\\)\s+")))

(current-indentation)

(+ (current-indentation)

(length

(match-string-no-properties 0))))))))

indentation))

('inside-paren

(or (save-excursion

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

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

(not (forward-char 1))

(not (python-info-ppss-context 'paren)))

(goto-char context-start)

(back-to-indentation)

(current-column)))

(-

(save-excursion

(goto-char context-start)

(forward-char)

(save-restriction

(narrow-to-region

(line-beginning-position)

(line-end-position))

(forward-comment 9999))

(if (looking-at "$")

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

(forward-comment 9999)

(current-column)))

(if (progn

(back-to-indentation)

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

python-indent-offset

0)))))))))

(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

`indent-for-tab-command' 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

`indent-for-tab-command' 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')"

(if (or (and (eq this-command 'indent-for-tab-command)

(eq last-command this-command))

force-toggle)

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

(python-indent-toggle-levels)

(python-indent-calculate-levels))

(python-indent-calculate-levels))

(beginning-of-line)

(delete-horizontal-space)

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

(save-restriction

(widen)

(let ((closing-block-point (python-info-closing-block)))

(when closing-block-point

(message "Closes %s" (buffer-substring

closing-block-point

(save-excursion

(goto-char closing-block-point)

(line-end-position))))))))

(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 (or (python-info-ppss-context 'string)

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

(<= (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 word

(beginning-of-line)

(delete-horizontal-space)

(indent-to (python-indent-calculate-indentation)))))

(forward-line 1))

(move-marker end nil))))

(defun python-indent-shift-left (start end &optional count)

"Shift lines contained in region START END by COUNT columns to the left.

COUNT defaults to `python-indent-offset'. If region isn't

active, the current line is shifted. The shifted region includes

the lines in which START and END lie. An error is signaled if

any lines in the region are indented less than COUNT columns."

(interactive

(if mark-active

(list (region-beginning) (region-end) current-prefix-arg)

(list (line-beginning-position) (line-end-position) current-prefix-arg)))

(if count

(setq count (prefix-numeric-value count))

(setq count python-indent-offset))

(when (> count 0)

(let ((deactivate-mark nil))

(save-excursion

(goto-char start)

(while (< (point) end)

(if (and (< (current-indentation) count)

(not (looking-at "[ \t]*$")))

(error "Can't shift all lines enough"))

(forward-line))

(indent-rigidly start end (- count))))))

(add-to-list 'debug-ignored-errors "^Can't shift all lines enough")

(defun python-indent-shift-right (start end &optional count)

"Shift lines contained in region START END by COUNT columns to the left.

COUNT defaults to `python-indent-offset'. If region isn't

active, the current line is shifted. The shifted region includes

the lines in which START and END lie."

(interactive

(if mark-active

(list (region-beginning) (region-end) current-prefix-arg)

(list (line-beginning-position) (line-end-position) current-prefix-arg)))

(let ((deactivate-mark nil))

(if count

(setq count (prefix-numeric-value count))

(setq count python-indent-offset))

(indent-rigidly start end count)))

(defun python-indent-electric-colon (arg)

"Insert a colon and maybe de-indent the current line.

With numeric ARG, just insert that many colons. With

\\[universal-argument], just insert a single colon."

(interactive "*P")

(self-insert-command (if (not (integerp arg)) 1 arg))

(when (and (not arg)

(eolp)

(not (equal ?: (char-after (- (point-marker) 2))))

(not (or (python-info-ppss-context 'string)

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

(let ((indentation (current-indentation))

(calculated-indentation (python-indent-calculate-indentation)))

(when (> indentation calculated-indentation)

(save-excursion

(indent-line-to calculated-indentation)

(when (not (python-info-closing-block))

(indent-line-to indentation)))))))

(put 'python-indent-electric-colon 'delete-selection t)



;;; Navigation

(defvar python-nav-beginning-of-defun-regexp

(python-rx line-start (* space) defun (+ space) (group symbol-name))

"Regexp matching class or function definition.

The name of the defun should be grouped so it can be retrieved

via `match-string'.")

(defun python-nav-beginning-of-defun (&optional nodecorators)

"Move point to `beginning-of-defun'.

When NODECORATORS is non-nil decorators are not included. This

is the main part of`python-beginning-of-defun-function'

implementation. Return non-nil if point is moved to the

`beginning-of-defun'."

(let ((indent-pos (save-excursion

(back-to-indentation)

(point-marker)))

(found)

(include-decorators

(lambda ()

(when (not nodecorators)

(when (save-excursion

(forward-line -1)

(looking-at (python-rx decorator)))

(while (and (not (bobp))

(forward-line -1)

(looking-at (python-rx decorator))))

(when (not (bobp)) (forward-line 1)))))))

(if (and (> (point) indent-pos)

(save-excursion

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

(looking-at python-nav-beginning-of-defun-regexp)))

(progn

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

(funcall include-decorators)

(setq found t))

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

(when (re-search-backward python-nav-beginning-of-defun-regexp nil t)

(setq found t))

(goto-char (or (python-info-ppss-context 'string) (point)))

(funcall include-decorators))

found))

(defun python-beginning-of-defun-function (&optional arg nodecorators)

"Move point to the beginning of def or class.

With positive ARG move that number of functions forward. With

negative do the same but backwards. When NODECORATORS is non-nil

decorators are not included. Return non-nil if point is moved to the

`beginning-of-defun'."

(when (or (null arg) (= arg 0)) (setq arg 1))

(if (> arg 0)

(dotimes (i arg (python-nav-beginning-of-defun nodecorators)))

(let ((found))

(dotimes (i (- arg) found)

(python-end-of-defun-function)

(forward-comment 9999)

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

(when (not (eobp))

(setq found

(python-nav-beginning-of-defun nodecorators)))))))

(defun python-end-of-defun-function ()

"Move point to the end of def or class.

Returns nil if point is not in a def or class."

(interactive)

(let ((beg-defun-indent)

(decorator-regexp "[[:space:]]*@"))

(when (looking-at decorator-regexp)

(while (and (not (eobp))

(forward-line 1)

(looking-at decorator-regexp))))

(when (not (looking-at python-nav-beginning-of-defun-regexp))

(python-beginning-of-defun-function))

(setq beg-defun-indent (current-indentation))

(forward-line 1)

(while (and (forward-line 1)

(not (eobp))

(or (not (current-word))

(> (current-indentation) beg-defun-indent))))

(forward-comment 9999)

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