python-mode.el-6.2.3/ 0000755 0000000 0000000 00000000000 13037475064 014333 5 ustar root root 0000000 0000000 python-mode.el-6.2.3/python-mode.el 0000644 0000000 0000000 00003614243 13037473655 017141 0 ustar root root 0000000 0000000 ;; python-mode.el --- Edit, debug, develop, run Python programs. -*- lexical-binding: t; -*-
;; Includes a minor mode for handling a Python/IPython shell,
;; and can take advantage of Pymacs when installed.
;; This file not shipped as part of GNU Emacs.
;; Keywords: languages, processes, python, oop
;; Version: "6.2.3"
;; Copyright (C) 1992,1993,1994 Tim Peters
;; Author: 2015-2016 https://gitlab.com/groups/python-mode-devs
;; 2003-2014 https://launchpad.net/python-mode
;; 1995-2002 Barry A. Warsaw
;; 1992-1994 Tim Peters
;; Maintainer: python-mode@python.org
;; Created: Feb 1992
;; Keywords: python languages oop
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;; See documentation in README.org, README.DEVEL.org
;; Please report bugs at
;; https://gitlab.com/python-mode-devs/python-mode/issues
;; or at
;; https://bugs.launchpad.net/python-mode
;; commands-python-mode.org in directory "doc" reports
;; available commands, also a menu is provided
;; as for `py-add-abbrev':
;; Similar to `add-mode-abbrev', but uses
;; `py-partial-expression' before point for expansion to
;; store, not `word'. Also provides a proposal for new
;; abbrevs.
;; Proposal for an abbrev is composed from the downcased
;; initials of expansion - provided they are of char-class
;; [:alpha:]
;;
;; For example code below would be recognised as a
;; `py-expression' composed by three
;; py-partial-expressions.
;;
;; OrderedDict.popitem(last=True)
;;
;; Putting the curser at the EOL, M-3 M-x py-add-abbrev
;;
;; would prompt "op" for an abbrev to store, as first
;; `py-partial-expression' beginns with a "(", which is
;; not taken as proposal.
;;; Code:
(defgroup python-mode nil
"Support for the Python programming language, "
:group 'languages
:prefix "py-")
(defconst py-version "6.2.3")
(defcustom py-install-directory ""
"Directory where python-mode.el and it's subdirectories should be installed. Needed for completion and other environment stuff only. "
:type 'string
:tag "py-install-directory"
:group 'python-mode)
(defcustom py-pythonpath ""
"Define $PYTHONPATH here, if needed.
Emacs doesn't read .bashrc"
:type 'string
:tag "py-pythonpath"
:group 'python-mode)
(when (string= "" py-install-directory)
(setq py-install-directory default-directory))
(defcustom python-mode-modeline-display "Py"
"String to display in Emacs modeline "
:type 'string
:tag "python-mode-modeline-display"
:group 'python-mode)
(defcustom py-extensions "py-extensions.el"
"File where extensions to python-mode.el should be installed. Used by virtualenv support. "
:type 'string
:tag "py-extensions"
:group 'python-mode)
(defcustom info-lookup-mode "python"
"Which Python documentation should be queried.
Make sure it's accessible from Emacs by M-x info RET ...
See INSTALL-INFO-FILES for help. "
:type 'string
:tag "info-lookup-mode"
:group 'python-mode)
(defcustom py-fast-process-p nil
"Use `py-fast-process'.
Commands prefixed \"py-fast-...\" suitable for large output
See: large output makes Emacs freeze, lp:1253907
Results arrive in output buffer, which is not in comint-mode"
:type 'boolean
:tag "py-fast-process-p"
:group 'python-mode)
(defvar py-fast-output-buffer "*Py-Fast-Output-Buffer*"
"Default buffer-name for fast-processes")
(defvar py-this-result nil
"Internally used, store return-value")
(defcustom py-comment-auto-fill-p nil
"When non-nil, fill comments.
Defaut is nil"
:type 'boolean
:group 'python-mode)
(defcustom py-sexp-use-expression-p nil
"If non-nil, C-M-s call py-forward-expression.
Respective C-M-b will call py-backward-expression
Default is t"
:type 'boolean
:group 'python-mode)
(defcustom py-session-p t
"If commands would use an existing process.
If nil, a maybe existing process at py-buffer-name would be killed and re-started
See also `py-dedicated-process-p'
"
:type 'boolean
:tag "py-session-p"
:group 'python-mode)
(defcustom py-max-help-buffer-p nil
"If \"\*Python-Help\*\"-buffer should appear as the only visible.
Default is nil. In help-buffer, \"q\" will close it. "
:type 'boolean
:tag "py-max-help-buffer-p"
:group 'python-mode)
(defcustom py-highlight-error-source-p nil
"When py-execute-... commands raise an error, respective code in source-buffer will be highlighted. Default is nil.
M-x `py-remove-overlays-at-point' removes that highlighting.
"
:type 'boolean
:tag "py-highlight-error-source-p"
:group 'python-mode)
(defcustom py-set-pager-cat-p nil
"If the shell environment variable $PAGER should set to `cat'.
If `t', use `C-c C-r' to jump to beginning of output. Then scroll normally.
Avoids lp:783828, \"Terminal not fully functional\", for help('COMMAND') in python-shell
When non-nil, imports module `os' "
:type 'boolean
:tag "py-set-pager-cat-p"
:group 'python-mode)
(defcustom py-empty-line-closes-p nil
"When non-nil, dedent after empty line following block
if True:
print(\"Part of the if-statement\")
print(\"Not part of the if-statement\")
Default is nil
If non-nil, a C-j from empty line dedents."
:type 'boolean
:tag "py-empty-line-closes-p"
:group 'python-mode)
(defcustom py-prompt-on-changed-p t
"When called interactively, ask for save before a changed buffer is sent to interpreter.
Default is `t'"
:type 'boolean
:tag "py-prompt-on-changed-p"
:group 'python-mode)
(defcustom py-dedicated-process-p nil
"If commands executing code use a dedicated shell.
Default is nil
When non-nil and `py-session-p', an existing dedicated process is re-used instead of default - which allows executing stuff in parallel.
"
:type 'boolean
:tag "py-dedicated-process-p"
:group 'python-mode)
(defcustom py-store-result-p nil
"When non-nil, put resulting string of `py-execute-...' into kill-ring, so it might be yanked.
Default is nil"
:type 'boolean
:tag "py-dedicated-process-p"
:group 'python-mode)
(defvar py-shell--font-lock-buffer " *PSFLB*"
"May contain the `py-buffer-name' currently fontified. " )
(defvar py-return-result-p t
"Internally used. When non-nil, return resulting string of `py-execute-...' functions. Imports will use it with nil.
Default is t")
(defcustom py--execute-use-temp-file-p nil
"Assume execution at a remote machine.
where write-access is not given. "
:type 'boolean
:group 'python-mode)
(defvar py--match-paren-forward-p nil
"Internally used by `py-match-paren'. ")
(defvar py-new-session-p t
"Internally used. See lp:1393882.
Restart py-shell once with new Emacs/python-mode. ")
(defcustom py-electric-close-active-p nil
"Close completion buffer when it's sure, it's no longer needed, i.e. when inserting a space.
Works around a bug in `choose-completion'.
Default is `nil'"
:type 'boolean
:group 'python-mode)
(defcustom py-update-gud-pdb-history-p t
"If pdb should provide suggestions WRT file to check and py-pdb-path.
Default is t
See lp:963253
"
:type 'boolean
:tag "py-update-gud-pdb-history-p"
:group 'python-mode
:tag "py-update-gud-pdb-history-p")
(defcustom py-pdb-executable nil
"Indicate PATH/TO/pdb.
Default is nil
See lp:963253
"
:type 'string
:tag "py-pdb-executable"
:group 'python-mode
:tag "py-pdb-executable")
(defcustom py-hide-show-minor-mode-p nil
"If hide-show minor-mode should be on, default is nil. "
:type 'boolean
:tag "py-hide-show-minor-mode-p"
:group 'python-mode)
(defcustom py-load-skeletons-p nil
"If skeleton definitions should be loaded, default is nil.
If non-nil and abbrev-mode on, block-skeletons will inserted.
Pressing \"if\" for example will prompt for the if-condition.
"
:type 'boolean
:tag "py-load-skeletons-p"
:group 'python-mode)
(defcustom py-if-name-main-permission-p t
"Allow execution of code inside blocks started
by \"if __name__== '__main__':\".
Default is non-nil"
:type 'boolean
:tag "py-if-name-main-permission-p"
:group 'python-mode)
(defcustom py-use-font-lock-doc-face-p nil
"If documention string inside of def or class get `font-lock-doc-face'.
`font-lock-doc-face' inherits `font-lock-string-face'.
Call M-x `customize-face' in order to have a visible effect. "
:type 'boolean
:tag "py-use-font-lock-doc-face-p"
:group 'python-mode)
(defcustom py-empty-comment-line-separates-paragraph-p t
"Consider paragraph start/end lines with nothing inside but comment sign.
Default is non-nil"
:type 'boolean
:tag "py-empty-comment-line-separates-paragraph-p"
:group 'python-mode)
(defcustom py-indent-honors-inline-comment nil
"If non-nil, indents to column of inlined comment start.
Default is nil. "
:type 'boolean
:tag "py-indent-honors-inline-comment"
:group 'python-mode)
(defcustom py-auto-fill-mode nil
"If python-mode should set fill-column
according values in `py-comment-fill-column' and `py-docstring-fill-column'.
Default is nil"
:type 'boolean
:tag "py-auto-fill-mode"
:group 'python-mode)
(defcustom py-error-markup-delay 4
"Seconds error's are highlighted in exception buffer. "
:type 'integer
:tag "py-error-markup-delay"
:group 'python-mode)
(defcustom py-fast-completion-delay 0.1
"Used by py--fast-send-string-intern. "
:type 'float
:tag "py-fast-completion-delay"
:group 'python-mode)
(defcustom py-new-shell-delay
(if (eq system-type 'windows-nt)
2.0
1.0)
"If a new comint buffer is connected to Python, commands like completion might need some delay. "
:type 'float
:tag "py-new-shell-delay"
:group 'python-mode)
(defcustom py-autofill-timer-delay 1
"Delay when idle before functions ajusting `py-docstring-fill-column' resp. `py-comment-fill-column' are called. "
:type 'integer
:tag "py-autofill-timer-delay"
:group 'python-mode)
(defcustom py-docstring-fill-column 72
"Value of `fill-column' to use when filling a docstring.
Any non-integer value means do not use a different value of
`fill-column' when filling docstrings."
:type '(choice (integer)
(const :tag "Use the current `fill-column'" t))
:tag "py-docstring-fill-column"
:group 'python-mode)
(defcustom py-comment-fill-column 79
"Value of `fill-column' to use when filling a comment.
Any non-integer value means do not use a different value of
`fill-column' when filling docstrings."
:type '(choice (integer)
(const :tag "Use the current `fill-column'" t))
:tag "py-comment-fill-column"
:group 'python-mode)
(defcustom py-fontify-shell-buffer-p nil
"If code in Python shell should be highlighted as in script buffer.
Default is nil.
If `t', related vars like `comment-start' will be set too.
Seems convenient when playing with stuff in IPython shell
Might not be TRT when a lot of output arrives "
:type 'boolean
:tag "py-fontify-shell-buffer-p"
:group 'python-mode)
(defcustom py-modeline-display-full-path-p nil
"If the full PATH/TO/PYTHON should be displayed in shell modeline.
Default is nil. Note: when `py-shell-name' is specified with path, it's shown as an acronym in buffer-name already. "
:type 'boolean
:tag "py-modeline-display-full-path-p"
:group 'python-mode)
(defcustom py-modeline-acronym-display-home-p nil
"If the modeline acronym should contain chars indicating the home-directory.
Default is nil "
:type 'boolean
:tag "py-modeline-acronym-display-home-p"
:group 'python-mode)
(defun py-smart-operator-check ()
"Check, if smart-operator-mode is loaded resp. available.
Give some hints, if not."
(interactive)
(if (featurep 'smart-operator)
't
(progn
(and (boundp 'py-smart-operator-mode-p) py-smart-operator-mode-p (message "%s" "Don't see smart-operator.el. Make sure, it's installed. See in menu Options, Manage Emacs Packages. Or get it from source: URL: http://xwl.appspot.com/ref/smart-operator.el")
nil))))
(defun py-autopair-check ()
"Check, if autopair-mode is available.
Give some hints, if not."
(interactive)
(if (featurep 'autopair)
't
(progn
(message "py-autopair-check: %s" "Don't see autopair.el. Make sure, it's installed. If not, maybe see source: URL: http://autopair.googlecode.com")
nil)))
(defvar smart-operator-mode nil)
(defvar highlight-indent-active nil)
(defvar autopair-mode nil)
(defvar-local py-edit-docstring-orig-pos nil
"Internally used by `py-edit-docstring'. ")
(defvar-local py--docbeg nil
"Internally used by `py-edit-docstring'")
(defvar-local py--docend nil
"Internally used by `py-edit-docstring'")
(defvar py--oldbuf nil
"Internally used by `py-edit-docstring'")
(defvar py-edit-docstring-buffer "Edit docstring"
"Name of the temporary buffer to use when editing. ")
(defvar py--edit-docstring-register nil)
(defvar py-result nil
"Internally used. May store result from Python process. ")
(defvar py-error nil
"Internally used. Takes the error-messages from Python process. ")
(defvar py-python-completions "*Python Completions*"
"Buffer name for Python-shell completions, internally used")
(defvar py-ipython-completions "*IPython Completions*"
"Buffer name for IPython-shell completions, internally used")
(defcustom py-timer-close-completions-p t
"If `py-timer-close-completion-buffer' should run, default is non-nil. "
:type 'boolean
:tag "py-timer-close-completions-p"
:group 'python-mode)
(defcustom py-smart-operator-mode-p nil
"If python-mode calls `smart-operator-mode-on'
Default is nil. "
:type 'boolean
:tag "py-smart-operator-mode-p"
:group 'python-mode)
(defcustom py-autopair-mode nil
"If python-mode calls (autopair-mode-on)
Default is nil
Load `autopair-mode' written by Joao Tavora
URL: http://autopair.googlecode.com "
:type 'boolean
:tag "py-autopair-mode"
:group 'python-mode)
(defcustom py-indent-no-completion-p nil
"If completion function should insert a TAB when no completion found.
Default is `nil'"
:type 'boolean
:tag "py-indent-no-completion-p"
:group 'python-mode)
(defcustom py-company-pycomplete-p nil
"Load company-pycomplete stuff. Default is nil"
:type 'boolean
:tag "py-company-pycomplete-p"
:group 'python-mode)
(defvar py-last-position nil
"Used by py-help-at-point.
Avoid repeated call at identic pos. ")
(defvar py-auto-completion-mode-p nil
"Internally used by `py-auto-completion-mode'")
(defvar py-complete-last-modified nil
"Internally used by `py-auto-completion-mode'")
(defvar py--auto-complete-timer nil
"Internally used by `py-auto-completion-mode'")
(defvar py-auto-completion-buffer nil
"Internally used by `py-auto-completion-mode'")
(defvar py--auto-complete-timer-delay 1
"Seconds Emacs must be idle to trigger auto-completion.
See `py-auto-completion-mode'")
(defcustom py-auto-complete-p nil
"Run python-mode's built-in auto-completion via py-complete-function. Default is nil"
:type 'boolean
:tag "py-auto-complete-p"
:group 'python-mode)
(make-variable-buffer-local 'py-auto-complete-p)
(defcustom py-tab-shifts-region-p nil
"If `t', TAB will indent/cycle the region, not just the current line.
Default is nil
See also `py-tab-indents-region-p'"
:type 'boolean
:tag "py-tab-shifts-region-p"
:group 'python-mode)
(defcustom py-tab-indents-region-p nil
"When `t' and first TAB doesn't shift, indent-region is called.
Default is nil
See also `py-tab-shifts-region-p'"
:type 'boolean
:tag "py-tab-indents-region-p"
:group 'python-mode)
(defcustom py-block-comment-prefix-p t
"If py-comment inserts py-block-comment-prefix.
Default is t"
:type 'boolean
:tag "py-block-comment-prefix-p"
:group 'python-mode)
(defcustom py-org-cycle-p nil
"When non-nil, command `org-cycle' is available at shift-TAB,
Default is nil. "
:type 'boolean
:tag "py-org-cycle-p"
:group 'python-mode)
(defcustom py-set-complete-keymap-p nil
"If `py-complete-initialize', which sets up enviroment for Pymacs based py-complete, should load it's keys into `python-mode-map'
Default is nil.
See also resp. edit `py-complete-set-keymap' "
:type 'boolean
:tag "py-set-complete-keymap-p"
:group 'python-mode)
(defcustom py-outline-minor-mode-p t
"If outline minor-mode should be on, default is `t'. "
:type 'boolean
:tag "py-outline-minor-mode-p"
:group 'python-mode)
(defcustom py-guess-py-install-directory-p t
"If in cases, `py-install-directory' isn't set, `py-set-load-path'should guess it from `buffer-file-name'. "
:type 'boolean
:tag "py-guess-py-install-directory-p"
:group 'python-mode)
(defcustom py-load-pymacs-p nil
"If Pymacs related stuff should be loaded.
Default is nil.
Pymacs has been written by François Pinard and many others.
See original source: http://pymacs.progiciels-bpi.ca"
:type 'boolean
:tag "py-load-pymacs-p"
:group 'python-mode)
(defcustom py-verbose-p nil
"If functions should report results.
Default is nil. "
:type 'boolean
:tag "py-verbose-p"
:group 'python-mode)
(defcustom py-sexp-function nil
"When set, it's value is called instead of `forward-sexp', `backward-sexp'
Default is nil. "
:type '(choice
(const :tag "default" nil)
(const :tag "py-end-of-partial-expression" py-end-of-partial-expression)
(const :tag "py-end-of-expression" py-end-of-expression))
:tag "py-sexp-function"
:group 'python-mode)
(defcustom py-close-provides-newline t
"If a newline is inserted, when line after block isn't empty. Default is non-nil.
When non-nil, `py-end-of-def' and related will work faster"
:type 'boolean
:tag "py-close-provides-newline"
:group 'python-mode)
(defcustom py-dedent-keep-relative-column t
"If point should follow dedent or kind of electric move to end of line. Default is t - keep relative position. "
:type 'boolean
:tag "py-dedent-keep-relative-column"
:group 'python-mode)
(defcustom py-indent-honors-multiline-listing nil
"If `t', indents to 1+ column of opening delimiter. If `nil', indent adds one level to the beginning of statement. Default is `nil'. "
:type 'boolean
:tag "py-indent-honors-multiline-listing"
:group 'python-mode)
(defcustom py-indent-paren-spanned-multilines-p t
"If non-nil, indents elements of list a value of `py-indent-offset' to first element:
def foo():
if (foo &&
baz):
bar()
Default lines up with first element:
def foo():
if (foo &&
baz):
bar()
Default is `t'"
:type 'boolean
:tag "py-indent-paren-spanned-multilines-p"
:group 'python-mode)
(defcustom py-closing-list-dedents-bos nil
"When non-nil, indent list's closing delimiter like start-column.
It will be lined up under the first character of
the line that starts the multi-line construct, as in:
my_list = [
1, 2, 3,
4, 5, 6,
]
result = some_function_that_takes_arguments(
'a', 'b', 'c',
'd', 'e', 'f',
)
Default is nil, i.e.
my_list = [
1, 2, 3,
4, 5, 6,
]
result = some_function_that_takes_arguments(
'a', 'b', 'c',
'd', 'e', 'f',
)
Examples from PEP8"
:type 'boolean
:tag "py-closing-list-dedents-bos"
:group 'python-mode)
(defvar py-imenu-max-items 99)
(defcustom py-imenu-max-items 99
"Python-mode specific `imenu-max-items'"
:type 'number
:group 'python-mode)
(defcustom py-closing-list-space 1
"Number of chars, closing parenthesis outdent from opening, default is 1 "
:type 'number
:tag "py-closing-list-space"
:group 'python-mode)
(defcustom py-max-specpdl-size max-specpdl-size
"Heuristic exit. Limiting number of recursive calls by py-forward-statement and related functions. Default is max-specpdl-size.
This threshold is just an approximation. It might set far higher maybe.
See lp:1235375. In case code is not to navigate due to errors, `which-function-mode' and others might make Emacs hang. Rather exit than. "
:type 'number
:tag "py-max-specpdl-size"
:group 'python-mode)
(defcustom py-closing-list-keeps-space nil
"If non-nil, closing parenthesis dedents onto column of opening plus `py-closing-list-space', default is nil "
:type 'boolean
:tag "py-closing-list-keeps-space"
:group 'python-mode)
(defcustom py-electric-kill-backward-p nil
"Affects `py-electric-backspace'. Default is nil.
If behind a delimited form of braces, brackets or parentheses,
backspace will kill it's contents
With when cursor after
my_string[0:1]
--------------^
==>
my_string[]
----------^
In result cursor is insided emptied delimited form."
:type 'boolean
:tag "py-electric-kill-backward-p"
:group 'python-mode)
(defcustom py-electric-colon-active-p nil
"`py-electric-colon' feature. Default is `nil'. See lp:837065 for discussions.
See also `py-electric-colon-bobl-only' "
:type 'boolean
:tag "py-electric-colon-active-p"
:group 'python-mode)
(defcustom py-electric-colon-bobl-only t
"When inserting a colon, do not indent lines unless at beginning of block
See lp:1207405 resp. `py-electric-colon-active-p' "
:type 'boolean
:tag "py-electric-colon-bobl-only"
:group 'python-mode)
(defcustom py-electric-yank-active-p nil
" When non-nil, `yank' will be followed by an `indent-according-to-mode'.
Default is nil"
:type 'boolean
:tag "py-electric-yank-active-p"
:group 'python-mode)
(defcustom py-electric-colon-greedy-p nil
"If py-electric-colon should indent to the outmost reasonable level.
If nil, default, it will not move from at any reasonable level. "
:type 'boolean
:tag "py-electric-colon-greedy-p"
:group 'python-mode)
(defcustom py-electric-colon-newline-and-indent-p nil
"If non-nil, `py-electric-colon' will call `newline-and-indent'. Default is `nil'. "
:type 'boolean
:tag "py-electric-colon-newline-and-indent-p"
:group 'python-mode)
(defcustom py-electric-comment-p nil
"If \"#\" should call `py-electric-comment'. Default is `nil'. "
:type 'boolean
:tag "py-electric-comment-p"
:group 'python-mode)
(defcustom py-electric-comment-add-space-p nil
"If py-electric-comment should add a space. Default is `nil'. "
:type 'boolean
:tag "py-electric-comment-add-space-p"
:group 'python-mode)
(defcustom py-mark-decorators nil
"If py-mark-def-or-class functions should mark decorators too. Default is `nil'. "
:type 'boolean
:tag "py-mark-decorators"
:group 'python-mode)
(defcustom py-defun-use-top-level-p nil
"When non-nil, keys C-M-a, C-M-e address top-level form.
Default is nil.
Beginning- end-of-defun forms use
commands `py-beginning-of-top-level', `py-end-of-top-level'
mark-defun marks top-level form at point etc."
:type 'boolean
:tag "py-defun-use-top-level-p"
:group 'python-mode)
(defcustom py-tab-indent t
"Non-nil means TAB in Python mode calls `py-indent-line'."
:type 'boolean
:tag "py-tab-indent"
:group 'python-mode)
(defcustom py-return-key 'newline
"Which command should call. "
:type '(choice
(const :tag "default" py-newline-and-indent)
(const :tag "newline" newline)
(const :tag "py-newline-and-indent" py-newline-and-indent)
(const :tag "py-newline-and-dedent" py-newline-and-dedent)
)
:tag "py-return-key"
:group 'python-mode)
(defcustom py-complete-function 'py-fast-complete
"When set, enforces function todo completion, default is `py-fast-complete'.
Might not affect IPython, as `py-shell-complete' is the only known working here.
Normally python-mode knows best which function to use. "
:type '(choice
(const :tag "default" nil)
(const :tag "Pymacs and company based py-complete" py-complete)
(const :tag "py-shell-complete" py-shell-complete)
(const :tag "py-indent-or-complete" py-indent-or-complete)
(const :tag "py-fast-complete" py-fast-complete)
)
:tag "py-complete-function"
:group 'python-mode)
(defcustom py-encoding-string " # -*- coding: utf-8 -*-"
"Default string specifying encoding of a Python file. "
:type 'string
:tag "py-encoding-string"
:group 'python-mode)
(defcustom py-shebang-startstring "#! /bin/env"
"Detecting the shell in head of file. "
:type 'string
:tag "py-shebang-startstring"
:group 'python-mode)
(defcustom py-flake8-command ""
"Which command to call flake8.
If empty, python-mode will guess some "
:type 'string
:tag "py-flake8-command"
:group 'python-mode)
(defcustom py-flake8-command-args ""
"Arguments used by flake8.
Default is the empty string. "
:type 'string
:tag "py-flake8-command-args"
:group 'python-mode)
(defvar py-flake8-history nil
"Used by flake8, resp. py-flake8-command.
Default is nil. ")
(defcustom py-message-executing-temporary-file t
"If execute functions using a temporary file should message it. Default is `t'.
Messaging increments the prompt counter of IPython shell. "
:type 'boolean
:tag "py-message-executing-temporary-file"
:group 'python-mode)
(defcustom py-execute-no-temp-p nil
"Seems Emacs-24.3 provided a way executing stuff without temporary files. "
:type 'boolean
:tag "py-execute-no-temp-p"
:group 'python-mode)
(defcustom py-lhs-inbound-indent 1
"When line starts a multiline-assignment: How many colums indent should be more than opening bracket, brace or parenthesis. "
:type 'integer
:tag "py-lhs-inbound-indent"
:group 'python-mode)
(defcustom py-continuation-offset 2
"Additional amount of offset to give for some continuation lines.
Continuation lines are those that immediately follow a backslash
terminated line. "
:type 'integer
:tag "py-continuation-offset"
:group 'python-mode)
(defcustom py-indent-tabs-mode nil
"Python-mode starts `indent-tabs-mode' with the value specified here, default is nil. "
:type 'boolean
:tag "py-indent-tabs-mode"
:group 'python-mode)
(defcustom py-smart-indentation t
"Should `python-mode' try to automagically set some indentation variables?
When this variable is non-nil, two things happen when a buffer is set
to `python-mode':
1. `py-indent-offset' is guessed from existing code in the buffer.
Only guessed values between 2 and 8 are considered. If a valid
guess can't be made (perhaps because you are visiting a new
file), then the value in `py-indent-offset' is used.
2. `tab-width' is setq to `py-indent-offset' if not equal
already. `indent-tabs-mode' inserts one tab one
indentation level, otherwise spaces are used.
Note that both these settings occur *after* `python-mode-hook' is run,
so if you want to defeat the automagic configuration, you must also
set `py-smart-indentation' to nil in your `python-mode-hook'."
:type 'boolean
:tag "py-smart-indentation"
:group 'python-mode)
(defcustom py-block-comment-prefix "##"
"String used by \\[comment-region] to comment out a block of code.
This should follow the convention for non-indenting comment lines so
that the indentation commands won't get confused (i.e., the string
should be of the form `#x...' where `x' is not a blank or a tab, and
`...' is arbitrary). However, this string should not end in whitespace."
:type 'string
:tag "py-block-comment-prefix"
:group 'python-mode)
(defcustom py-indent-offset 4
"Amount of offset per level of indentation.
`\\[py-guess-indent-offset]' can usually guess a good value when
you're editing someone else's Python code."
:type 'integer
:tag "py-indent-offset"
:group 'python-mode)
(make-variable-buffer-local 'py-indent-offset)
(defcustom py-backslashed-lines-indent-offset 5
"Amount of offset per level of indentation of backslashed.
No semantic indent, which diff to `py-indent-offset' indicates "
:type 'integer
:tag "py-backslashed-lines-indent-offset"
:group 'python-mode)
(defcustom py-pdb-path
(if (or (eq system-type 'ms-dos)(eq system-type 'windows-nt))
(quote c:/python27/python\ -i\ c:/python27/Lib/pdb.py)
'/usr/lib/python2.7/pdb.py)
"Where to find pdb.py. Edit this according to your system.
If you ignore the location `M-x py-guess-pdb-path' might display it."
:type 'variable
:tag "py-pdb-path"
:group 'python-mode)
(defvar py-python-ms-pdb-command ""
"MS-systems might use that")
(defcustom py-indent-comments t
"When t, comment lines are indented. "
:type 'boolean
:tag "py-indent-comments"
:group 'python-mode)
(defcustom py-uncomment-indents-p nil
"When non-nil, after uncomment indent lines. "
:type 'boolean
:tag "py-uncomment-indents-p"
:group 'python-mode)
(defcustom py-separator-char 47
"The character, which separates the system file-path components.
Precedes guessing when not empty, returned by function `py-separator-char'. "
:type 'character
:tag "py-separator-char"
:group 'python-mode)
(and
;; used as a string finally
;; kept a character not to break existing customizations
(characterp py-separator-char)(setq py-separator-char (char-to-string py-separator-char)))
(defcustom py-custom-temp-directory ""
"If set, will take precedence over guessed values from `py-temp-directory'. Default is the empty string. "
:type 'string
:tag "py-custom-temp-directory"
:group 'python-mode)
(defcustom py-beep-if-tab-change t
"Ring the bell if `tab-width' is changed.
If a comment of the form
\t# vi:set tabsize=:
is found before the first code line when the file is entered, and the
current value of (the general Emacs variable) `tab-width' does not
equal , `tab-width' is set to , a message saying so is
displayed in the echo area, and if `py-beep-if-tab-change' is non-nil
the Emacs bell is also rung as a warning."
:type 'boolean
:tag "py-beep-if-tab-change"
:group 'python-mode)
(defcustom py-jump-on-exception t
"Jump to innermost exception frame in Python output buffer.
When this variable is non-nil and an exception occurs when running
Python code synchronously in a subprocess, jump immediately to the
source code of the innermost traceback frame."
:type 'boolean
:tag "py-jump-on-exception"
:group 'python-mode)
(defcustom py-ask-about-save t
"If not nil, ask about which buffers to save before executing some code.
Otherwise, all modified buffers are saved without asking."
:type 'boolean
:tag "py-ask-about-save"
:group 'python-mode)
(defcustom py-delete-function 'delete-char
"Function called by `py-electric-delete' when deleting forwards."
:type 'function
:tag "py-delete-function"
:group 'python-mode)
(defcustom py-pdbtrack-do-tracking-p t
"Controls whether the pdbtrack feature is enabled or not.
When non-nil, pdbtrack is enabled in all comint-based buffers,
e.g. shell buffers and the *Python* buffer. When using pdb to debug a
Python program, pdbtrack notices the pdb prompt and displays the
source file and line that the program is stopped at, much the same way
as gud-mode does for debugging C programs with gdb."
:type 'boolean
:tag "py-pdbtrack-do-tracking-p"
:group 'python-mode)
(make-variable-buffer-local 'py-pdbtrack-do-tracking-p)
(defcustom py-pdbtrack-filename-mapping nil
"Supports mapping file paths when opening file buffers in pdbtrack.
When non-nil this is an alist mapping paths in the Python interpreter
to paths in Emacs."
:type 'alist
:tag "py-pdbtrack-filename-mapping"
:group 'python-mode)
(defcustom py-pdbtrack-minor-mode-string " PDB"
"String to use in the minor mode list when pdbtrack is enabled."
:type 'string
:tag "py-pdbtrack-minor-mode-string"
:group 'python-mode)
(defcustom py-import-check-point-max
20000
"Maximum number of characters to search for a Java-ish import statement.
When `python-mode' tries to calculate the shell to use (either a
CPython or a Jython shell), it looks at the so-called `shebang' line
-- i.e. #! line. If that's not available, it looks at some of the
file heading imports to see if they look Java-like."
:type 'integer
:tag "py-import-check-point-max
"
:group 'python-mode)
(defcustom py-jython-packages
'("java" "javax")
"Imported packages that imply `jython-mode'."
:type '(repeat string)
:tag "py-jython-packages
"
:group 'python-mode)
(defcustom py-current-defun-show t
"If `py-current-defun' should jump to the definition, highlight it while waiting PY-WHICH-FUNC-DELAY seconds, before returning to previous position.
Default is `t'."
:type 'boolean
:tag "py-current-defun-show"
:group 'python-mode)
(defcustom py-current-defun-delay 2
"When called interactively, `py-current-defun' should wait PY-WHICH-FUNC-DELAY seconds at the definition name found, before returning to previous position. "
:type 'number
:tag "py-current-defun-delay"
:group 'python-mode)
(defcustom py--delete-temp-file-delay 1
"Used by `py--delete-temp-file'"
:type 'number
:tag "py--delete-temp-file-delay"
:group 'python-mode)
(defcustom py-python-send-delay 5
"Seconds to wait for output, used by `py--send-...' functions.
See also py-ipython-send-delay"
:type 'number
:tag "py-python-send-delay"
:group 'python-mode)
(defcustom py-ipython-send-delay 9
"Seconds to wait for output, used by `py--send-...' functions.
See also py-python-send-delay"
:type 'number
:tag "py-ipython-send-delay"
:group 'python-mode)
(defcustom py-master-file nil
"If non-nil, \\[py-execute-buffer] executes the named
master file instead of the buffer's file. If the file name has a
relative path, the value of variable `default-directory' for the
buffer is prepended to come up with a file name.
Beside you may set this variable in the file's local
variable section, e.g.:
# Local Variables:
# py-master-file: \"master.py\"
# End:
"
:type 'string
:tag "py-master-file"
:group 'python-mode)
(make-variable-buffer-local 'py-master-file)
(defcustom py-pychecker-command "pychecker"
"Shell command used to run Pychecker."
:type 'string
:tag "py-pychecker-command"
:group 'python-mode)
(defcustom py-pychecker-command-args "--stdlib"
"String arguments to be passed to pychecker."
:type 'string
:tag "py-pychecker-command-args"
:group 'python-mode)
(defcustom py-pyflakes-command "pyflakes"
"Shell command used to run Pyflakes."
:type 'string
:tag "py-pyflakes-command"
:group 'python-mode)
(defcustom py-pyflakes-command-args ""
"String arguments to be passed to pyflakes.
Default is \"\""
:type 'string
:tag "py-pyflakes-command-args"
:group 'python-mode)
(defcustom py-pep8-command "pep8"
"Shell command used to run pep8."
:type 'string
:tag "py-pep8-command"
:group 'python-mode)
(defcustom py-pep8-command-args ""
"String arguments to be passed to pylint.
Default is \"\" "
:type 'string
:tag "py-pep8-command-args"
:group 'python-mode)
(defcustom py-pyflakespep8-command (concat py-install-directory "/pyflakespep8.py")
"Shell command used to run `pyflakespep8'."
:type 'string
:tag "py-pyflakespep8-command"
:group 'python-mode)
(defcustom py-pyflakespep8-command-args ""
"string arguments to be passed to pyflakespep8.
Default is \"\" "
:type 'string
:tag "py-pyflakespep8-command-args"
:group 'python-mode)
(defcustom py-pylint-command "pylint"
"Shell command used to run Pylint."
:type 'string
:tag "py-pylint-command"
:group 'python-mode)
(defcustom py-pylint-command-args '("--errors-only")
"String arguments to be passed to pylint.
Default is \"--errors-only\" "
:type '(repeat string)
:tag "py-pylint-command-args"
:group 'python-mode)
(defcustom py-shell-input-prompt-1-regexp ">>> "
"A regular expression to match the input prompt of the shell."
:type 'regexp
:tag "py-shell-input-prompt-1-regexp"
:group 'python-mode)
(defcustom py-shell-input-prompt-2-regexp "[.][.][.] "
"A regular expression to match the input prompt of the shell after the
first line of input."
:type 'string
:tag "py-shell-input-prompt-2-regexp"
:group 'python-mode)
(defcustom py-shell-prompt-read-only t
"If non-nil, the python prompt is read only. Setting this
variable will only effect new shells."
:type 'boolean
:tag "py-shell-prompt-read-only"
:group 'python-mode)
(defcustom py-honor-IPYTHONDIR-p nil
"When non-nil ipython-history file is constructed by $IPYTHONDIR
followed by \"/history\". Default is nil.
Otherwise value of py-ipython-history is used. "
:type 'boolean
:tag "py-honor-IPYTHONDIR-p"
:group 'python-mode)
(defcustom py-ipython-history "~/.ipython/history"
"ipython-history default file. Used when py-honor-IPYTHONDIR-p is nil (default) "
:type 'string
:tag "py-ipython-history"
:group 'python-mode)
(defcustom py-honor-PYTHONHISTORY-p nil
"When non-nil python-history file is set by $PYTHONHISTORY
Default is nil.
Otherwise value of py-python-history is used. "
:type 'boolean
:tag "py-honor-PYTHONHISTORY-p"
:group 'python-mode)
(defcustom py-python-history "~/.python_history"
"python-history default file. Used when py-honor-PYTHONHISTORY-p is nil (default) "
:type 'string
:tag "py-python-history"
:group 'python-mode)
(defcustom py-switch-buffers-on-execute-p nil
"When non-nil switch to the Python output buffer.
If `py-keep-windows-configuration' is t, this will take precedence over setting here. "
:type 'boolean
:tag "py-switch-buffers-on-execute-p"
:group 'python-mode)
(defcustom py-split-window-on-execute 'just-two
"When non-nil split windows.
Default is just-two - when code is send to interpreter, split screen into source-code buffer and current py-shell result.
Other buffer will be hidden that way.
When set to `t', python-mode tries to reuse existing windows and will split only if needed.
With 'always, results will displayed in a new window.
Both `t' and `always' is experimental still.
For the moment: If a multitude of python-shells/buffers should be
visible, open them manually and set `py-keep-windows-configuration' to `t'.
See also `py-keep-windows-configuration'
"
:type '(choice
(const :tag "default" just-two)
(const :tag "reuse" t)
(const :tag "no split" nil)
(const :tag "just-two" just-two)
(const :tag "always" always))
:tag "py-split-window-on-execute"
:group 'python-mode)
(defcustom py-split-window-on-execute-threshold 3
"Maximal number of displayed windows.
Honored, when `py-split-window-on-execute' is `t', i.e. \"reuse\".
Don't split when max number of displayed windows is reached. "
:type 'number
:tag "py-split-window-on-execute-threshold"
:group 'python-mode)
(defcustom py-split-windows-on-execute-function 'split-window-vertically
"How window should get splitted to display results of py-execute-... functions. "
:type '(choice (const :tag "split-window-vertically" split-window-vertically)
(const :tag "split-window-horizontally" split-window-horizontally)
)
:tag "py-split-windows-on-execute-function"
:group 'python-mode)
(defcustom py-shell-fontify-style 'all
"Fontify current input resp. output in Python shell. Default is nil.
INPUT will leave output unfontified.
ALL keeps output fontified.
At any case only current input gets fontified.
"
:type '(choice (const :tag "Default" all)
(const :tag "Input" input)
(const :tag "Nil" nil)
)
:tag "py-shell-fontify-style"
:group 'python-mode)
(defcustom py-hide-show-keywords
'("class" "def" "elif" "else" "except"
"for" "if" "while" "finally" "try"
"with")
"Keywords composing visible heads. "
:type '(repeat string)
:tag "py-hide-show-keywords
"
:group 'python-mode)
(defcustom py-hide-show-hide-docstrings t
"Controls if doc strings can be hidden by hide-show"
:type 'boolean
:tag "py-hide-show-hide-docstrings"
:group 'python-mode)
(defcustom py-hide-comments-when-hiding-all t
"Hide the comments too when you do an `hs-hide-all'."
:type 'boolean
:tag "py-hide-comments-when-hiding-all"
:group 'python-mode)
(defcustom py-outline-mode-keywords
'("class" "def" "elif" "else" "except"
"for" "if" "while" "finally" "try"
"with")
"Keywords composing visible heads. "
:type '(repeat string)
:tag "py-outline-mode-keywords
"
:group 'python-mode)
(defcustom python-mode-hook nil
"Hook run when entering Python mode."
:type 'hook
:tag "python-mode-hook"
:group 'python-mode
)
(defcustom py-shell-name
(if (eq system-type 'windows-nt)
"C:/Python27/python"
;; "python"
"python")
"A PATH/TO/EXECUTABLE or default value `py-shell' may look for, if no shell is specified by command.
On Windows default is C:/Python27/python
--there is no garantee it exists, please check your system--
Else python"
:type 'string
:tag "py-shell-name
"
:group 'python-mode)
(defvar py-default-interpreter py-shell-name)
(defvar py-tempfile nil
"Internally used")
(defvar py-named-shells (list 'ipython 'ipython-dedicated 'ipython-no-switch 'ipython-switch 'ipython-switch-dedicated 'ipython2.7 'ipython2.7-dedicated 'ipython2.7-no-switch 'ipython2.7-switch 'ipython2.7-switch-dedicated 'ipython3 'ipython3-dedicated 'ipython3-no-switch 'ipython3-switch 'ipython3-switch-dedicated 'jython 'jython-dedicated 'jython-no-switch 'jython-switch 'jython-switch-dedicated 'python 'python-dedicated 'python-no-switch 'python-switch 'python-switch-dedicated 'python2 'python2-dedicated 'python2-no-switch 'python2-switch 'python2-switch-dedicated 'python3 'python3-dedicated 'python3-no-switch 'python3-switch 'python3-switch-dedicated))
(defcustom py-python-command
(if (eq system-type 'windows-nt)
;; "C:\\Python27\\python.exe"
"python"
;; "C:/Python33/Lib/site-packages/IPython"
"python")
"Make sure, the directory where python.exe resides in in the PATH-variable.
Windows: If needed, edit in \"Advanced System Settings/Environment Variables\" Commonly \"C:\\\\Python27\\\\python.exe\"
With Anaconda for example the following works here:
\"C:\\\\Users\\\\My-User-Name\\\\Anaconda\\\\Scripts\\\\python.exe\"
Else /usr/bin/python"
:type 'string
:tag "py-python-command
"
:group 'python-mode)
(defcustom py-python-command-args '("-i")
"String arguments to be used when starting a Python shell."
:type 'string
:tag "py-python-command-args"
:group 'python-mode)
(defcustom py-python2-command
(if (eq system-type 'windows-nt)
"C:\\Python27\\python"
;; "python2"
"python2")
"Make sure, the directory where python.exe resides in in the PATH-variable.
Windows: If needed, edit in \"Advanced System Settings/Environment Variables\" Commonly \"C:\\\\Python27\\\\python.exe\"
With Anaconda for example the following works here:
\"C:\\\\Users\\\\My-User-Name\\\\Anaconda\\\\Scripts\\\\python.exe\"
Else /usr/bin/python"
:type 'string
:tag "py-python2-command
"
:group 'python-mode)
(defcustom py-python2-command-args '("-i")
"String arguments to be used when starting a Python shell."
:type '(repeat string)
:tag "py-python2-command-args"
:group 'python-mode)
;; "/usr/bin/python3"
(defcustom py-python3-command
(if (eq system-type 'windows-nt)
"C:/Python33/python"
"python3")
"A PATH/TO/EXECUTABLE or default value `py-shell' may look for, if
no shell is specified by command.
On Windows see C:/Python3/python.exe
--there is no garantee it exists, please check your system--
At GNU systems see /usr/bin/python3"
:type 'string
:tag "py-python3-command
"
:group 'python-mode)
(defcustom py-python3-command-args '("-i")
"String arguments to be used when starting a Python3 shell."
:type '(repeat string)
:tag "py-python3-command-args"
:group 'python-mode)
(defcustom py-ipython-command
(if (eq system-type 'windows-nt)
;; "ipython"
"C:\\Python27\\python"
;; "C:/Python33/Lib/site-packages/IPython"
;; "/usr/bin/ipython"
"ipython")
"A PATH/TO/EXECUTABLE or default value `M-x IPython RET' may look for, if no IPython-shell is specified by command.
On Windows default is \"C:\\\\Python27\\\\python.exe\"
While with Anaconda for example the following works here:
\"C:\\\\Users\\\\My-User-Name\\\\Anaconda\\\\Scripts\\\\ipython.exe\"
Else /usr/bin/ipython"
:type 'string
:tag "py-ipython-command
"
:group 'python-mode)
(defcustom py-ipython-command-args
(if (eq system-type 'windows-nt)
"-i C:\\Python27\\Scripts\\ipython-script.py"
"--pylab --automagic")
"String arguments to be used when starting a Python shell.
At Windows make sure ipython-script.py is PATH. Also setting PATH/TO/SCRIPT here should work, for example;
C:\\Python27\\Scripts\\ipython-script.py
With Anaconda the following is known to work:
\"C:\\\\Users\\\\My-User-Name\\\\Anaconda\\\\Scripts\\\\ipython-script-py\"
"
:type 'string
:tag "py-ipython-command-args
"
:group 'python-mode)
(defcustom py-jython-command
(if (eq system-type 'windows-nt)
"jython"
"/usr/bin/jython")
"A PATH/TO/EXECUTABLE or default value `M-x Jython RET' may look for, if no Jython-shell is specified by command.
Not known to work at windows
Default /usr/bin/jython"
:type 'string
:tag "py-jython-command
"
:group 'python-mode)
(defcustom py-jython-command-args ""
"String arguments to be used when starting a Python shell."
:type 'string
:tag "py-jython-command-args"
:group 'python-mode)
(defcustom py-shell-toggle-1 py-python2-command
"A PATH/TO/EXECUTABLE or default value used by `py-toggle-shell'. "
:type 'string
:tag "py-shell-toggle-1"
:group 'python-mode)
(defcustom py-shell-toggle-2 py-python3-command
"A PATH/TO/EXECUTABLE or default value used by `py-toggle-shell'. "
:type 'string
:tag "py-shell-toggle-2"
:group 'python-mode)
(defcustom py--imenu-create-index-p nil
"Non-nil means Python mode creates and displays an index menu of functions and global variables. "
:type 'boolean
:tag "py--imenu-create-index-p"
:group 'python-mode)
(defvar py-history-filter-regexp "\\`\\s-*\\S-?\\S-?\\s-*\\'\\|'''/tmp/"
"Input matching this regexp is not saved on the history list.
Default ignores all inputs of 0, 1, or 2 non-blank characters.")
(defcustom py-match-paren-mode nil
"Non-nil means, cursor will jump to beginning or end of a block.
This vice versa, to beginning first.
Sets `py-match-paren-key' in python-mode-map.
Customize `py-match-paren-key' which key to use. "
:type 'boolean
:tag "py-match-paren-mode"
:group 'python-mode)
(defcustom py-match-paren-key "%"
"String used by \\[comment-region] to comment out a block of code.
This should follow the convention for non-indenting comment lines so
that the indentation commands won't get confused (i.e., the string
should be of the form `#x...' where `x' is not a blank or a tab, and
`...' is arbitrary). However, this string should not end in whitespace."
:type 'string
:tag "py-match-paren-key"
:group 'python-mode)
(defcustom py-kill-empty-line t
"If t, py-indent-forward-line kills empty lines. "
:type 'boolean
:tag "py-kill-empty-line"
:group 'python-mode)
(defcustom py-imenu-show-method-args-p nil
"Controls echoing of arguments of functions & methods in the Imenu buffer.
When non-nil, arguments are printed."
:type 'boolean
:tag "py-imenu-show-method-args-p"
:group 'python-mode)
(defcustom py-use-local-default nil
"If `t', py-shell will use `py-shell-local-path' instead
of default Python.
Making switch between several virtualenv's easier,
`python-mode' should deliver an installer, so named-shells pointing to virtualenv's will be available. "
:type 'boolean
:tag "py-use-local-default"
:group 'python-mode)
(defcustom py-edit-only-p nil
"When `t' `python-mode' will not take resort nor check for installed Python executables. Default is nil.
See bug report at launchpad, lp:944093. "
:type 'boolean
:tag "py-edit-only-p"
:group 'python-mode)
(defcustom py-force-py-shell-name-p nil
"When `t', execution with kind of Python specified in `py-shell-name' is enforced, possibly shebang doesn't take precedence. "
:type 'boolean
:tag "py-force-py-shell-name-p"
:group 'python-mode)
(defcustom python-mode-v5-behavior-p nil
"Execute region through `shell-command-on-region' as
v5 did it - lp:990079. This might fail with certain chars - see UnicodeEncodeError lp:550661"
:type 'boolean
:tag "python-mode-v5-behavior-p"
:group 'python-mode)
(defcustom py-trailing-whitespace-smart-delete-p nil
"Default is nil. When t, python-mode calls
(add-hook 'before-save-hook 'delete-trailing-whitespace nil 'local)
Also commands may delete trailing whitespace by the way.
When editing other peoples code, this may produce a larger diff than expected "
:type 'boolean
:tag "py-trailing-whitespace-smart-delete-p"
:group 'python-mode)
(defcustom py-newline-delete-trailing-whitespace-p t
"Delete trailing whitespace maybe left by `py-newline-and-indent'.
Default is `t'. See lp:1100892 "
:type 'boolean
:tag "py-newline-delete-trailing-whitespace-p"
:group 'python-mode)
(defcustom py--warn-tmp-files-left-p nil
"Messages a warning, when `py-temp-directory' contains files susceptible being left by previous Python-mode sessions. See also lp:987534 "
:type 'boolean
:tag "py--warn-tmp-files-left-p"
:group 'python-mode)
(defcustom py-complete-ac-sources '(ac-source-pycomplete)
"List of auto-complete sources assigned to `ac-sources' in `py-complete-initialize'.
Default is known to work an Ubuntu 14.10 - having python-
mode, pymacs and auto-complete-el, with the following minimal
emacs initialization:
\(require 'pymacs)
\(require 'auto-complete-config)
\(ac-config-default)
"
:type 'hook
:tag "py-complete-ac-sources"
:options '(ac-source-pycomplete ac-source-abbrev ac-source-dictionary ac-source-words-in-same-mode-buffers)
:group 'python-mode)
(defcustom py-remove-cwd-from-path t
"Whether to allow loading of Python modules from the current directory.
If this is non-nil, Emacs removes '' from sys.path when starting
a Python process. This is the default, for security
reasons, as it is easy for the Python process to be started
without the user's realization (e.g. to perform completion)."
:type 'boolean
:tag "py-remove-cwd-from-path"
:group 'python-mode)
(defcustom py-shell-local-path ""
"If `py-use-local-default' is non-nil, `py-shell' will use EXECUTABLE indicated here incl. path. "
:type 'string
:tag "py-shell-local-path"
:group 'python-mode)
(defcustom py-python-edit-version ""
"When not empty, fontify according to Python version specified.
Default is the empty string, a useful value \"python3\" maybe.
When empty, version is guessed via `py-choose-shell'. "
:type 'string
:tag "py-python-edit-version"
:group 'python-mode)
(defcustom py-ipython-execute-delay 0.3
"Delay needed by execute functions when no IPython shell is running. "
:type 'float
:tag "py-ipython-execute-delay"
:group 'python-mode)
(defvar py-shell-completion-setup-code
"try:
import readline
except ImportError:
def __COMPLETER_all_completions(text): []
else:
import rlcompleter
readline.set_completer(rlcompleter.Completer().complete)
def __COMPLETER_all_completions(text):
import sys
completions = []
try:
i = 0
while True:
res = readline.get_completer()(text, i)
if not res: break
i += 1
completions.append(res)
except NameError:
pass
return completions"
"Code used to setup completion in Python processes.")
(defvar py-shell-module-completion-code "';'.join(__COMPLETER_all_completions('''%s'''))"
"Python code used to get completions separated by semicolons for imports.")
(defvar py-ipython-module-completion-code
"import IPython
version = IPython.__version__
if \'0.10\' < version:
from IPython.core.completerlib import module_completion
"
"For IPython v0.11 or greater.
Use the following as the value of this variable:
';'.join(module_completion('''%s'''))")
(defvar py-ipython-module-completion-string
"';'.join(module_completion('''%s'''))"
"See also `py-ipython-module-completion-code'")
(defcustom py--imenu-create-index-function 'py--imenu-create-index-new
"Switch between `py--imenu-create-index-new', which also lists modules variables, and series 5. index-machine"
:type '(choice (const :tag "'py--imenu-create-index-new, also lists modules variables " py--imenu-create-index-new)
(const :tag "py--imenu-create-index, series 5. index-machine" py-imenu-create-index))
:tag "py--imenu-create-index-function"
:group 'python-mode)
(defvar py-line-re "^"
"Used by generated functions." )
(defvar py-input-filter-re "\\`\\s-*\\S-?\\S-?\\s-*\\'"
"Input matching this regexp is not saved on the history list.
Default ignores all inputs of 0, 1, or 2 non-blank characters.")
(defvaralias 'inferior-python-filter-regexp 'py-input-filter-re)
(defvar strip-chars-before "\\`[ \t\r\n]*"
"Regexp indicating which chars shall be stripped before STRING - which is defined by `string-chars-preserve'.")
(defvar strip-chars-after "[ \t\r\n]*\\'"
"Regexp indicating which chars shall be stripped after STRING - which is defined by `string-chars-preserve'.")
(defcustom py-docstring-style 'pep-257-nn
"Implemented styles are DJANGO, ONETWO, PEP-257, PEP-257-NN,
SYMMETRIC, and NIL.
A value of NIL won't care about quotes
position and will treat docstrings a normal string, any other
value may result in one of the following docstring styles:
DJANGO:
\"\"\"
Process foo, return bar.
\"\"\"
\"\"\"
Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
ONETWO:
\"\"\"Process foo, return bar.\"\"\"
\"\"\"
Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
PEP-257:
\"\"\"Process foo, return bar.\"\"\"
\"\"\"Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
PEP-257-NN:
\"\"\"Process foo, return bar.\"\"\"
\"\"\"Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
SYMMETRIC:
\"\"\"Process foo, return bar.\"\"\"
\"\"\"
Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\""
:type '(choice
(const :tag "Don't format docstrings" nil)
(const :tag "Django's coding standards style." django)
(const :tag "One newline and start and Two at end style." onetwo)
(const :tag "PEP-257 with 2 newlines at end of string." pep-257)
(const :tag "PEP-257 with 1 newline at end of string." pep-257-nn)
(const :tag "Symmetric style." symmetric))
:tag "py-docstring-style"
:group 'python-mode)
(defcustom py-execute-directory nil
"When set, stores the file's default directory-name py-execute-... functions act upon.
Used by Python-shell for output of `py-execute-buffer' and related commands. See also `py-use-current-dir-when-execute-p'"
:type 'string
:tag "py-execute-directory"
:group 'python-mode)
(defcustom py-use-current-dir-when-execute-p t
"When `t', current directory is used by Python-shell for output of `py-execute-buffer' and related commands.
See also `py-execute-directory'"
:type 'boolean
:tag "py-use-current-dir-when-execute-p"
:group 'python-mode)
(defcustom py-keep-shell-dir-when-execute-p nil
"Don't change Python shell's current working directory when sending code.
See also `py-execute-directory'"
:type 'boolean
:tag "py-keep-shell-dir-when-execute-p"
:group 'python-mode)
(defcustom py-fileless-buffer-use-default-directory-p t
"When `py-use-current-dir-when-execute-p' is non-nil and no buffer-file exists, value of `default-directory' sets current working directory of Python output shell"
:type 'boolean
:tag "py-fileless-buffer-use-default-directory-p"
:group 'python-mode)
(defcustom py-check-command "pychecker --stdlib"
"Command used to check a Python file."
:type 'string
:tag "py-check-command"
:group 'python-mode)
(defvar py-this-abbrevs-changed nil
"Internally used by python-mode-hook")
(defvar py-ffap-p nil)
(defvar py-ffap nil)
(defvar ffap-alist nil)
(defvar py-buffer-name nil
"Internal use. ")
(defvar py-orig-buffer-or-file nil
"Internal use. ")
(defun py--set-ffap-form ()
(cond ((and py-ffap-p py-ffap)
(eval-after-load "ffap"
'(push '(python-mode . py-module-path) ffap-alist))
(setq ffap-alist (remove '(python-mode . py-ffap-module-path) ffap-alist))
(setq ffap-alist (remove '(py-shell-mode . py-ffap-module-path)
ffap-alist)))
(t (setq ffap-alist (remove '(python-mode . py-ffap-module-path) ffap-alist))
(setq ffap-alist (remove '(py-shell-mode . py-ffap-module-path)
ffap-alist))
(setq ffap-alist (remove '(python-mode . py-module-path) ffap-alist)))))
(defcustom py-ffap-p nil
"Select python-modes way to find file at point.
Default is nil "
:type '(choice
(const :tag "default" nil)
(const :tag "use py-ffap" py-ffap))
:tag "py-ffap-p"
:set (lambda (symbol value)
(set-default symbol value)
(py--set-ffap-form))
:group 'python-mode)
(defcustom py-keep-windows-configuration nil
"Takes precedence over `py-split-window-on-execute' and `py-switch-buffers-on-execute-p'.
See lp:1239498
To suppres window-changes due to error-signaling also, set `py-keep-windows-configuration' onto 'force
Default is nil "
:type '(choice
(const :tag "nil" nil)
(const :tag "t" t)
(const :tag "force" 'force))
:tag "py-keep-windows-configuration"
:group 'python-mode)
(defvar py-output-buffer "*Python Output*"
"Currently unused.
Output buffer is created dynamically according to Python version and kind of process-handling")
(make-variable-buffer-local 'py-output-buffer)
(defvar py-ffap-string-code
"__FFAP_get_module_path('''%s''')\n"
"Python code used to get a string with the path of a module.")
(defcustom py-shell-prompt-regexp ">>> "
"Regular Expression matching top\-level input prompt of python shell.
It should not contain a caret (^) at the beginning."
:type 'string
:tag "py-shell-prompt-regexp"
:group 'python-mode)
(defvar py-ffap-setup-code
"def __FFAP_get_module_path(module):
try:
import os
path = __import__(module).__file__
if path[-4:] == '.pyc' and os.path.exists(path[0:-1]):
path = path[:-1]
return path
except:
return ''
"
"Python code to get a module path.")
(defvar py-eldoc-window-configuration nil
"Keeps window-configuration when eldoc-mode is called. ")
(defvar py-eldoc-setup-code
"def __PYDOC_get_help(obj):
try:
import inspect
if hasattr(obj, 'startswith'):
obj = eval(obj, globals())
doc = inspect.getdoc(obj)
if not doc and callable(obj):
target = None
if inspect.isclass(obj) and hasattr(obj, '__init__'):
target = obj.__init__
objtype = 'class'
else:
target = obj
objtype = 'def'
if target:
args = inspect.formatargspec(
*inspect.getargspec(target))
name = obj.__name__
doc = '{objtype} {name}{args}'.format(
objtype=objtype, name=name, args=args)
else:
doc = doc.splitlines()[0]
except:
doc = ''
try:
exec('print doc')
except SyntaxError:
print(doc)"
"Python code to setup documentation retrieval.")
(defcustom py-shell-prompt-output-regexp ""
"Regular Expression matching output prompt of python shell.
It should not contain a caret (^) at the beginning."
:type 'string
:tag "py-shell-prompt-output-regexp"
:group 'python-mode)
(defvar py-underscore-word-syntax-p t
"This is set later by defcustom, only initial value here.
If underscore chars should be of syntax-class `word', not of `symbol'.
Underscores in word-class makes `forward-word' etc. travel the indentifiers. Default is `t'.
See also command `toggle-py-underscore-word-syntax-p' ")
(defvar py-autofill-timer nil)
(defvar py-fill-column-orig fill-column)
;; defvared value isn't updated maybe
(defvar python-mode-message-string
(if (or (string= "python-mode.el" (buffer-name))
(ignore-errors (string-match "python-mode.el" (py--buffer-filename-remote-maybe))))
"python-mode.el"
"python-components-mode")
"Internally used. Reports the python-mode branch")
;; defvared value isn't updated maybe
(setq python-mode-message-string
(if (or (string= "python-mode.el" (buffer-name))
(ignore-errors (string-match "python-mode.el" (py--buffer-filename-remote-maybe))))
"python-mode.el"
"python-components-mode"))
(unless (fboundp 'string-to-syntax)
;; Skip's XE workaround
(defun string-to-syntax (s)
(cond
((equal s "|") '(15))
((equal s "_") '(3))
(t (error "Unhandled string: %s" s)))))
(defvar python-mode-syntax-table nil
"Give punctuation syntax to ASCII that normally has symbol
syntax or has word syntax and isn't a letter.")
(setq 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)
(if py-underscore-word-syntax-p
(modify-syntax-entry ?\_ "w" table)
(modify-syntax-entry ?\_ "_" table))
table))
(defvar py-local-command nil
"Returns locally used executable-name. ")
(make-variable-buffer-local 'py-local-command)
(defvar py-local-versioned-command nil
"Returns locally used executable-name including its version. ")
(make-variable-buffer-local 'py-local-versioned-command)
(defvar py-ipython-completion-command-string nil
"Either py-ipython0.10-completion-command-string or py-ipython0.11-completion-command-string.
py-ipython0.11-completion-command-string also covers version 0.12")
(defvar py-ipython0.10-completion-command-string
"print(';'.join(__IP.Completer.all_completions('%s'))) #PYTHON-MODE SILENT\n"
"The string send to ipython to query for all possible completions")
(defvar py-ipython0.11-completion-command-string
"print(';'.join(get_ipython().Completer.all_completions('%s'))) #PYTHON-MODE SILENT\n"
"The string send to ipython to query for all possible completions")
(defvar py-encoding-string-re "^[ \t]*#[ \t]*-\\*-[ \t]*coding:.+-\\*-"
"Matches encoding string of a Python file. ")
(defvar py-shebang-regexp "#![ \t]?\\([^ \t\n]+\\)[ \t]*\\([biptj]+ython[^ \t\n]*\\)"
"Detecting the shell in head of file. ")
;; (setq py-shebang-regexp "#![ \t]?\\([^ \t\n]+\\)[ \t]*\\([biptj]+ython[^ \t\n]*\\)")
(defvar py-separator-char "/"
"Values set by defcustom only will not be seen in batch-mode. ")
(defvar py-temp-directory
(let ((ok '(lambda (x)
(and x
(setq x (expand-file-name x)) ; always true
(file-directory-p x)
(file-writable-p x)
x)))
erg)
(or
(and (not (string= "" py-custom-temp-directory))
(if (funcall ok py-custom-temp-directory)
(setq erg (expand-file-name py-custom-temp-directory))
(if (file-directory-p (expand-file-name py-custom-temp-directory))
(error "py-custom-temp-directory set but not writable")
(error "py-custom-temp-directory not an existing directory"))))
(and (funcall ok (getenv "TMPDIR"))
(setq erg (getenv "TMPDIR")))
(and (funcall ok (getenv "TEMP/TMP"))
(setq erg (getenv "TEMP/TMP")))
(and (funcall ok "/usr/tmp")
(setq erg "/usr/tmp"))
(and (funcall ok "/tmp")
(setq erg "/tmp"))
(and (funcall ok "/var/tmp")
(setq erg "/var/tmp"))
(and (eq system-type 'darwin)
(funcall ok "/var/folders")
(setq erg "/var/folders"))
(and (or (eq system-type 'ms-dos)(eq system-type 'windows-nt))
(funcall ok (concat "c:" py-separator-char "Users"))
(setq erg (concat "c:" py-separator-char "Users")))
;; (funcall ok ".")
(error
"Couldn't find a usable temp directory -- set `py-temp-directory'"))
(when erg (setq py-temp-directory erg)))
"Directory used for temporary files created by a *Python* process.
By default, guesses the first directory from this list that exists and that you
can write into: the value (if any) of the environment variable TMPDIR,
/usr/tmp, /tmp, /var/tmp, or the current directory.
`py-custom-temp-directory' will take precedence when setq ")
(defvar py-pdbtrack-input-prompt "^[(<]*[Ii]?[Pp]y?db[>)]+ "
"Recognize the prompt. ")
(defvar py-pydbtrack-input-prompt "^[(]*ipydb[>)]+ "
"Recognize the pydb-prompt. ")
(defvar py-ipython-input-prompt-re "In \\[[0-9]+\\]:\\|^[ ]\\{3\\}[.]\\{3,\\}:"
"A regular expression to match the IPython input prompt. ")
;; prevent ipython.el's setting
(setq py-ipython-input-prompt-re "In \\[[0-9]+\\]:\\|^[ ]\\{3\\}[.]\\{3,\\}:" )
(defvar py-exec-command nil
"Internally used. ")
(defvar py-which-bufname "Python")
(defvar py-pychecker-history nil)
(defvar py-pyflakes-history nil)
(defvar py-pep8-history nil)
(defvar py-pyflakespep8-history nil)
(defvar py-pylint-history nil)
(defvar py-ipython-output-prompt-re "^Out\\[[0-9]+\\]: "
"A regular expression to match the output prompt of IPython.")
(defvar py-mode-output-map nil
"Keymap used in *Python Output* buffers.")
(defvar hs-hide-comments-when-hiding-all t
"Defined in hideshow.el, silence compiler warnings here. ")
(defvar py-force-local-shell-p nil
"Used internally, see `toggle-force-local-shell'. ")
(defvar py-shell-complete-debug nil
"For interal use when debugging, stores completions." )
(defcustom py-debug-p nil
"When non-nil, keep resp. store information useful for debugging.
Temporary files are not deleted. Other functions might implement
some logging etc. "
:type 'boolean
:tag "py-debug-p"
:group 'python-mode)
(defcustom py-section-start "# {{"
"Delimit arbitrary chunks of code. "
:type 'string
:tag "py-section-start"
:group 'python-mode)
(defcustom py-section-end "# }}"
"Delimit arbitrary chunks of code. "
:type 'string
:tag "py-section-end"
:group 'python-mode)
(defvar py-section-re py-section-start)
(defvar py-last-window-configuration nil
"Internal use: restore py-restore-window-configuration when completion is done resp. abandoned. ")
(defvar py-exception-buffer nil
"Will be set internally, let-bound, remember source buffer where error might occur. ")
(defvar py-string-delim-re "\\(\"\"\"\\|'''\\|\"\\|'\\)"
"When looking at beginning of string. ")
(defvar py-labelled-re "[ \\t]*:[[:graph:]]+"
"When looking at label. ")
;; (setq py-labelled-re "[ \\t]*:[[:graph:]]+")
(defvar py-expression-skip-regexp "[^ (=:#\t\r\n\f]"
"py-expression assumes chars indicated possible composing a py-expression, skip it. ")
(defvar py-expression-skip-chars "^ (=#\t\r\n\f"
"py-expression assumes chars indicated possible composing a py-expression, skip it. ")
(setq py-expression-skip-chars "^ [{(=#\t\r\n\f")
(defvar py-expression-re "[^ =#\t\r\n\f]+"
"py-expression assumes chars indicated possible composing a py-expression, when looking-at or -back. ")
(defcustom py-paragraph-re paragraph-start
"Allow Python specific paragraph-start var"
:type 'string
:tag "py-paragraph-re"
:group 'python-mode)
(defvar py-not-expression-regexp "[ .=#\t\r\n\f)]+"
"py-expression assumes chars indicated probably will not compose a py-expression. ")
(defvar py-not-expression-chars " #\t\r\n\f"
"py-expression assumes chars indicated probably will not compose a py-expression. ")
(defvar py-partial-expression-backward-chars "^] .=,\"'()[{}:#\t\r\n\f"
"py-partial-expression assumes chars indicated possible composing a py-partial-expression, skip it. ")
;; (setq py-partial-expression-backward-chars "^] .=,\"'()[{}:#\t\r\n\f")
(defvar py-partial-expression-forward-chars "^ .\"')}]:#\t\r\n\f")
;; (setq py-partial-expression-forward-chars "^ .\"')}]:#\t\r\n\f")
(defvar py-partial-expression-re (concat "[" py-partial-expression-backward-chars (substring py-partial-expression-forward-chars 1) "]+"))
(setq py-partial-expression-re (concat "[" py-partial-expression-backward-chars "]+"))
(defvar py-statement-re py-partial-expression-re)
(defvar py-indent-re ".+"
"This var is introduced for regularity only")
(setq py-indent-re ".+")
(defvar py-operator-re "[ \t]*\\(\\.\\|+\\|-\\|*\\|//\\|//\\|&\\|%\\||\\|\\^\\|>>\\|<<\\|<\\|<=\\|>\\|>=\\|==\\|!=\\|=\\)[ \t]*"
"Matches most of Python syntactical meaningful characters, inclusive whitespaces around.
See also `py-assignment-re' ")
;; (setq py-operator-re "[ \t]*\\(\\.\\|+\\|-\\|*\\|//\\|//\\|&\\|%\\||\\|\\^\\|>>\\|<<\\|<\\|<=\\|>\\|>=\\|==\\|!=\\|=\\)[ \t]*")
(defvar py-assignment-re "[ \t]*=[^=]"
"Matches assignment operator inclusive whitespaces around.
See also `py-operator-re' ")
(defvar py-delimiter-re "\\(\\.[[:alnum:]]\\|,\\|;\\|:\\)[ \t\n]"
"Delimiting elements of lists or other programming constructs. ")
(defvar py-line-number-offset 0
"When an exception occurs as a result of py-execute-region, a
subsequent py-up-exception needs the line number where the region
started, in order to jump to the correct file line. This variable is
set in py-execute-region and used in py--jump-to-exception.")
(defvar py-match-paren-no-use-syntax-pps nil)
(defvar py-traceback-line-re
"[ \t]+File \"\\([^\"]+\\)\", line \\([0-9]+\\)"
"Regular expression that describes tracebacks.")
(defvar py-XXX-tag-face 'py-XXX-tag-face)
(defvar py-pseudo-keyword-face 'py-pseudo-keyword-face)
(defvar py-variable-name-face 'py-variable-name-face)
(defvar py-number-face 'py-number-face)
(defvar py-decorators-face 'py-decorators-face)
(defvar py-object-reference-face 'py-object-reference-face)
(defvar py-builtins-face 'py-builtins-face)
(defvar py-class-name-face 'py-class-name-face)
(defvar py-exception-name-face 'py-exception-name-face)
(defvar py-import-from-face 'py-import-from-face)
(defvar py-def-class-face 'py-def-class-face)
(defvar py-try-if-face 'py-try-if-face)
(defvar py-file-queue nil
"Queue of Python temp files awaiting execution.
Currently-active file is at the head of the list.")
(defvar jython-mode-hook nil
"Hook called by `jython-mode'. `jython-mode' also calls
`python-mode-hook'.")
(defvar py-shell-hook nil
"Hook called by `py-shell'.")
(defvar python-font-lock-keywords nil)
(defvar py-dotted-expression-syntax-table
(let ((table (make-syntax-table python-mode-syntax-table)))
(modify-syntax-entry ?_ "_" table)
(modify-syntax-entry ?. "_" table)
table)
"Syntax table used to identify Python dotted expressions.")
(defvar python-default-template "if"
"Default template to expand by `python-expand-template'.
Updated on each expansion.")
(defvar py-already-guessed-indent-offset nil
"Internal use by py-indent-line.
When `this-command' is `eq' to `last-command', use the guess already computed. ")
(make-variable-buffer-local 'py-already-guessed-indent-offset)
(defvar py-shell-template "
\(defun NAME (&optional argprompt)
\"Start an DOCNAME interpreter in another window.
With optional \\\\[universal-argument] user is prompted
for options to pass to the DOCNAME interpreter. \"
(interactive \"P\")
(let\* ((py-shell-name \"FULLNAME\"))
(py-shell argprompt)
(when (called-interactively-p 'any) (switch-to-buffer (current-buffer))
(goto-char (point-max)))))
")
(defvar py-fast-filter-re (concat "\\("
(mapconcat 'identity
(delq nil (list py-shell-input-prompt-1-regexp py-shell-input-prompt-2-regexp py-ipython-input-prompt-re py-ipython-output-prompt-re py-pdbtrack-input-prompt py-pydbtrack-input-prompt "[.]\\{3,\\}:? *"))
"\\|")
"\\)")
"Internally used by `py-fast-filter'.
ansi-color-filter-apply might return
Result: \"\\nIn [10]: ....: ....: ....: 1\\n\\nIn [11]: \"
")
;; Constants
(defconst py-block-closing-keywords-re
"[ \t]*\\_<\\(return\\|raise\\|break\\|continue\\|pass\\)\\_>[ \n\t]"
"Matches the beginning of a class, method or compound statement. ")
(setq py-block-closing-keywords-re
"[ \t]*\\_[ \n\t]")
(defconst py-finally-re
"[ \t]*\\_[: \n\t]"
"Regular expression matching keyword which closes a try-block. ")
(defconst py-except-re
"[ \t]*\\_[:( \n\t]*"
"Regular expression matching keyword which composes a try-block. ")
;; (defconst py-else-re
;; "[ \t]*\\_[ \n\t]*"
;; "Regular expression matching keyword which closes a for- if- or try-block. ")
(defconst py-return-re
".*:?[ \t]*\\_<\\(return\\)\\_>[ \n\t]*"
"Regular expression matching keyword which typically closes a function. ")
(defconst py-decorator-re
"[ \t]*@[^ ]+\\_>[ \n\t]*"
"Regular expression matching keyword which typically closes a function. ")
(defcustom py-outdent-re-raw
(list
"async def"
"async for"
"async with"
"class"
"def"
"elif"
"else"
"except"
"for"
"if"
"try"
"while"
"with")
""
:type '(repeat string)
:tag "py-outdent-re-raw"
:group 'python-mode
)
(defconst py-outdent-re
(concat
"[ \t]*\\_<"
(regexp-opt py-outdent-re-raw)
"\\_>[)\t]*")
"Regular expression matching lines not to augment indent after.
See py-no-outdent-re-raw for better readable content ")
(defcustom py-no-outdent-re-raw
(list
"break"
"continue"
"import"
"pass"
"raise"
"return")
""
:type '(repeat string)
:tag "py-no-outdent-re-raw"
:group 'python-mode)
(defconst py-no-outdent-re
(concat
"[ \t]*\\_<"
(regexp-opt py-no-outdent-re-raw)
"\\_>[)\t]*$")
"Regular expression matching lines not to augment indent after.
See py-no-outdent-re-raw for better readable content ")
(defconst py-assignment-re "\\_<\\w+\\_>[ \t]*\\(=\\|+=\\|*=\\|%=\\|&=\\|^=\\|<<=\\|-=\\|/=\\|**=\\||=\\|>>=\\|//=\\)"
"If looking at the beginning of an assignment. ")
(defconst py-block-re "[ \t]*\\_<\\(class\\|def\\|async def\\|async for\\|for\\|if\\|try\\|while\\|with\\|async with\\)\\_>[:( \n\t]*"
"Matches the beginning of a compound statement. ")
(defconst py-minor-block-re "[ \t]*\\_<\\(for\\|async for\\|if\\|try\\|with\\|async with\\|except\\)\\_>[:( \n\t]*"
"Matches the beginning of an `for', `if', `try', `except' or `with' block. ")
(defconst py-try-block-re "[ \t]*\\_[: \n\t]"
"Matches the beginning of a `try' block. ")
(defconst py-except-block-re "[ \t]*\\_ *a?s? *[[:print:]]*[: \n\t]"
"Matches the beginning of a `except' block. ")
(defconst py-for-block-re "[ \t]*\\_<\\(for\\|async for\\)\\_> +[[:alpha:]_][[:alnum:]_]* +in +[[:alpha:]_][[:alnum:]_()]* *[: \n\t]"
"Matches the beginning of a `try' block. ")
(defconst py-if-block-re "[ \t]*\\_ +[[:alpha:]_][[:alnum:]_]* *[: \n\t]"
"Matches the beginning of an `if' block. ")
(defconst py-else-block-re "[ \t]*\\_ +[[:alpha:]_][[:alnum:]_]* *[: \n\t]"
"Matches the beginning of an `elif' block. ")
(defconst py-class-re "[ \t]*\\_<\\(class\\)\\_>[ \n\t]"
"Matches the beginning of a class definition. ")
(defconst py-def-or-class-re "[ \t]*\\_<\\(async def\\|class\\|def\\)\\_>[ \n\t]"
"Matches the beginning of a class- or functions definition. ")
;; (setq py-def-or-class-re "[ \t]*\\_<\\(async def\\|class\\|def\\)\\_>[ \n\t]")
;; (defconst py-def-re "[ \t]*\\_<\\(async def\\|def\\)\\_>[ \n\t]"
(defconst py-def-re "[ \t]*\\_<\\(def\\|async def\\)\\_>[ \n\t]"
"Matches the beginning of a functions definition. ")
(defcustom py-block-or-clause-re-raw
(list
"async for"
"async with"
"elif"
"else"
"except"
"finally"
"for"
"if"
"try"
"while"
"with"
)
"Matches the beginning of a compound statement or it's clause. "
:type '(repeat string)
:tag "py-block-or-clause-re-raw"
:group 'python-mode)
(defvar py-block-or-clause-re
(concat
"[ \t]*\\_<\\("
(regexp-opt py-block-or-clause-re-raw)
"\\)\\_>[( \t]*.*:?")
"See py-block-or-clause-re-raw, which it reads. ")
(defcustom py-block-re-raw
(list
"except"
"for"
"if"
"try"
"while"
"with")
"Matches the beginning of a compound statement but not it's clause. "
:type '(repeat string)
:tag "py-block-re-raw"
:group 'python-mode)
(defvar py-block-re
(concat
"[ \t]*\\_<\\("
(regexp-opt py-block-re-raw)
"\\)\\_>[( \t]*.*:?")
"See py-block-or-clause-re-raw, which it reads. ")
(defconst py-clause-re
(concat
"[ \t]*\\_<\\("
(mapconcat 'identity
(list
"elif"
"else"
"except"
"finally")
"\\|")
"\\)\\_>[( \t]*.*:?")
"Regular expression matching lines not to augment indent after.")
(defcustom py-extended-block-or-clause-re-raw
(list
"async def"
"async for"
"async with"
"class"
"def"
"elif"
"else"
"except"
"finally"
"for"
"if"
"try"
"while"
"with")
"Matches the beginning of a compound statement or it's clause. "
:type '(repeat string)
:tag "py-extended-block-or-clause-re-raw"
:group 'python-mode)
(defconst py-extended-block-or-clause-re
(concat
"[ \t]*\\_<\\("
(regexp-opt py-extended-block-or-clause-re-raw)
"\\)\\_>[( \t]*.*:?")
"See py-block-or-clause-re-raw, which it reads. ")
(defcustom py-top-level-re
(concat
"^\\_<[a-zA-Z_]\\|^\\_<\\("
(regexp-opt py-extended-block-or-clause-re-raw)
"\\)\\_>[( \t]*.*:?")
"A form which starts at zero indent level, but is not a comment. "
:type '(regexp)
:tag "py-top-level-re"
:group 'python-mode
)
(defvar py-comment-re comment-start
"Needed for normalized processing")
(defconst py-block-keywords
(concat
"\\_<\\("
(regexp-opt py-block-or-clause-re-raw)
"\\)\\_>")
"Matches known keywords opening a block.
Customizing `py-block-or-clause-re-raw' will change values here")
(defcustom py-clause-re-raw
(list
"elif"
"else"
"except"
"finally"
)
"Matches the beginning of a clause. "
:type '(repeat string)
:tag "py-clause-re-raw"
:group 'python-mode)
(defconst py-clause-re
(concat
"[ \t]*\\_<\\("
(regexp-opt py-clause-re-raw)
"\\)\\_>[( \t]*.*:?")
"See py-clause-re-raw, which it reads. ")
(defconst py-elif-re "[ \t]*\\_<\\elif\\_>[:( \n\t]*"
"Matches the beginning of a compound if-statement's clause exclusively. ")
(defconst py-try-clause-re
(concat
"[ \t]*\\_<\\("
(mapconcat 'identity
(list
"else"
"except"
"finally")
"\\|")
"\\)\\_>[( \t]*.*:")
"Matches the beginning of a compound try-statement's clause. ")
(defconst py-if-re "[ \t]*\\_[( \n\t]*"
"Matches the beginning of a compound statement saying `if'. ")
(defconst py-try-re "[ \t]*\\_[:( \n\t]*"
"Matches the beginning of a compound statement saying `try'. " )
(defcustom py-compilation-regexp-alist
`((,(rx line-start (1+ (any " \t")) "File \""
(group (1+ (not (any "\"<")))) ; avoid `' &c
"\", line " (group (1+ digit)))
1 2)
(,(rx " in file " (group (1+ not-newline)) " on line "
(group (1+ digit)))
1 2)
(,(rx line-start "> " (group (1+ (not (any "(\"<"))))
"(" (group (1+ digit)) ")" (1+ (not (any "("))) "()")
1 2))
"Fetch errors from Py-shell.
hooked into `compilation-error-regexp-alist' "
:type '(alist string)
:tag "py-compilation-regexp-alist"
:group 'python-mode)
(defun py--quote-syntax (n)
"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))
(cond
;; Consider property for the last char if in a fenced string.
((= n 3)
(let* ((font-lock-syntactic-keywords nil)
(syntax (parse-partial-sexp (point-min) (point))))
(when (eq t (nth 3 syntax)) ; after unclosed fence
(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)))
(eval-when-compile (string-to-syntax "|"))))))
;; Consider property for initial char, accounting for prefixes.
((or (and (= n 2) ; leading quote (not prefix)
(not (match-end 1))) ; prefix is null
(and (= n 1) ; prefix
(match-end 1))) ; non-empty
(let ((font-lock-syntactic-keywords nil))
(unless (eq 'string (syntax-ppss-context (parse-partial-sexp (point-min) (point))))
(eval-when-compile (string-to-syntax "|")))))
;; Otherwise (we're in a non-matching string) the property is
;; nil, which is OK.
)))
(defconst py-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 "\\(?:^\\|[^\\]\\(?:\\\\.\\)*\\)" ;Prefix.
"\\(?1:\"\\)\\(?2:\"\\)\\(?3:\"\\)\\(?4:\"\\)\\(?5:\"\\)\\(?6:\"\\)\\|\\(?1:\"\\)\\(?2:\"\\)\\(?3:\"\\)\\|\\(?1:'\\)\\(?2:'\\)\\(?3:'\\)\\(?4:'\\)\\(?5:'\\)\\(?6:'\\)\\|\\(?1:'\\)\\(?2:'\\)\\(?3:'\\)\\(?4:'\\)\\(?5:'\\)\\(?6:'\\)\\|\\(?1:'\\)\\(?2:'\\)\\(?3:'\\)")
(1 (py--quote-syntax 1) t t)
(2 (py--quote-syntax 2) t t)
(3 (py--quote-syntax 3) t t)
(6 (py--quote-syntax 1) t t))))
(defconst py-windows-config-register 313465889
"Internal used")
(defvar py-windows-config nil
"Completion stores py-windows-config-register here")
(put 'py-indent-offset 'safe-local-variable 'integerp)
;; testing
(defvar py-ert-test-default-executables
(list "python" "python3" "ipython")
"Serialize tests employing dolist")
(defvar py--shell-unfontify nil
"Internally used by `py--run-unfontify-timer'. ")
(make-variable-buffer-local 'py--shell-unfontify)
(defvar py--timer nil
"Used by `py--run-unfontify-timer'")
(make-variable-buffer-local 'py--timer)
(defvar py--timer-delay nil
"Used by `py--run-unfontify-timer'")
(make-variable-buffer-local 'py--timer-delay)
(defcustom py-shell-unfontify-p t
"Run `py--run-unfontify-timer' unfontifying the shell banner-text.
Default is nil "
:type 'boolean
:tag "py-shell-unfontify-p"
:group 'python-mode)
(defun py--unfontify-banner-intern (buffer)
(save-excursion
(goto-char (point-min))
(let ((erg (or (ignore-errors (car comint-last-prompt))
(and
(re-search-forward py-fast-filter-re nil t 1)
(match-beginning 0))
(progn
(forward-paragraph)
(point)))))
;; (sit-for 1 t)
(if erg
(progn
(font-lock-unfontify-region (point-min) erg)
(goto-char (point-max)))
(progn (and py-debug-p (message "%s" (concat "py--unfontify-banner: Don't see a prompt in buffer " (buffer-name buffer)))))))))
(defun py--unfontify-banner (&optional buffer)
"Unfontify the shell banner-text.
Cancels `py--timer'
Expects being called by `py--run-unfontify-timer' "
(interactive)
(let ((buffer (or buffer (current-buffer))))
(if (ignore-errors (buffer-live-p (get-buffer buffer)))
(with-current-buffer buffer
(py--unfontify-banner-intern buffer)
(and (timerp py--timer)(cancel-timer py--timer)))
(and (timerp py--timer)(cancel-timer py--timer)))))
(defun py--run-unfontify-timer (&optional buffer)
"Unfontify the shell banner-text "
(when py--shell-unfontify
(let ((buffer (or buffer (current-buffer))))
(if (and
(buffer-live-p buffer)
(or
(eq major-mode 'py-python-shell-mode)
(eq major-mode 'py-ipython-shell-mode)))
(unless py--timer
(setq py--timer
(run-with-idle-timer
(if py--timer-delay (setq py--timer-delay 3)
(setq py--timer-delay 0.1))
nil
#'py--unfontify-banner buffer)))
(cancel-timer py--timer)))))
(defsubst py-keep-region-active ()
"Keep the region active in XEmacs."
(and (boundp 'zmacs-region-stays)
(setq zmacs-region-stays t)))
;; GNU's syntax-ppss-context
(unless (functionp 'syntax-ppss-context)
(defsubst syntax-ppss-context (ppss)
(cond
((nth 3 ppss) 'string)
((nth 4 ppss) 'comment)
(t nil))))
(defface py-XXX-tag-face
'((t (:inherit font-lock-string-face)))
"XXX\\|TODO\\|FIXME "
:tag "py-XXX-tag-face"
:group 'python-mode)
(defface py-pseudo-keyword-face
'((t (:inherit font-lock-keyword-face)))
"Face for pseudo keywords in Python mode, like self, True, False,
Ellipsis.
See also `py-object-reference-face'"
:tag "py-pseudo-keyword-face"
:group 'python-mode)
(defface py-object-reference-face
'((t (:inherit py-pseudo-keyword-face)))
"Face when referencing object members from its class resp. method., commonly \"cls\" and \"self\""
:tag "py-object-reference-face"
:group 'python-mode)
(defface py-variable-name-face
'((t (:inherit default)))
"Face method decorators."
:tag "py-variable-name-face"
:group 'python-mode)
(defface py-number-face
'((t (:inherit default)))
"Highlight numbers. "
:tag "py-number-face"
:group 'python-mode)
(defface py-try-if-face
'((t (:inherit font-lock-keyword-face)))
"Highlight keywords. "
:tag "py-try-if-face"
:group 'python-mode)
(defface py-import-from-face
'((t (:inherit font-lock-keyword-face)))
"Highlight keywords. "
:tag "py-import-from-face"
:group 'python-mode)
(defface py-def-class-face
'((t (:inherit font-lock-keyword-face)))
"Highlight keywords. "
:tag "py-def-class-face"
:group 'python-mode)
;; PEP 318 decorators
(defface py-decorators-face
'((t (:inherit font-lock-keyword-face)))
"Face method decorators."
:tag "py-decorators-face"
:group 'python-mode)
(defface py-builtins-face
'((t (:inherit font-lock-builtin-face)))
"Face for builtins like TypeError, object, open, and exec."
:tag "py-builtins-face"
:group 'python-mode)
(defface py-class-name-face
'((t (:inherit font-lock-type-face)))
"Face for classes."
:tag "py-class-name-face"
:group 'python-mode)
(defface py-exception-name-face
'((t (:inherit font-lock-builtin-face)))
"."
:tag "py-exception-name-face"
:group 'python-mode)
(defun py--python-send-setup-code-intern (name &optional msg)
(let ((setup-file (concat (py--normalize-directory py-temp-directory) "py-" name "-setup-code.py"))
(buf (current-buffer)))
(unless (file-readable-p setup-file)
(with-temp-buffer
(insert (eval (car (read-from-string (concat "py-" name "-setup-code")))))
(write-file setup-file)))
(py--execute-file-base nil setup-file nil buf)
(when msg (message "%s" (concat name " setup-code sent to " (process-name (get-buffer-process buf)))))))
(defun py--python-send-completion-setup-code ()
"For Python see py--python-send-setup-code "
(py--python-send-setup-code-intern "shell-completion" py-verbose-p))
(defun py--python-send-ffap-setup-code ()
"For Python see py--python-send-setup-code "
(py--python-send-setup-code-intern "ffap" py-verbose-p))
(defun py--python-send-eldoc-setup-code ()
"For Python see py--python-send-setup-code "
(py--python-send-setup-code-intern "eldoc" py-verbose-p))
(defun py--ipython-import-module-completion ()
"Setup IPython v0.11 or greater.
Used by `py-ipython-module-completion-string'"
(let ((setup-file (concat (py--normalize-directory py-temp-directory) "py-ipython-module-completion.py")))
(unless (file-readable-p setup-file)
(with-temp-buffer
(insert py-ipython-module-completion-code)
(write-file setup-file)))
(py--execute-file-base nil setup-file nil (current-buffer))))
(defun py--at-raw-string ()
"If at beginning of a raw-string. "
(looking-at "\"\"\"\\|'''") (member (char-before) (list ?u ?U ?r ?R)))
(defun py--docstring-p (&optional beginning-of-string-position)
"Check to see if there is a docstring at POS."
(let* (pps
(pos (or beginning-of-string-position
(and (nth 3 (setq pps (parse-partial-sexp (point-min) (point)))) (nth 8 pps)))))
(save-restriction
(widen)
(save-excursion
(goto-char pos)
(when (py--at-raw-string)
(forward-char -1)
(setq pos (point)))
(when (py-backward-statement)
(when (looking-at py-def-or-class-re)
pos))))))
(defun py--font-lock-syntactic-face-function (state)
(if (nth 3 state)
(if (py--docstring-p (nth 8 state))
font-lock-doc-face
font-lock-string-face)
font-lock-comment-face))
(and (fboundp 'make-obsolete-variable)
(make-obsolete-variable 'py-mode-hook 'python-mode-hook nil))
(defun py-choose-shell-by-shebang (&optional shebang)
"Choose shell by looking at #! on the first line.
If SHEBANG is non-nil, returns the shebang as string,
otherwise the Python resp. Jython shell command name. "
(interactive)
;; look for an interpreter specified in the first line
(let* (erg res)
(save-excursion
(goto-char (point-min))
(when (looking-at py-shebang-regexp)
(if shebang
(setq erg (match-string-no-properties 0))
(setq erg (split-string (match-string-no-properties 0) "[#! \t]"))
(dolist (ele erg)
(when (string-match "[bijp]+ython" ele)
(setq res ele))))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" res))
res))
(defun py--choose-shell-by-import ()
"Choose CPython or Jython mode based imports.
If a file imports any packages in `py-jython-packages', within
`py-import-check-point-max' characters from the start of the file,
return `jython', otherwise return nil."
(let (mode)
(save-excursion
(goto-char (point-min))
(while (and (not mode)
(search-forward-regexp
"^\\(\\(from\\)\\|\\(import\\)\\) \\([^ \t\n.]+\\)"
py-import-check-point-max t))
(setq mode (and (member (match-string 4) py-jython-packages)
'jython))))
mode))
(defun py-choose-shell-by-path (&optional separator-char)
"Select Python executable according to version desplayed in path, current buffer-file is selected from.
Returns versioned string, nil if nothing appropriate found "
(interactive)
(let ((path (py--buffer-filename-remote-maybe))
(separator-char (or separator-char py-separator-char))
erg)
(when (and path separator-char
(string-match (concat separator-char "[iI]?[pP]ython[0-9.]+" separator-char) path))
(setq erg (substring path
(1+ (string-match (concat separator-char "[iI]?[pP]ython[0-9.]+" separator-char) path)) (1- (match-end 0)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-which-python (&optional shell)
"Returns version of Python of current environment, a number. "
(interactive)
(let* ((cmd (or shell (py-choose-shell)))
(treffer (string-match "\\([23]*\\.?[0-9\\.]*\\)$" cmd))
version erg)
(if treffer
;; if a number if part of python name, assume it's the version
(setq version (substring-no-properties cmd treffer))
(setq erg (shell-command-to-string (concat cmd " --version")))
(setq version (cond ((string-match (concat "\\(on top of Python \\)" "\\([0-9]\\.[0-9]+\\)") erg)
(match-string-no-properties 2 erg))
((string-match "\\([0-9]\\.[0-9]+\\)" erg)
(substring erg 7 (1- (length erg)))))))
(when (called-interactively-p 'any)
(if version
(when py-verbose-p (message "%s" version))
(message "%s" "Could not detect Python on your system")))
(string-to-number version)))
(defun py-python-current-environment ()
"Returns path of current Python installation. "
(interactive)
(let* ((cmd (py-choose-shell))
(denv (shell-command-to-string (concat "type " cmd)))
(erg (substring denv (string-match "/" denv))))
(when (called-interactively-p 'any)
(if erg
(message "%s" erg)
(message "%s" "Could not detect Python on your system")))
erg))
;; requested by org-mode still
(defalias 'py-toggle-shells 'py-choose-shell)
(defun py--cleanup-process-name (res)
"Make res ready for use by `executable-find'
Returns RES or substring of RES"
(if (string-match "<" res)
(substring res 0 (match-beginning 0))
res))
(defalias 'py-which-shell 'py-choose-shell)
(defun py-choose-shell (&optional arg fast)
"Return an appropriate executable as a string.
Returns nil, if no executable found.
This does the following:
- look for an interpreter with `py-choose-shell-by-shebang'
- examine imports using `py--choose-shell-by-import'
- look if Path/To/File indicates a Python version
- if not successful, return default value of `py-shell-name'
When interactivly called, messages the shell name, Emacs would in the given circumstances.
With \\[universal-argument] 4 is called `py-switch-shell' see docu there."
(interactive "P")
(if (eq 4 (prefix-numeric-value arg))
(py-switch-shell '(4))
(let* (res done
(erg (cond (py-force-py-shell-name-p
(default-value 'py-shell-name))
(py-use-local-default
(if (not (string= "" py-shell-local-path))
(expand-file-name py-shell-local-path)
(message "Abort: `py-use-local-default' is set to `t' but `py-shell-local-path' is empty. Maybe call `py-toggle-local-default-use'")))
((and (or fast py-fast-process-p)
(comint-check-proc (current-buffer))
(string-match "ython" (process-name (get-buffer-process (current-buffer)))))
(progn
(setq res (process-name (get-buffer-process (current-buffer))))
(py--cleanup-process-name res)))
((and (not py-fast-process-p)
(comint-check-proc (current-buffer))
(setq done t)
(string-match "ython" (process-name (get-buffer-process (current-buffer)))))
(setq res (process-name (get-buffer-process (current-buffer))))
(py--cleanup-process-name res))
((py-choose-shell-by-shebang))
((py--choose-shell-by-import))
((py-choose-shell-by-path))
(t (or
(default-value 'py-shell-name)
"python"))))
(cmd (if (or
;; comint-check-proc was succesful
done
py-edit-only-p) erg
(executable-find erg))))
(if cmd
(when (called-interactively-p 'any)
(message "%s" cmd))
(when (called-interactively-p 'any) (message "%s" "Could not detect Python on your system. Maybe set `py-edit-only-p'?")))
erg)))
(defun py--normalize-directory (directory)
"Make sure DIRECTORY ends with a file-path separator char.
Returns DIRECTORY"
(let ((erg (cond ((string-match (concat py-separator-char "$") directory)
directory)
((not (string= "" directory))
(concat directory py-separator-char)))))
(unless erg (when py-verbose-p (message "Warning: directory is empty")))
erg))
(defun py--normalize-pythonpath (pythonpath)
"Make sure PYTHONPATH ends with a colon.
Returns PYTHONPATH"
(let ((erg (cond ((string-match (concat path-separator "$") pythonpath)
pythonpath)
((not (string= "" pythonpath))
(concat pythonpath path-separator))
(t pythonpath))))
erg))
(defun py-install-directory-check ()
"Do some sanity check for `py-install-directory'.
Returns `t' if successful. "
(interactive)
(let ((erg (and (boundp 'py-install-directory) (stringp py-install-directory) (< 1 (length py-install-directory)))))
(when (called-interactively-p 'any) (message "py-install-directory-check: %s" erg))
erg))
(defun py-guess-py-install-directory ()
"Takes value of user directory aka $HOME
if `(locate-library \"python-mode\")' is not succesful.
Used only, if `py-install-directory' is empty. "
(interactive)
(let ((erg (cond ((locate-library "python-mode")
(file-name-directory (locate-library "python-mode")))
((ignore-errors (string-match "python-mode" (py--buffer-filename-remote-maybe)))
(file-name-directory (py--buffer-filename-remote-maybe)))
((string-match "python-mode" (buffer-name))
default-directory))))
(cond ((and (or (not py-install-directory) (string= "" py-install-directory)) erg)
(setq py-install-directory erg))
(t (setq py-install-directory (expand-file-name "~/")))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "Setting py-install-directory to: %s" py-install-directory))
py-install-directory)
(defun py--fetch-pythonpath ()
"Consider settings of py-pythonpath. "
(if (string= "" py-pythonpath)
(getenv "PYTHONPATH")
(concat (py--normalize-pythonpath (getenv "PYTHONPATH")) py-pythonpath)))
(defun py-load-pymacs ()
"Load Pymacs as delivered.
Pymacs has been written by François Pinard and many others.
See original source: http://pymacs.progiciels-bpi.ca"
(interactive)
(let ((pyshell (py-choose-shell))
(path (py--fetch-pythonpath))
(py-install-directory (cond ((string= "" py-install-directory)
(py-guess-py-install-directory))
(t (py--normalize-directory py-install-directory)))))
(if (py-install-directory-check)
(progn
;; If Pymacs has not been loaded before, prepend py-install-directory to
;; PYTHONPATH, so that the Pymacs delivered with python-mode is used.
(unless (featurep 'pymacs)
(setenv "PYTHONPATH" (concat
(expand-file-name py-install-directory)
(if path (concat path-separator path)))))
(setenv "PYMACS_PYTHON" (if (string-match "IP" pyshell)
"python"
pyshell))
(require 'pymacs))
(error "`py-install-directory' not set, see INSTALL"))))
(when py-load-pymacs-p (py-load-pymacs))
(when (and py-load-pymacs-p (featurep 'pymacs))
(defun py-load-pycomplete ()
"Load Pymacs based pycomplete."
(interactive)
(let* ((path (py--fetch-pythonpath))
(py-install-directory (cond ((string= "" py-install-directory)
(py-guess-py-install-directory))
(t (py--normalize-directory py-install-directory))))
(pycomplete-directory (concat (expand-file-name py-install-directory) "completion")))
(if (py-install-directory-check)
(progn
;; If the Pymacs process is already running, augment its path.
(when (and (get-process "pymacs") (fboundp 'pymacs-exec))
(pymacs-exec (concat "sys.path.insert(0, '" pycomplete-directory "')")))
(require 'pymacs)
(setenv "PYTHONPATH" (concat
pycomplete-directory
(if path (concat path-separator path))))
(push pycomplete-directory load-path)
(require 'pycomplete)
(add-hook 'python-mode-hook 'py-complete-initialize))
(error "`py-install-directory' not set, see INSTALL")))))
(when (functionp 'py-load-pycomplete)
(py-load-pycomplete))
(defun py-set-load-path ()
"Include needed subdirs of python-mode directory. "
(interactive)
(let ((py-install-directory (py--normalize-directory py-install-directory)))
(cond ((and (not (string= "" py-install-directory))(stringp py-install-directory))
(push (expand-file-name py-install-directory) load-path)
(push (concat (expand-file-name py-install-directory) "completion") load-path)
(push (concat (expand-file-name py-install-directory) "extensions") load-path)
(push (concat (expand-file-name py-install-directory) "test") load-path)
(push (concat (expand-file-name py-install-directory) "tools") load-path)
(push (concat (expand-file-name py-install-directory) "autopair") load-path))
(py-guess-py-install-directory-p
(let ((guessed-py-install-directory (py-guess-py-install-directory)))
(when guessed-py-install-directory
(push guessed-py-install-directory load-path))))
(t (error "Please set `py-install-directory', see INSTALL"))
(when (called-interactively-p 'any) (message "%s" load-path)))))
(unless py-install-directory
(push default-directory load-path)
(push (concat default-directory "extensions") load-path))
(defun py-count-lines (&optional beg end)
"Count lines in accessible part until current line.
See http://debbugs.gnu.org/cgi/bugreport.cgi?bug=7115"
(interactive)
(save-excursion
(let ((count 0)
(beg (or beg (point-min)))
(end (or end (point))))
(save-match-data
(if (or (eq major-mode 'comint-mode)
(eq major-mode 'py-shell-mode))
(if
(re-search-backward py-fast-filter-re nil t 1)
(goto-char (match-end 0))
;; (when py-debug-p (message "%s" "py-count-lines: Don't see a prompt here"))
(goto-char beg))
(goto-char beg)))
(while (and (< (point) end)(not (eobp)) (skip-chars-forward "^\n" end))
(setq count (1+ count))
(unless (or (not (< (point) end)) (eobp)) (forward-char 1)
(setq count (+ count (abs (skip-chars-forward "\n" end))))))
(when (bolp) (setq count (1+ count)))
(when (and py-debug-p (called-interactively-p 'any)) (message "%s" count))
count)))
(defmacro py-escaped ()
"Return t if char is preceded by an odd number of backslashes. "
`(save-excursion
(< 0 (% (abs (skip-chars-backward "\\\\")) 2))))
(defmacro py-current-line-backslashed-p ()
"Return t if current line is a backslashed continuation line. "
`(save-excursion
(end-of-line)
(skip-chars-backward " \t\r\n\f")
(and (eq (char-before (point)) ?\\ )
(py-escaped))))
(defmacro py-preceding-line-backslashed-p ()
"Return t if preceding line is a backslashed continuation line. "
`(save-excursion
(beginning-of-line)
(skip-chars-backward " \t\r\n\f")
(and (eq (char-before (point)) ?\\ )
(py-escaped))))
(defun py--escape-doublequotes (start end)
(let ((end (copy-marker end)))
(save-excursion
(goto-char start)
(while (and (not (eobp)) (< 0 (abs (skip-chars-forward "^\"" end))))
(when (eq (char-after) ?\")
(unless (py-escaped)
(insert "\\")
(forward-char 1)))))))
(defun py--escape-open-paren-col1 (start end)
(goto-char start)
;; (switch-to-buffer (current-buffer))
(while (re-search-forward "^(" end t 1)
(insert "\\")
(end-of-line)))
(and py-company-pycomplete-p (require 'company-pycomplete))
;; Macros
(defmacro empty-line-p ()
"Returns t if cursor is at an line with nothing but whitespace-characters, nil otherwise."
`(save-excursion
(progn
(beginning-of-line)
(looking-at "\\s-*$"))))
(require 'ansi-color)
(require 'cc-cmds)
(require 'cl)
(require 'comint)
(require 'compile)
(require 'custom)
(require 'flymake)
(require 'hippie-exp)
(require 'shell)
(require 'thingatpt)
(require 'which-func)
(defun py-define-menu (map)
(easy-menu-define py-menu map "Py"
`("Python"
("Interpreter"
["Ipython" ipython
:help " `ipython'
Start an IPython interpreter."]
["Ipython2\.7" ipython2\.7
:help " `ipython2\.7'"]
["Ipython3" ipython3
:help " `ipython3'
Start an IPython3 interpreter."]
["Jython" jython
:help " `jython'
Start an Jython interpreter."]
["Python" python
:help " `python'
Start an Python interpreter."]
["Python2" python2
:help " `python2'
Start an Python2 interpreter."]
["Python3" python3
:help " `python3'
Start an Python3 interpreter."])
("Edit"
("Shift"
("Shift right"
["Shift block right" py-shift-block-right
:help " `py-shift-block-right'
Indent block by COUNT spaces."]
["Shift block or clause right" py-shift-block-or-clause-right
:help " `py-shift-block-or-clause-right'
Indent block-or-clause by COUNT spaces."]
["Shift class right" py-shift-class-right
:help " `py-shift-class-right'
Indent class by COUNT spaces."]
["Shift clause right" py-shift-clause-right
:help " `py-shift-clause-right'
Indent clause by COUNT spaces."]
["Shift comment right" py-shift-comment-right
:help " `py-shift-comment-right'
Indent comment by COUNT spaces."]
["Shift def right" py-shift-def-right
:help " `py-shift-def-right'
Indent def by COUNT spaces."]
["Shift def or class right" py-shift-def-or-class-right
:help " `py-shift-def-or-class-right'
Indent def-or-class by COUNT spaces."]
["Shift indent right" py-shift-indent-right
:help " `py-shift-indent-right'
Indent indent by COUNT spaces."]
["Shift minor block right" py-shift-minor-block-right
:help " `py-shift-minor-block-right'
Indent minor-block by COUNT spaces."]
["Shift paragraph right" py-shift-paragraph-right
:help " `py-shift-paragraph-right'
Indent paragraph by COUNT spaces."]
["Shift region right" py-shift-region-right
:help " `py-shift-region-right'
Indent region by COUNT spaces."]
["Shift statement right" py-shift-statement-right
:help " `py-shift-statement-right'
Indent statement by COUNT spaces."]
["Shift top level right" py-shift-top-level-right
:help " `py-shift-top-level-right'
Indent top-level by COUNT spaces."])
("Shift left"
["Shift block left" py-shift-block-left
:help " `py-shift-block-left'
Dedent block by COUNT spaces."]
["Shift block or clause left" py-shift-block-or-clause-left
:help " `py-shift-block-or-clause-left'
Dedent block-or-clause by COUNT spaces."]
["Shift class left" py-shift-class-left
:help " `py-shift-class-left'
Dedent class by COUNT spaces."]
["Shift clause left" py-shift-clause-left
:help " `py-shift-clause-left'
Dedent clause by COUNT spaces."]
["Shift comment left" py-shift-comment-left
:help " `py-shift-comment-left'
Dedent comment by COUNT spaces."]
["Shift def left" py-shift-def-left
:help " `py-shift-def-left'
Dedent def by COUNT spaces."]
["Shift def or class left" py-shift-def-or-class-left
:help " `py-shift-def-or-class-left'
Dedent def-or-class by COUNT spaces."]
["Shift indent left" py-shift-indent-left
:help " `py-shift-indent-left'
Dedent indent by COUNT spaces."]
["Shift minor block left" py-shift-minor-block-left
:help " `py-shift-minor-block-left'
Dedent minor-block by COUNT spaces."]
["Shift paragraph left" py-shift-paragraph-left
:help " `py-shift-paragraph-left'
Dedent paragraph by COUNT spaces."]
["Shift region left" py-shift-region-left
:help " `py-shift-region-left'
Dedent region by COUNT spaces."]
["Shift statement left" py-shift-statement-left
:help " `py-shift-statement-left'
Dedent statement by COUNT spaces."]))
("Mark"
["Mark block" py-mark-block
:help " `py-mark-block'
Mark block, take beginning of line positions."]
["Mark block or clause" py-mark-block-or-clause
:help " `py-mark-block-or-clause'
Mark block-or-clause, take beginning of line positions."]
["Mark class" py-mark-class
:help " `py-mark-class'
Mark class, take beginning of line positions."]
["Mark clause" py-mark-clause
:help " `py-mark-clause'
Mark clause, take beginning of line positions."]
["Mark comment" py-mark-comment
:help " `py-mark-comment'
Mark comment at point."]
["Mark def" py-mark-def
:help " `py-mark-def'
Mark def, take beginning of line positions."]
["Mark def or class" py-mark-def-or-class
:help " `py-mark-def-or-class'
Mark def-or-class, take beginning of line positions."]
["Mark expression" py-mark-expression
:help " `py-mark-expression'
Mark expression at point."]
["Mark except block" py-mark-except-block
:help " `py-mark-except-block'
Mark except-block, take beginning of line positions."]
["Mark if block" py-mark-if-block
:help " `py-mark-if-block'
Mark if-block, take beginning of line positions."]
["Mark indent" py-mark-indent
:help " `py-mark-indent'
Mark indent, take beginning of line positions."]
["Mark line" py-mark-line
:help " `py-mark-line'
Mark line at point."]
["Mark minor block" py-mark-minor-block
:help " `py-mark-minor-block'
Mark minor-block, take beginning of line positions."]
["Mark partial expression" py-mark-partial-expression
:help " `py-mark-partial-expression'
Mark partial-expression at point."]
["Mark paragraph" py-mark-paragraph
:help " `py-mark-paragraph'
Mark paragraph at point."]
["Mark section" py-mark-section
:help " `py-mark-section'
Mark section at point."]
["Mark statement" py-mark-statement
:help " `py-mark-statement'
Mark statement, take beginning of line positions."]
["Mark top level" py-mark-top-level
:help " `py-mark-top-level'
Mark top-level, take beginning of line positions."]
["Mark try block" py-mark-try-block
:help " `py-mark-try-block'
Mark try-block, take beginning of line positions."])
("Copy"
["Copy block" py-copy-block
:help " `py-copy-block'
Copy block at point."]
["Copy block or clause" py-copy-block-or-clause
:help " `py-copy-block-or-clause'
Copy block-or-clause at point."]
["Copy class" py-copy-class
:help " `py-copy-class'
Copy class at point."]
["Copy clause" py-copy-clause
:help " `py-copy-clause'
Copy clause at point."]
["Copy comment" py-copy-comment
:help " `py-copy-comment'"]
["Copy def" py-copy-def
:help " `py-copy-def'
Copy def at point."]
["Copy def or class" py-copy-def-or-class
:help " `py-copy-def-or-class'
Copy def-or-class at point."]
["Copy expression" py-copy-expression
:help " `py-copy-expression'
Copy expression at point."]
["Copy except block" py-copy-except-block
:help " `py-copy-except-block'"]
["Copy if block" py-copy-if-block
:help " `py-copy-if-block'"]
["Copy indent" py-copy-indent
:help " `py-copy-indent'
Copy indent at point."]
["Copy line" py-copy-line
:help " `py-copy-line'
Copy line at point."]
["Copy minor block" py-copy-minor-block
:help " `py-copy-minor-block'
Copy minor-block at point."]
["Copy partial expression" py-copy-partial-expression
:help " `py-copy-partial-expression'
Copy partial-expression at point."]
["Copy paragraph" py-copy-paragraph
:help " `py-copy-paragraph'
Copy paragraph at point."]
["Copy section" py-copy-section
:help " `py-copy-section'"]
["Copy statement" py-copy-statement
:help " `py-copy-statement'
Copy statement at point."]
["Copy top level" py-copy-top-level
:help " `py-copy-top-level'
Copy top-level at point."]
["Copy try block" py-copy-try-block
:help " `py-copy-try-block'"])
("Kill"
["Kill block" py-kill-block
:help " `py-kill-block'
Delete block at point."]
["Kill block or clause" py-kill-block-or-clause
:help " `py-kill-block-or-clause'
Delete block-or-clause at point."]
["Kill class" py-kill-class
:help " `py-kill-class'
Delete class at point."]
["Kill clause" py-kill-clause
:help " `py-kill-clause'
Delete clause at point."]
["Kill comment" py-kill-comment
:help " `py-kill-comment'
Delete comment at point."]
["Kill def" py-kill-def
:help " `py-kill-def'
Delete def at point."]
["Kill def or class" py-kill-def-or-class
:help " `py-kill-def-or-class'
Delete def-or-class at point."]
["Kill expression" py-kill-expression
:help " `py-kill-expression'
Delete expression at point."]
["Kill except block" py-kill-except-block
:help " `py-kill-except-block'
Delete except-block at point."]
["Kill if block" py-kill-if-block
:help " `py-kill-if-block'
Delete if-block at point."]
["Kill indent" py-kill-indent
:help " `py-kill-indent'
Delete indent at point."]
["Kill line" py-kill-line
:help " `py-kill-line'
Delete line at point."]
["Kill minor block" py-kill-minor-block
:help " `py-kill-minor-block'
Delete minor-block at point."]
["Kill partial expression" py-kill-partial-expression
:help " `py-kill-partial-expression'
Delete partial-expression at point."]
["Kill paragraph" py-kill-paragraph
:help " `py-kill-paragraph'
Delete paragraph at point."]
["Kill section" py-kill-section
:help " `py-kill-section'
Delete section at point."]
["Kill statement" py-kill-statement
:help " `py-kill-statement'
Delete statement at point."]
["Kill top level" py-kill-top-level
:help " `py-kill-top-level'
Delete top-level at point."]
["Kill try block" py-kill-try-block
:help " `py-kill-try-block'
Delete try-block at point."])
("Delete"
["Delete block" py-delete-block
:help " `py-delete-block'
Delete BLOCK at point until beginning-of-line."]
["Delete block or clause" py-delete-block-or-clause
:help " `py-delete-block-or-clause'
Delete BLOCK-OR-CLAUSE at point until beginning-of-line."]
["Delete class" py-delete-class
:help " `py-delete-class'
Delete CLASS at point until beginning-of-line."]
["Delete clause" py-delete-clause
:help " `py-delete-clause'
Delete CLAUSE at point until beginning-of-line."]
["Delete comment" py-delete-comment
:help " `py-delete-comment'
Delete COMMENT at point."]
["Delete def" py-delete-def
:help " `py-delete-def'
Delete DEF at point until beginning-of-line."]
["Delete def or class" py-delete-def-or-class
:help " `py-delete-def-or-class'
Delete DEF-OR-CLASS at point until beginning-of-line."]
["Delete expression" py-delete-expression
:help " `py-delete-expression'
Delete EXPRESSION at point."]
["Delete except block" py-delete-except-block
:help " `py-delete-except-block'
Delete EXCEPT-BLOCK at point until beginning-of-line."]
["Delete if block" py-delete-if-block
:help " `py-delete-if-block'
Delete IF-BLOCK at point until beginning-of-line."]
["Delete indent" py-delete-indent
:help " `py-delete-indent'
Delete INDENT at point until beginning-of-line."]
["Delete line" py-delete-line
:help " `py-delete-line'
Delete LINE at point."]
["Delete minor block" py-delete-minor-block
:help " `py-delete-minor-block'
Delete MINOR-BLOCK at point until beginning-of-line."]
["Delete partial expression" py-delete-partial-expression
:help " `py-delete-partial-expression'
Delete PARTIAL-EXPRESSION at point."]
["Delete paragraph" py-delete-paragraph
:help " `py-delete-paragraph'
Delete PARAGRAPH at point."]
["Delete section" py-delete-section
:help " `py-delete-section'
Delete SECTION at point."]
["Delete statement" py-delete-statement
:help " `py-delete-statement'
Delete STATEMENT at point until beginning-of-line."]
["Delete top level" py-delete-top-level
:help " `py-delete-top-level'
Delete TOP-LEVEL at point."]
["Delete try block" py-delete-try-block
:help " `py-delete-try-block'
Delete TRY-BLOCK at point until beginning-of-line."])
("Comment"
["Comment block" py-comment-block
:help " `py-comment-block'
Comments block at point."]
["Comment block or clause" py-comment-block-or-clause
:help " `py-comment-block-or-clause'
Comments block-or-clause at point."]
["Comment class" py-comment-class
:help " `py-comment-class'
Comments class at point."]
["Comment clause" py-comment-clause
:help " `py-comment-clause'
Comments clause at point."]
["Comment def" py-comment-def
:help " `py-comment-def'
Comments def at point."]
["Comment def or class" py-comment-def-or-class
:help " `py-comment-def-or-class'
Comments def-or-class at point."]
["Comment indent" py-comment-indent
:help " `py-comment-indent'
Comments indent at point."]
["Comment minor block" py-comment-minor-block
:help " `py-comment-minor-block'
Comments minor-block at point."]
["Comment section" py-comment-section
:help " `py-comment-section'
Comments section at point."]
["Comment statement" py-comment-statement
:help " `py-comment-statement'
Comments statement at point."]
["Comment top level" py-comment-top-level
:help " `py-comment-top-level'
Comments top-level at point."]))
("Move"
("Backward"
["Backward block" py-backward-block
:help " `py-backward-block'
Go to beginning of ‘block’."]
["Backward block or clause" py-backward-block-or-clause
:help " `py-backward-block-or-clause'
Go to beginning of ‘block-or-clause’."]
["Backward class" py-backward-class
:help " `py-backward-class'
Go to beginning of class."]
["Backward clause" py-backward-clause
:help " `py-backward-clause'
Go to beginning of ‘clause’."]
["Backward def" py-backward-def
:help " `py-backward-def'
Go to beginning of def."]
["Backward def or class" py-backward-def-or-class
:help " `py-backward-def-or-class'
Go to beginning of def-or-class."]
["Backward elif block" py-backward-elif-block
:help " `py-backward-elif-block'
Go to beginning of ‘elif-block’."]
["Backward else block" py-backward-else-block
:help " `py-backward-else-block'
Go to beginning of ‘else-block’."]
["Backward except block" py-backward-except-block
:help " `py-backward-except-block'
Go to beginning of ‘except-block’."]
["Backward expression" py-backward-expression
:help " `py-backward-expression'
Go to the beginning of a python expression."]
["Backward for block" py-backward-for-block
:help " `py-backward-for-block'
Go to beginning of ‘for-block’."]
["Backward if block" py-backward-if-block
:help " `py-backward-if-block'
Go to beginning of ‘if-block’."]
["Backward indent" py-backward-indent
:help " `py-backward-indent'
Go to the beginning of a section of equal indent."]
["Backward minor block" py-backward-minor-block
:help " `py-backward-minor-block'
Go to beginning of ‘minor-block’."]
["Backward partial expression" py-backward-partial-expression
:help " `py-backward-partial-expression'"]
["Backward section" py-backward-section
:help " `py-backward-section'
Go to next section start upward in buffer."]
["Backward statement" py-backward-statement
:help " `py-backward-statement'
Go to the initial line of a simple statement."]
["Backward top level" py-backward-top-level
:help " `py-backward-top-level'
Go up to beginning of statments until level of indentation is null."]
["Backward try block" py-backward-try-block
:help " `py-backward-try-block'
Go to beginning of ‘try-block’."])
("Forward"
["Forward block" py-forward-block
:help " `py-forward-block'
Go to end of block."]
["Forward block or clause" py-forward-block-or-clause
:help " `py-forward-block-or-clause'
Go to end of block-or-clause."]
["Forward class" py-forward-class
:help " `py-forward-class'
Go to end of class."]
["Forward clause" py-forward-clause
:help " `py-forward-clause'
Go to end of clause."]
["Forward def" py-forward-def
:help " `py-forward-def'
Go to end of def."]
["Forward def or class" py-forward-def-or-class
:help " `py-forward-def-or-class'
Go to end of def-or-class."]
["Forward elif block" py-forward-elif-block
:help " `py-forward-elif-block'
Go to end of elif-block."]
["Forward else block" py-forward-else-block
:help " `py-forward-else-block'
Go to end of else-block."]
["Forward except block" py-forward-except-block
:help " `py-forward-except-block'
Go to end of except-block."]
["Forward expression" py-forward-expression
:help " `py-forward-expression'
Go to the end of a compound python expression."]
["Forward for block" py-forward-for-block
:help " `py-forward-for-block'
Go to end of for-block."]
["Forward if block" py-forward-if-block
:help " `py-forward-if-block'
Go to end of if-block."]
["Forward indent" py-forward-indent
:help " `py-forward-indent'
Go to the end of a section of equal indentation."]
["Forward minor block" py-forward-minor-block
:help " `py-forward-minor-block'
Go to end of minor-block."]
["Forward partial expression" py-forward-partial-expression
:help " `py-forward-partial-expression'"]
["Forward section" py-forward-section
:help " `py-forward-section'
Go to next section end downward in buffer."]
["Forward statement" py-forward-statement
:help " `py-forward-statement'
Go to the last char of current statement."]
["Forward top level" py-forward-top-level
:help " `py-forward-top-level'
Go to end of top-level form at point."]
["Forward try block" py-forward-try-block
:help " `py-forward-try-block'
Go to end of try-block."])
("BOL-forms"
("Backward"
["Backward block bol" py-backward-block-bol
:help " `py-backward-block-bol'
Go to beginning of ‘block’, go to BOL."]
["Backward block or clause bol" py-backward-block-or-clause-bol
:help " `py-backward-block-or-clause-bol'
Go to beginning of ‘block-or-clause’, go to BOL."]
["Backward class bol" py-backward-class-bol
:help " `py-backward-class-bol'
Go to beginning of class, go to BOL."]
["Backward clause bol" py-backward-clause-bol
:help " `py-backward-clause-bol'
Go to beginning of ‘clause’, go to BOL."]
["Backward def bol" py-backward-def-bol
:help " `py-backward-def-bol'
Go to beginning of def, go to BOL."]
["Backward def or class bol" py-backward-def-or-class-bol
:help " `py-backward-def-or-class-bol'
Go to beginning of def-or-class, go to BOL."]
["Backward elif block bol" py-backward-elif-block-bol
:help " `py-backward-elif-block-bol'
Go to beginning of ‘elif-block’, go to BOL."]
["Backward else block bol" py-backward-else-block-bol
:help " `py-backward-else-block-bol'
Go to beginning of ‘else-block’, go to BOL."]
["Backward except block bol" py-backward-except-block-bol
:help " `py-backward-except-block-bol'
Go to beginning of ‘except-block’, go to BOL."]
["Backward expression bol" py-backward-expression-bol
:help " `py-backward-expression-bol'"]
["Backward for block bol" py-backward-for-block-bol
:help " `py-backward-for-block-bol'
Go to beginning of ‘for-block’, go to BOL."]
["Backward if block bol" py-backward-if-block-bol
:help " `py-backward-if-block-bol'
Go to beginning of ‘if-block’, go to BOL."]
["Backward indent bol" py-backward-indent-bol
:help " `py-backward-indent-bol'
Go to the beginning of line of a section of equal indent."]
["Backward minor block bol" py-backward-minor-block-bol
:help " `py-backward-minor-block-bol'
Go to beginning of ‘minor-block’, go to BOL."]
["Backward partial expression bol" py-backward-partial-expression-bol
:help " `py-backward-partial-expression-bol'"]
["Backward section bol" py-backward-section-bol
:help " `py-backward-section-bol'"]
["Backward statement bol" py-backward-statement-bol
:help " `py-backward-statement-bol'
Goto beginning of line where statement starts."]
["Backward try block bol" py-backward-try-block-bol
:help " `py-backward-try-block-bol'
Go to beginning of ‘try-block’, go to BOL."])
("Forward"
["Forward block bol" py-forward-block-bol
:help " `py-forward-block-bol'
Goto beginning of line following end of block."]
["Forward block or clause bol" py-forward-block-or-clause-bol
:help " `py-forward-block-or-clause-bol'
Goto beginning of line following end of block-or-clause."]
["Forward class bol" py-forward-class-bol
:help " `py-forward-class-bol'
Goto beginning of line following end of class."]
["Forward clause bol" py-forward-clause-bol
:help " `py-forward-clause-bol'
Goto beginning of line following end of clause."]
["Forward def bol" py-forward-def-bol
:help " `py-forward-def-bol'
Goto beginning of line following end of def."]
["Forward def or class bol" py-forward-def-or-class-bol
:help " `py-forward-def-or-class-bol'
Goto beginning of line following end of def-or-class."]
["Forward elif block bol" py-forward-elif-block-bol
:help " `py-forward-elif-block-bol'
Goto beginning of line following end of elif-block."]
["Forward else block bol" py-forward-else-block-bol
:help " `py-forward-else-block-bol'
Goto beginning of line following end of else-block."]
["Forward except block bol" py-forward-except-block-bol
:help " `py-forward-except-block-bol'
Goto beginning of line following end of except-block."]
["Forward expression bol" py-forward-expression-bol
:help " `py-forward-expression-bol'"]
["Forward for block bol" py-forward-for-block-bol
:help " `py-forward-for-block-bol'
Goto beginning of line following end of for-block."]
["Forward if block bol" py-forward-if-block-bol
:help " `py-forward-if-block-bol'
Goto beginning of line following end of if-block."]
["Forward indent bol" py-forward-indent-bol
:help " `py-forward-indent-bol'
Go to beginning of line following of a section of equal indentation."]
["Forward minor block bol" py-forward-minor-block-bol
:help " `py-forward-minor-block-bol'
Goto beginning of line following end of minor-block."]
["Forward partial expression bol" py-forward-partial-expression-bol
:help " `py-forward-partial-expression-bol'"]
["Forward section bol" py-forward-section-bol
:help " `py-forward-section-bol'"]
["Forward statement bol" py-forward-statement-bol
:help " `py-forward-statement-bol'
Go to the beginning-of-line following current statement."]
["Forward top level bol" py-forward-top-level-bol
:help " `py-forward-top-level-bol'
Go to end of top-level form at point, stop at next beginning-of-line."]
["Forward try block bol" py-forward-try-block-bol
:help " `py-forward-try-block-bol'
Goto beginning of line following end of try-block."]))
("Up/Down"
["Up" py-up
:help " `py-up'
Go up or to beginning of form if inside."]
["Down" py-down
:help " `py-down'
Go to beginning one level below of compound statement or definition at point."]))
("Send"
["Execute block" py-execute-block
:help " `py-execute-block'
Send block at point to interpreter."]
["Execute block or clause" py-execute-block-or-clause
:help " `py-execute-block-or-clause'
Send block-or-clause at point to interpreter."]
["Execute buffer" py-execute-buffer
:help " `py-execute-buffer'
:around advice: ‘ad-Advice-py-execute-buffer’"]
["Execute class" py-execute-class
:help " `py-execute-class'
Send class at point to interpreter."]
["Execute clause" py-execute-clause
:help " `py-execute-clause'
Send clause at point to interpreter."]
["Execute def" py-execute-def
:help " `py-execute-def'
Send def at point to interpreter."]
["Execute def or class" py-execute-def-or-class
:help " `py-execute-def-or-class'
Send def-or-class at point to interpreter."]
["Execute expression" py-execute-expression
:help " `py-execute-expression'
Send expression at point to interpreter."]
["Execute indent" py-execute-indent
:help " `py-execute-indent'
Send indent at point to interpreter."]
["Execute line" py-execute-line
:help " `py-execute-line'
Send line at point to interpreter."]
["Execute minor block" py-execute-minor-block
:help " `py-execute-minor-block'
Send minor-block at point to interpreter."]
["Execute paragraph" py-execute-paragraph
:help " `py-execute-paragraph'
Send paragraph at point to interpreter."]
["Execute partial expression" py-execute-partial-expression
:help " `py-execute-partial-expression'
Send partial-expression at point to interpreter."]
["Execute region" py-execute-region
:help " `py-execute-region'
Send region at point to interpreter."]
["Execute statement" py-execute-statement
:help " `py-execute-statement'
Send statement at point to interpreter."]
["Execute top level" py-execute-top-level
:help " `py-execute-top-level'
Send top-level at point to interpreter."]
("Other"
("IPython"
["Execute block ipython" py-execute-block-ipython
:help " `py-execute-block-ipython'
Send block at point to IPython interpreter."]
["Execute block or clause ipython" py-execute-block-or-clause-ipython
:help " `py-execute-block-or-clause-ipython'
Send block-or-clause at point to IPython interpreter."]
["Execute buffer ipython" py-execute-buffer-ipython
:help " `py-execute-buffer-ipython'
Send buffer at point to IPython interpreter."]
["Execute class ipython" py-execute-class-ipython
:help " `py-execute-class-ipython'
Send class at point to IPython interpreter."]
["Execute clause ipython" py-execute-clause-ipython
:help " `py-execute-clause-ipython'
Send clause at point to IPython interpreter."]
["Execute def ipython" py-execute-def-ipython
:help " `py-execute-def-ipython'
Send def at point to IPython interpreter."]
["Execute def or class ipython" py-execute-def-or-class-ipython
:help " `py-execute-def-or-class-ipython'
Send def-or-class at point to IPython interpreter."]
["Execute expression ipython" py-execute-expression-ipython
:help " `py-execute-expression-ipython'
Send expression at point to IPython interpreter."]
["Execute indent ipython" py-execute-indent-ipython
:help " `py-execute-indent-ipython'
Send indent at point to IPython interpreter."]
["Execute line ipython" py-execute-line-ipython
:help " `py-execute-line-ipython'
Send line at point to IPython interpreter."]
["Execute minor block ipython" py-execute-minor-block-ipython
:help " `py-execute-minor-block-ipython'
Send minor-block at point to IPython interpreter."]
["Execute paragraph ipython" py-execute-paragraph-ipython
:help " `py-execute-paragraph-ipython'
Send paragraph at point to IPython interpreter."]
["Execute partial expression ipython" py-execute-partial-expression-ipython
:help " `py-execute-partial-expression-ipython'
Send partial-expression at point to IPython interpreter."]
["Execute region ipython" py-execute-region-ipython
:help " `py-execute-region-ipython'
Send region at point to IPython interpreter."]
["Execute statement ipython" py-execute-statement-ipython
:help " `py-execute-statement-ipython'
Send statement at point to IPython interpreter."]
["Execute top level ipython" py-execute-top-level-ipython
:help " `py-execute-top-level-ipython'
Send top-level at point to IPython interpreter."])
("IPython2\.7"
["Execute block ipython2\.7" py-execute-block-ipython2\.7
:help " `py-execute-block-ipython2\.7'"]
["Execute block or clause ipython2\.7" py-execute-block-or-clause-ipython2\.7
:help " `py-execute-block-or-clause-ipython2\.7'"]
["Execute buffer ipython2\.7" py-execute-buffer-ipython2\.7
:help " `py-execute-buffer-ipython2\.7'"]
["Execute class ipython2\.7" py-execute-class-ipython2\.7
:help " `py-execute-class-ipython2\.7'"]
["Execute clause ipython2\.7" py-execute-clause-ipython2\.7
:help " `py-execute-clause-ipython2\.7'"]
["Execute def ipython2\.7" py-execute-def-ipython2\.7
:help " `py-execute-def-ipython2\.7'"]
["Execute def or class ipython2\.7" py-execute-def-or-class-ipython2\.7
:help " `py-execute-def-or-class-ipython2\.7'"]
["Execute expression ipython2\.7" py-execute-expression-ipython2\.7
:help " `py-execute-expression-ipython2\.7'"]
["Execute indent ipython2\.7" py-execute-indent-ipython2\.7
:help " `py-execute-indent-ipython2\.7'"]
["Execute line ipython2\.7" py-execute-line-ipython2\.7
:help " `py-execute-line-ipython2\.7'"]
["Execute minor block ipython2\.7" py-execute-minor-block-ipython2\.7
:help " `py-execute-minor-block-ipython2\.7'"]
["Execute paragraph ipython2\.7" py-execute-paragraph-ipython2\.7
:help " `py-execute-paragraph-ipython2\.7'"]
["Execute partial expression ipython2\.7" py-execute-partial-expression-ipython2\.7
:help " `py-execute-partial-expression-ipython2\.7'"]
["Execute region ipython2\.7" py-execute-region-ipython2\.7
:help " `py-execute-region-ipython2\.7'"]
["Execute statement ipython2\.7" py-execute-statement-ipython2\.7
:help " `py-execute-statement-ipython2\.7'"]
["Execute top level ipython2\.7" py-execute-top-level-ipython2\.7
:help " `py-execute-top-level-ipython2\.7'"])
("IPython3"
["Execute block ipython3" py-execute-block-ipython3
:help " `py-execute-block-ipython3'
Send block at point to IPython interpreter."]
["Execute block or clause ipython3" py-execute-block-or-clause-ipython3
:help " `py-execute-block-or-clause-ipython3'
Send block-or-clause at point to IPython interpreter."]
["Execute buffer ipython3" py-execute-buffer-ipython3
:help " `py-execute-buffer-ipython3'
Send buffer at point to IPython interpreter."]
["Execute class ipython3" py-execute-class-ipython3
:help " `py-execute-class-ipython3'
Send class at point to IPython interpreter."]
["Execute clause ipython3" py-execute-clause-ipython3
:help " `py-execute-clause-ipython3'
Send clause at point to IPython interpreter."]
["Execute def ipython3" py-execute-def-ipython3
:help " `py-execute-def-ipython3'
Send def at point to IPython interpreter."]
["Execute def or class ipython3" py-execute-def-or-class-ipython3
:help " `py-execute-def-or-class-ipython3'
Send def-or-class at point to IPython interpreter."]
["Execute expression ipython3" py-execute-expression-ipython3
:help " `py-execute-expression-ipython3'
Send expression at point to IPython interpreter."]
["Execute indent ipython3" py-execute-indent-ipython3
:help " `py-execute-indent-ipython3'
Send indent at point to IPython interpreter."]
["Execute line ipython3" py-execute-line-ipython3
:help " `py-execute-line-ipython3'
Send line at point to IPython interpreter."]
["Execute minor block ipython3" py-execute-minor-block-ipython3
:help " `py-execute-minor-block-ipython3'
Send minor-block at point to IPython interpreter."]
["Execute paragraph ipython3" py-execute-paragraph-ipython3
:help " `py-execute-paragraph-ipython3'
Send paragraph at point to IPython interpreter."]
["Execute partial expression ipython3" py-execute-partial-expression-ipython3
:help " `py-execute-partial-expression-ipython3'
Send partial-expression at point to IPython interpreter."]
["Execute region ipython3" py-execute-region-ipython3
:help " `py-execute-region-ipython3'
Send region at point to IPython interpreter."]
["Execute statement ipython3" py-execute-statement-ipython3
:help " `py-execute-statement-ipython3'
Send statement at point to IPython interpreter."]
["Execute top level ipython3" py-execute-top-level-ipython3
:help " `py-execute-top-level-ipython3'
Send top-level at point to IPython interpreter."])
("Jython"
["Execute block jython" py-execute-block-jython
:help " `py-execute-block-jython'
Send block at point to Jython interpreter."]
["Execute block or clause jython" py-execute-block-or-clause-jython
:help " `py-execute-block-or-clause-jython'
Send block-or-clause at point to Jython interpreter."]
["Execute buffer jython" py-execute-buffer-jython
:help " `py-execute-buffer-jython'
Send buffer at point to Jython interpreter."]
["Execute class jython" py-execute-class-jython
:help " `py-execute-class-jython'
Send class at point to Jython interpreter."]
["Execute clause jython" py-execute-clause-jython
:help " `py-execute-clause-jython'
Send clause at point to Jython interpreter."]
["Execute def jython" py-execute-def-jython
:help " `py-execute-def-jython'
Send def at point to Jython interpreter."]
["Execute def or class jython" py-execute-def-or-class-jython
:help " `py-execute-def-or-class-jython'
Send def-or-class at point to Jython interpreter."]
["Execute expression jython" py-execute-expression-jython
:help " `py-execute-expression-jython'
Send expression at point to Jython interpreter."]
["Execute indent jython" py-execute-indent-jython
:help " `py-execute-indent-jython'
Send indent at point to Jython interpreter."]
["Execute line jython" py-execute-line-jython
:help " `py-execute-line-jython'
Send line at point to Jython interpreter."]
["Execute minor block jython" py-execute-minor-block-jython
:help " `py-execute-minor-block-jython'
Send minor-block at point to Jython interpreter."]
["Execute paragraph jython" py-execute-paragraph-jython
:help " `py-execute-paragraph-jython'
Send paragraph at point to Jython interpreter."]
["Execute partial expression jython" py-execute-partial-expression-jython
:help " `py-execute-partial-expression-jython'
Send partial-expression at point to Jython interpreter."]
["Execute region jython" py-execute-region-jython
:help " `py-execute-region-jython'
Send region at point to Jython interpreter."]
["Execute statement jython" py-execute-statement-jython
:help " `py-execute-statement-jython'
Send statement at point to Jython interpreter."]
["Execute top level jython" py-execute-top-level-jython
:help " `py-execute-top-level-jython'
Send top-level at point to Jython interpreter."])
("Python"
["Execute block python" py-execute-block-python
:help " `py-execute-block-python'
Send block at point to default interpreter."]
["Execute block or clause python" py-execute-block-or-clause-python
:help " `py-execute-block-or-clause-python'
Send block-or-clause at point to default interpreter."]
["Execute buffer python" py-execute-buffer-python
:help " `py-execute-buffer-python'
Send buffer at point to default interpreter."]
["Execute class python" py-execute-class-python
:help " `py-execute-class-python'
Send class at point to default interpreter."]
["Execute clause python" py-execute-clause-python
:help " `py-execute-clause-python'
Send clause at point to default interpreter."]
["Execute def python" py-execute-def-python
:help " `py-execute-def-python'
Send def at point to default interpreter."]
["Execute def or class python" py-execute-def-or-class-python
:help " `py-execute-def-or-class-python'
Send def-or-class at point to default interpreter."]
["Execute expression python" py-execute-expression-python
:help " `py-execute-expression-python'
Send expression at point to default interpreter."]
["Execute indent python" py-execute-indent-python
:help " `py-execute-indent-python'
Send indent at point to default interpreter."]
["Execute line python" py-execute-line-python
:help " `py-execute-line-python'
Send line at point to default interpreter."]
["Execute minor block python" py-execute-minor-block-python
:help " `py-execute-minor-block-python'
Send minor-block at point to default interpreter."]
["Execute paragraph python" py-execute-paragraph-python
:help " `py-execute-paragraph-python'
Send paragraph at point to default interpreter."]
["Execute partial expression python" py-execute-partial-expression-python
:help " `py-execute-partial-expression-python'
Send partial-expression at point to default interpreter."]
["Execute region python" py-execute-region-python
:help " `py-execute-region-python'
Send region at point to default interpreter."]
["Execute statement python" py-execute-statement-python
:help " `py-execute-statement-python'
Send statement at point to default interpreter."]
["Execute top level python" py-execute-top-level-python
:help " `py-execute-top-level-python'
Send top-level at point to default interpreter."])
("Python2"
["Execute block python2" py-execute-block-python2
:help " `py-execute-block-python2'
Send block at point to Python2 interpreter."]
["Execute block or clause python2" py-execute-block-or-clause-python2
:help " `py-execute-block-or-clause-python2'
Send block-or-clause at point to Python2 interpreter."]
["Execute buffer python2" py-execute-buffer-python2
:help " `py-execute-buffer-python2'
Send buffer at point to Python2 interpreter."]
["Execute class python2" py-execute-class-python2
:help " `py-execute-class-python2'
Send class at point to Python2 interpreter."]
["Execute clause python2" py-execute-clause-python2
:help " `py-execute-clause-python2'
Send clause at point to Python2 interpreter."]
["Execute def python2" py-execute-def-python2
:help " `py-execute-def-python2'
Send def at point to Python2 interpreter."]
["Execute def or class python2" py-execute-def-or-class-python2
:help " `py-execute-def-or-class-python2'
Send def-or-class at point to Python2 interpreter."]
["Execute expression python2" py-execute-expression-python2
:help " `py-execute-expression-python2'
Send expression at point to Python2 interpreter."]
["Execute indent python2" py-execute-indent-python2
:help " `py-execute-indent-python2'
Send indent at point to Python2 interpreter."]
["Execute line python2" py-execute-line-python2
:help " `py-execute-line-python2'
Send line at point to Python2 interpreter."]
["Execute minor block python2" py-execute-minor-block-python2
:help " `py-execute-minor-block-python2'
Send minor-block at point to Python2 interpreter."]
["Execute paragraph python2" py-execute-paragraph-python2
:help " `py-execute-paragraph-python2'
Send paragraph at point to Python2 interpreter."]
["Execute partial expression python2" py-execute-partial-expression-python2
:help " `py-execute-partial-expression-python2'
Send partial-expression at point to Python2 interpreter."]
["Execute region python2" py-execute-region-python2
:help " `py-execute-region-python2'
Send region at point to Python2 interpreter."]
["Execute statement python2" py-execute-statement-python2
:help " `py-execute-statement-python2'
Send statement at point to Python2 interpreter."]
["Execute top level python2" py-execute-top-level-python2
:help " `py-execute-top-level-python2'
Send top-level at point to Python2 interpreter."])
("Python3"
["Execute block python3" py-execute-block-python3
:help " `py-execute-block-python3'
Send block at point to Python3 interpreter."]
["Execute block or clause python3" py-execute-block-or-clause-python3
:help " `py-execute-block-or-clause-python3'
Send block-or-clause at point to Python3 interpreter."]
["Execute buffer python3" py-execute-buffer-python3
:help " `py-execute-buffer-python3'
Send buffer at point to Python3 interpreter."]
["Execute class python3" py-execute-class-python3
:help " `py-execute-class-python3'
Send class at point to Python3 interpreter."]
["Execute clause python3" py-execute-clause-python3
:help " `py-execute-clause-python3'
Send clause at point to Python3 interpreter."]
["Execute def python3" py-execute-def-python3
:help " `py-execute-def-python3'
Send def at point to Python3 interpreter."]
["Execute def or class python3" py-execute-def-or-class-python3
:help " `py-execute-def-or-class-python3'
Send def-or-class at point to Python3 interpreter."]
["Execute expression python3" py-execute-expression-python3
:help " `py-execute-expression-python3'
Send expression at point to Python3 interpreter."]
["Execute indent python3" py-execute-indent-python3
:help " `py-execute-indent-python3'
Send indent at point to Python3 interpreter."]
["Execute line python3" py-execute-line-python3
:help " `py-execute-line-python3'
Send line at point to Python3 interpreter."]
["Execute minor block python3" py-execute-minor-block-python3
:help " `py-execute-minor-block-python3'
Send minor-block at point to Python3 interpreter."]
["Execute paragraph python3" py-execute-paragraph-python3
:help " `py-execute-paragraph-python3'
Send paragraph at point to Python3 interpreter."]
["Execute partial expression python3" py-execute-partial-expression-python3
:help " `py-execute-partial-expression-python3'
Send partial-expression at point to Python3 interpreter."]
["Execute region python3" py-execute-region-python3
:help " `py-execute-region-python3'
Send region at point to Python3 interpreter."]
["Execute statement python3" py-execute-statement-python3
:help " `py-execute-statement-python3'
Send statement at point to Python3 interpreter."]
["Execute top level python3" py-execute-top-level-python3
:help " `py-execute-top-level-python3'
Send top-level at point to Python3 interpreter."])
("Ignoring defaults "
:help "`M-x py-execute-statement- TAB' for example list commands ignoring defaults
of `py-switch-buffers-on-execute-p' and `py-split-window-on-execute'")))
("Hide-Show"
("Hide"
["Hide block" py-hide-block
:help " `py-hide-block'
Hide block at point."]
["Hide block or clause" py-hide-block-or-clause
:help " `py-hide-block-or-clause'
Hide block-or-clause at point."]
["Hide class" py-hide-class
:help " `py-hide-class'
Hide class at point."]
["Hide clause" py-hide-clause
:help " `py-hide-clause'
Hide clause at point."]
["Hide comment" py-hide-comment
:help " `py-hide-comment'
Hide comment at point."]
["Hide def" py-hide-def
:help " `py-hide-def'
Hide def at point."]
["Hide def or class" py-hide-def-or-class
:help " `py-hide-def-or-class'
Hide def-or-class at point."]
["Hide elif block" py-hide-elif-block
:help " `py-hide-elif-block'
Hide elif-block at point."]
["Hide else block" py-hide-else-block
:help " `py-hide-else-block'
Hide else-block at point."]
["Hide except block" py-hide-except-block
:help " `py-hide-except-block'
Hide except-block at point."]
["Hide expression" py-hide-expression
:help " `py-hide-expression'
Hide expression at point."]
["Hide for block" py-hide-for-block
:help " `py-hide-for-block'
Hide for-block at point."]
["Hide if block" py-hide-if-block
:help " `py-hide-if-block'
Hide if-block at point."]
["Hide indent" py-hide-indent
:help " `py-hide-indent'
Hide indent at point."]
["Hide line" py-hide-line
:help " `py-hide-line'
Hide line at point."]
["Hide minor block" py-hide-minor-block
:help " `py-hide-minor-block'
Hide minor-block at point."]
["Hide minor block" py-hide-minor-block
:help " `py-hide-minor-block'
Hide minor-block at point."]
["Hide paragraph" py-hide-paragraph
:help " `py-hide-paragraph'
Hide paragraph at point."]
["Hide partial expression" py-hide-partial-expression
:help " `py-hide-partial-expression'
Hide partial-expression at point."]
["Hide section" py-hide-section
:help " `py-hide-section'
Hide section at point."]
["Hide statement" py-hide-statement
:help " `py-hide-statement'
Hide statement at point."]
["Hide top level" py-hide-top-level
:help " `py-hide-top-level'
Hide top-level at point."])
("Show"
["Show block" py-show-block
:help " `py-show-block'
Show block at point."]
["Show block or clause" py-show-block-or-clause
:help " `py-show-block-or-clause'
Show block-or-clause at point."]
["Show class" py-show-class
:help " `py-show-class'
Show class at point."]
["Show clause" py-show-clause
:help " `py-show-clause'
Show clause at point."]
["Show comment" py-show-comment
:help " `py-show-comment'
Show comment at point."]
["Show def" py-show-def
:help " `py-show-def'
Show def at point."]
["Show def or class" py-show-def-or-class
:help " `py-show-def-or-class'
Show def-or-class at point."]
["Show elif block" py-show-elif-block
:help " `py-show-elif-block'
Show elif-block at point."]
["Show else block" py-show-else-block
:help " `py-show-else-block'
Show else-block at point."]
["Show except block" py-show-except-block
:help " `py-show-except-block'
Show except-block at point."]
["Show expression" py-show-expression
:help " `py-show-expression'
Show expression at point."]
["Show for block" py-show-for-block
:help " `py-show-for-block'
Show for-block at point."]
["Show if block" py-show-if-block
:help " `py-show-if-block'
Show if-block at point."]
["Show indent" py-show-indent
:help " `py-show-indent'
Show indent at point."]
["Show line" py-show-line
:help " `py-show-line'
Show line at point."]
["Show minor block" py-show-minor-block
:help " `py-show-minor-block'
Show minor-block at point."]
["Show minor block" py-show-minor-block
:help " `py-show-minor-block'
Show minor-block at point."]
["Show paragraph" py-show-paragraph
:help " `py-show-paragraph'
Show paragraph at point."]
["Show partial expression" py-show-partial-expression
:help " `py-show-partial-expression'
Show partial-expression at point."]
["Show section" py-show-section
:help " `py-show-section'
Show section at point."]
["Show statement" py-show-statement
:help " `py-show-statement'
Show statement at point."]
["Show top level" py-show-top-level
:help " `py-show-top-level'
Show top-level at point."]))
("Fast process"
["Execute block fast" py-execute-block-fast
:help " `py-execute-block-fast'
Process block at point by a Python interpreter."]
["Execute block or clause fast" py-execute-block-or-clause-fast
:help " `py-execute-block-or-clause-fast'
Process block-or-clause at point by a Python interpreter."]
["Execute class fast" py-execute-class-fast
:help " `py-execute-class-fast'
Process class at point by a Python interpreter."]
["Execute clause fast" py-execute-clause-fast
:help " `py-execute-clause-fast'
Process clause at point by a Python interpreter."]
["Execute def fast" py-execute-def-fast
:help " `py-execute-def-fast'
Process def at point by a Python interpreter."]
["Execute def or class fast" py-execute-def-or-class-fast
:help " `py-execute-def-or-class-fast'
Process def-or-class at point by a Python interpreter."]
["Execute expression fast" py-execute-expression-fast
:help " `py-execute-expression-fast'
Process expression at point by a Python interpreter."]
["Execute partial expression fast" py-execute-partial-expression-fast
:help " `py-execute-partial-expression-fast'
Process partial-expression at point by a Python interpreter."]
["Execute region fast" py-execute-region-fast
:help " `py-execute-region-fast'"]
["Execute statement fast" py-execute-statement-fast
:help " `py-execute-statement-fast'
Process statement at point by a Python interpreter."]
["Execute string fast" py-execute-string-fast
:help " `py-execute-string-fast'"]
["Execute top level fast" py-execute-top-level-fast
:help " `py-execute-top-level-fast'
Process top-level at point by a Python interpreter."])
("Virtualenv"
["Virtualenv activate" virtualenv-activate
:help " `virtualenv-activate'
Activate the virtualenv located in DIR"]
["Virtualenv deactivate" virtualenv-deactivate
:help " `virtualenv-deactivate'
Deactivate the current virtual enviroment"]
["Virtualenv p" virtualenv-p
:help " `virtualenv-p'
Check if a directory is a virtualenv"]
["Virtualenv workon" virtualenv-workon
:help " `virtualenv-workon'
Issue a virtualenvwrapper-like virtualenv-workon command"])
["Execute import or reload" py-execute-import-or-reload
:help " `py-execute-import-or-reload'
Import the current buffer’s file in a Python interpreter."]
("Help"
["Find definition" py-find-definition
:help " `py-find-definition'
Find source of definition of SYMBOL."]
["Help at point" py-help-at-point
:help " `py-help-at-point'
Print help on symbol at point."]
["Info lookup symbol" py-info-lookup-symbol
:help " `py-info-lookup-symbol'"]
["Symbol at point" py-symbol-at-point
:help " `py-symbol-at-point'
Return the current Python symbol."])
("Debugger"
["Execute statement pdb" py-execute-statement-pdb
:help " `py-execute-statement-pdb'
Execute statement running pdb."]
["Pdb" pdb
:help " `pdb'
Run pdb on program FILE in buffer ‘*gud-FILE*’."])
("Checks"
["Flycheck mode" py-flycheck-mode
:help " `py-flycheck-mode'
Toggle ‘flycheck-mode’."]
["Pychecker run" py-pychecker-run
:help " `py-pychecker-run'
*Run pychecker (default on the file currently visited)."]
("Pylint"
["Pylint run" py-pylint-run
:help " `py-pylint-run'
*Run pylint (default on the file currently visited)."]
["Pylint help" py-pylint-help
:help " `py-pylint-help'
Display Pylint command line help messages."]
["Pylint flymake mode" pylint-flymake-mode
:help " `pylint-flymake-mode'
Toggle ‘pylint’ ‘flymake-mode’."])
("Pep8"
["Pep8 run" py-pep8-run
:help " `py-pep8-run'
*Run pep8, check formatting - default on the file currently visited."]
["Pep8 help" py-pep8-help
:help " `py-pep8-help'
Display pep8 command line help messages."]
["Pep8 flymake mode" pep8-flymake-mode
:help " `pep8-flymake-mode'
Toggle ‘pep8’ ‘flymake-mode’."])
("Pyflakes"
["Pyflakes run" py-pyflakes-run
:help " `py-pyflakes-run'
*Run pyflakes (default on the file currently visited)."]
["Pyflakes help" py-pyflakes-help
:help " `py-pyflakes-help'
Display Pyflakes command line help messages."]
["Pyflakes flymake mode" pyflakes-flymake-mode
:help " `pyflakes-flymake-mode'
Toggle ‘pyflakes’ ‘flymake-mode’."])
("Flake8"
["Flake8 run" py-flake8-run
:help " `py-flake8-run'
Flake8 is a wrapper around these tools:"]
["Flake8 help" py-flake8-help
:help " `py-flake8-help'
Display flake8 command line help messages."]
("Pyflakes-pep8"
["Pyflakes pep8 run" py-pyflakes-pep8-run
:help " `py-pyflakes-pep8-run'"]
["Pyflakes pep8 help" py-pyflakes-pep8-help
:help " `py-pyflakes-pep8-help'"]
["Pyflakes pep8 flymake mode" pyflakes-pep8-flymake-mode
:help " `pyflakes-pep8-flymake-mode'"])))
("Customize"
["Python-mode customize group" (customize-group 'python-mode)
:help "Open the customization buffer for Python mode"]
("Switches"
:help "Toggle useful modes like `highlight-indentation'"
("Interpreter"
["Shell prompt read only"
(setq py-shell-prompt-read-only
(not py-shell-prompt-read-only))
:help "If non-nil, the python prompt is read only. Setting this variable will only effect new shells.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-shell-prompt-read-only]
["Remove cwd from path"
(setq py-remove-cwd-from-path
(not py-remove-cwd-from-path))
:help "Whether to allow loading of Python modules from the current directory.
If this is non-nil, Emacs removes '' from sys.path when starting
a Python process. This is the default, for security
reasons, as it is easy for the Python process to be started
without the user's realization (e.g. to perform completion).Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-remove-cwd-from-path]
["Honor IPYTHONDIR "
(setq py-honor-IPYTHONDIR-p
(not py-honor-IPYTHONDIR-p))
:help "When non-nil ipython-history file is constructed by \$IPYTHONDIR
followed by "/history". Default is nil.
Otherwise value of py-ipython-history is used. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-honor-IPYTHONDIR-p]
["Honor PYTHONHISTORY "
(setq py-honor-PYTHONHISTORY-p
(not py-honor-PYTHONHISTORY-p))
:help "When non-nil python-history file is set by \$PYTHONHISTORY
Default is nil.
Otherwise value of py-python-history is used. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-honor-PYTHONHISTORY-p]
["Enforce py-shell-name" force-py-shell-name-p-on
:help "Enforce customized default `py-shell-name' should upon execution. "]
["Don't enforce default interpreter" force-py-shell-name-p-off
:help "Make execute commands guess interpreter from environment"]
["Enforce local Python shell " py-force-local-shell-on
:help "Locally indicated Python being enforced upon sessions execute commands. "]
["Remove local Python shell enforcement, restore default" py-force-local-shell-off
:help "Restore `py-shell-name' default value and `behaviour'. "])
("Execute"
["Fast process" py-fast-process-p
:help " `py-fast-process-p'
Use `py-fast-process'\.
Commands prefixed \"py-fast-...\" suitable for large output
See: large output makes Emacs freeze, lp:1253907
Output-buffer is not in comint-mode"
:style toggle :selected py-fast-process-p]
["Python mode v5 behavior"
(setq python-mode-v5-behavior-p
(not python-mode-v5-behavior-p))
:help "Execute region through `shell-command-on-region' as
v5 did it - lp:990079. This might fail with certain chars - see UnicodeEncodeError lp:550661
Use `M-x customize-variable' to set it permanently"
:style toggle :selected python-mode-v5-behavior-p]
["Force shell name "
(setq py-force-py-shell-name-p
(not py-force-py-shell-name-p))
:help "When `t', execution with kind of Python specified in `py-shell-name' is enforced, possibly shebang doesn't take precedence. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-force-py-shell-name-p]
["Execute \"if name == main\" blocks p"
(setq py-if-name-main-permission-p
(not py-if-name-main-permission-p))
:help " `py-if-name-main-permission-p'
Allow execution of code inside blocks delimited by
if __name__ == '__main__'
Default is non-nil. "
:style toggle :selected py-if-name-main-permission-p]
["Ask about save"
(setq py-ask-about-save
(not py-ask-about-save))
:help "If not nil, ask about which buffers to save before executing some code.
Otherwise, all modified buffers are saved without asking.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-ask-about-save]
["Store result"
(setq py-store-result-p
(not py-store-result-p))
:help " `py-store-result-p'
When non-nil, put resulting string of `py-execute-...' into kill-ring, so it might be yanked. "
:style toggle :selected py-store-result-p]
["Prompt on changed "
(setq py-prompt-on-changed-p
(not py-prompt-on-changed-p))
:help "When called interactively, ask for save before a changed buffer is sent to interpreter.
Default is `t'Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-prompt-on-changed-p]
["Dedicated process "
(setq py-dedicated-process-p
(not py-dedicated-process-p))
:help "If commands executing code use a dedicated shell.
Default is nilUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-dedicated-process-p]
["Execute without temporary file"
(setq py-execute-no-temp-p
(not py-execute-no-temp-p))
:help " `py-execute-no-temp-p'
Seems Emacs-24.3 provided a way executing stuff without temporary files.
In experimental state yet "
:style toggle :selected py-execute-no-temp-p]
["Warn tmp files left "
(setq py--warn-tmp-files-left-p
(not py--warn-tmp-files-left-p))
:help "Messages a warning, when `py-temp-directory' contains files susceptible being left by previous Python-mode sessions. See also lp:987534 Use `M-x customize-variable' to set it permanently"
:style toggle :selected py--warn-tmp-files-left-p])
("Edit"
("Completion"
["Set Pymacs-based complete keymap "
(setq py-set-complete-keymap-p
(not py-set-complete-keymap-p))
:help "If `py-complete-initialize', which sets up enviroment for Pymacs based py-complete, should load it's keys into `python-mode-map'
Default is nil.
See also resp. edit `py-complete-set-keymap' Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-set-complete-keymap-p]
["Indent no completion "
(setq py-indent-no-completion-p
(not py-indent-no-completion-p))
:help "If completion function should indent when no completion found. Default is `t'
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-indent-no-completion-p]
["Company pycomplete "
(setq py-company-pycomplete-p
(not py-company-pycomplete-p))
:help "Load company-pycomplete stuff. Default is nilUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-company-pycomplete-p])
("Filling"
("Docstring styles"
:help "Switch docstring-style"
["Nil" py-set-nil-docstring-style
:help " `py-set-nil-docstring-style'
Set py-docstring-style to nil, format string normally. "]
["pep-257-nn" py-set-pep-257-nn-docstring-style
:help " `py-set-pep-257-nn-docstring-style'
Set py-docstring-style to 'pep-257-nn "]
["pep-257" py-set-pep-257-docstring-style
:help " `py-set-pep-257-docstring-style'
Set py-docstring-style to 'pep-257 "]
["django" py-set-django-docstring-style
:help " `py-set-django-docstring-style'
Set py-docstring-style to 'django "]
["onetwo" py-set-onetwo-docstring-style
:help " `py-set-onetwo-docstring-style'
Set py-docstring-style to 'onetwo "]
["symmetric" py-set-symmetric-docstring-style
:help " `py-set-symmetric-docstring-style'
Set py-docstring-style to 'symmetric "])
["Auto-fill mode"
(setq py-auto-fill-mode
(not py-auto-fill-mode))
:help "Fill according to `py-docstring-fill-column' and `py-comment-fill-column'
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-auto-fill-mode])
["Use current dir when execute"
(setq py-use-current-dir-when-execute-p
(not py-use-current-dir-when-execute-p))
:help " `toggle-py-use-current-dir-when-execute-p'
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-use-current-dir-when-execute-p]
("Indent"
("TAB related"
["indent-tabs-mode"
(setq indent-tabs-mode
(not indent-tabs-mode))
:help "Indentation can insert tabs if this is non-nil.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected indent-tabs-mode]
["Tab indent"
(setq py-tab-indent
(not py-tab-indent))
:help "Non-nil means TAB in Python mode calls `py-indent-line'.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-tab-indent]
["Tab shifts region "
(setq py-tab-shifts-region-p
(not py-tab-shifts-region-p))
:help "If `t', TAB will indent/cycle the region, not just the current line.
Default is nil
See also `py-tab-indents-region-p'
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-tab-shifts-region-p]
["Tab indents region "
(setq py-tab-indents-region-p
(not py-tab-indents-region-p))
:help "When `t' and first TAB doesn't shift, indent-region is called.
Default is nil
See also `py-tab-shifts-region-p'
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-tab-indents-region-p])
["Close at start column"
(setq py-closing-list-dedents-bos
(not py-closing-list-dedents-bos))
:help "When non-nil, indent list's closing delimiter like start-column.
It will be lined up under the first character of
the line that starts the multi-line construct, as in:
my_list = \[
1, 2, 3,
4, 5, 6,
]
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-closing-list-dedents-bos]
["Closing list keeps space"
(setq py-closing-list-keeps-space
(not py-closing-list-keeps-space))
:help "If non-nil, closing parenthesis dedents onto column of opening plus `py-closing-list-space', default is nil Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-closing-list-keeps-space]
["Closing list space"
(setq py-closing-list-space
(not py-closing-list-space))
:help "Number of chars, closing parenthesis outdent from opening, default is 1 Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-closing-list-space]
["Tab shifts region "
(setq py-tab-shifts-region-p
(not py-tab-shifts-region-p))
:help "If `t', TAB will indent/cycle the region, not just the current line.
Default is nil
See also `py-tab-indents-region-p'Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-tab-shifts-region-p]
["Lhs inbound indent"
(setq py-lhs-inbound-indent
(not py-lhs-inbound-indent))
:help "When line starts a multiline-assignment: How many colums indent should be more than opening bracket, brace or parenthesis. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-lhs-inbound-indent]
["Continuation offset"
(setq py-continuation-offset
(not py-continuation-offset))
:help "With numeric ARG different from 1 py-continuation-offset is set to that value; returns py-continuation-offset. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-continuation-offset]
["Electric colon"
(setq py-electric-colon-active-p
(not py-electric-colon-active-p))
:help " `py-electric-colon-active-p'
`py-electric-colon' feature. Default is `nil'. See lp:837065 for discussions. "
:style toggle :selected py-electric-colon-active-p]
["Electric colon at beginning of block only"
(setq py-electric-colon-bobl-only
(not py-electric-colon-bobl-only))
:help "When inserting a colon, do not indent lines unless at beginning of block.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-electric-colon-bobl-only]
["Electric yank active "
(setq py-electric-yank-active-p
(not py-electric-yank-active-p))
:help " When non-nil, `yank' will be followed by an `indent-according-to-mode'.
Default is nilUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-electric-yank-active-p]
["Electric kill backward "
(setq py-electric-kill-backward-p
(not py-electric-kill-backward-p))
:help "Affects `py-electric-backspace'. Default is nil.
If behind a delimited form of braces, brackets or parentheses,
backspace will kill it's contents
With when cursor after
my_string\[0:1]
--------------^
==>
my_string\[]
----------^
In result cursor is insided emptied delimited form.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-electric-kill-backward-p]
["Trailing whitespace smart delete "
(setq py-trailing-whitespace-smart-delete-p
(not py-trailing-whitespace-smart-delete-p))
:help "Default is nil. When t, python-mode calls
(add-hook 'before-save-hook 'delete-trailing-whitespace nil 'local)
Also commands may delete trailing whitespace by the way.
When editing other peoples code, this may produce a larger diff than expected Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-trailing-whitespace-smart-delete-p]
["Newline delete trailing whitespace "
(setq py-newline-delete-trailing-whitespace-p
(not py-newline-delete-trailing-whitespace-p))
:help "Delete trailing whitespace maybe left by `py-newline-and-indent'.
Default is `t'. See lp:1100892 Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-newline-delete-trailing-whitespace-p]
["Dedent keep relative column"
(setq py-dedent-keep-relative-column
(not py-dedent-keep-relative-column))
:help "If point should follow dedent or kind of electric move to end of line. Default is t - keep relative position. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-dedent-keep-relative-column]
["Indent paren spanned multilines "
(setq py-indent-paren-spanned-multilines-p
(not py-indent-paren-spanned-multilines-p))
:help "If non-nil, indents elements of list a value of `py-indent-offset' to first element:
def foo():
if (foo &&
baz):
bar()
Default lines up with first element:
def foo():
if (foo &&
baz):
bar()
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-indent-paren-spanned-multilines-p]
["Indent honors multiline listing"
(setq py-indent-honors-multiline-listing
(not py-indent-honors-multiline-listing))
:help "If `t', indents to 1\+ column of opening delimiter. If `nil', indent adds one level to the beginning of statement. Default is `nil'. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-indent-honors-multiline-listing]
["Indent comment "
(setq py-indent-comments
(not py-indent-comments))
:help "If comments should be indented like code. Default is `nil'.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-indent-comments]
["Uncomment indents "
(setq py-uncomment-indents-p
(not py-uncomment-indents-p))
:help "When non-nil, after uncomment indent lines. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-uncomment-indents-p]
["Indent honors inline comment"
(setq py-indent-honors-inline-comment
(not py-indent-honors-inline-comment))
:help "If non-nil, indents to column of inlined comment start.
Default is nil. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-indent-honors-inline-comment]
["Kill empty line"
(setq py-kill-empty-line
(not py-kill-empty-line))
:help "If t, py-indent-forward-line kills empty lines. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-kill-empty-line]
("Smart indentation"
:help "Toggle py-smart-indentation'
Use `M-x customize-variable' to set it permanently"
["Toggle py-smart-indentation" toggle-py-smart-indentation
:help "Toggles py-smart-indentation
Use `M-x customize-variable' to set it permanently"]
["py-smart-indentation on" py-smart-indentation-on
:help "Switches py-smart-indentation on
Use `M-x customize-variable' to set it permanently"]
["py-smart-indentation off" py-smart-indentation-off
:help "Switches py-smart-indentation off
Use `M-x customize-variable' to set it permanently"])
["Beep if tab change"
(setq py-beep-if-tab-change
(not py-beep-if-tab-change))
:help "Ring the bell if `tab-width' is changed.
If a comment of the form
# vi:set tabsize=:
is found before the first code line when the file is entered, and the
current value of (the general Emacs variable) `tab-width' does not
equal , `tab-width' is set to , a message saying so is
displayed in the echo area, and if `py-beep-if-tab-change' is non-nil
the Emacs bell is also rung as a warning.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-beep-if-tab-change]
["Highlight indentation" highlight-indentation
:help "Toggle highlight indentation.
Use `M-x customize-variable' to set it permanently
Make sure `highlight-indentation' is installed"
]
["Electric comment "
(setq py-electric-comment-p
(not py-electric-comment-p))
:help "If \"#\" should call `py-electric-comment'. Default is `nil'.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-electric-comment-p]
["Electric comment add space "
(setq py-electric-comment-add-space-p
(not py-electric-comment-add-space-p))
:help "If py-electric-comment should add a space. Default is `nil'. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-electric-comment-add-space-p]
["Empty line closes "
(setq py-empty-line-closes-p
(not py-empty-line-closes-p))
:help "When non-nil, dedent after empty line following block
if True:
print(\"Part of the if-statement\")
print(\"Not part of the if-statement\")
Default is nil
If non-nil, a C-j from empty line dedents.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-empty-line-closes-p])
["Defun use top level "
(setq py-defun-use-top-level-p
(not py-defun-use-top-level-p))
:help "When non-nil, keys C-M-a, C-M-e address top-level form.
Beginning- end-of-defun forms use
commands `py-backward-top-level', `py-forward-top-level'
mark-defun marks top-level form at point etc. "
:style toggle :selected py-defun-use-top-level-p]
["Close provides newline"
(setq py-close-provides-newline
(not py-close-provides-newline))
:help "If a newline is inserted, when line after block isn't empty. Default is non-nil. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-close-provides-newline]
["Block comment prefix "
(setq py-block-comment-prefix-p
(not py-block-comment-prefix-p))
:help "If py-comment inserts py-block-comment-prefix.
Default is tUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-block-comment-prefix-p])
("Display"
("Index"
["Imenu create index "
(setq py--imenu-create-index-p
(not py--imenu-create-index-p))
:help "Non-nil means Python mode creates and displays an index menu of functions and global variables. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py--imenu-create-index-p]
["Imenu show method args "
(setq py-imenu-show-method-args-p
(not py-imenu-show-method-args-p))
:help "Controls echoing of arguments of functions & methods in the Imenu buffer.
When non-nil, arguments are printed.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-imenu-show-method-args-p]
["Switch index-function" py-switch-imenu-index-function
:help "`py-switch-imenu-index-function'
Switch between `py--imenu-create-index' from 5.1 series and `py--imenu-create-index-new'."])
("Fontification"
["Mark decorators"
(setq py-mark-decorators
(not py-mark-decorators))
:help "If py-mark-def-or-class functions should mark decorators too. Default is `nil'. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-mark-decorators]
["Fontify shell buffer "
(setq py-fontify-shell-buffer-p
(not py-fontify-shell-buffer-p))
:help "If code in Python shell should be highlighted as in script buffer.
Default is nil.
If `t', related vars like `comment-start' will be set too.
Seems convenient when playing with stuff in IPython shell
Might not be TRT when a lot of output arrives Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-fontify-shell-buffer-p]
["Use font lock doc face "
(setq py-use-font-lock-doc-face-p
(not py-use-font-lock-doc-face-p))
:help "If documention string inside of def or class get `font-lock-doc-face'.
`font-lock-doc-face' inherits `font-lock-string-face'.
Call M-x `customize-face' in order to have a visible effect. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-use-font-lock-doc-face-p])
["Switch buffers on execute"
(setq py-switch-buffers-on-execute-p
(not py-switch-buffers-on-execute-p))
:help "When non-nil switch to the Python output buffer.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-switch-buffers-on-execute-p]
["Split windows on execute"
(setq py-split-window-on-execute
(not py-split-window-on-execute))
:help "When non-nil split windows.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-split-window-on-execute]
["Keep windows configuration"
(setq py-keep-windows-configuration
(not py-keep-windows-configuration))
:help "If a windows is splitted displaying results, this is directed by variable `py-split-window-on-execute'\. Also setting `py-switch-buffers-on-execute-p' affects window-configuration\. While commonly a screen splitted into source and Python-shell buffer is assumed, user may want to keep a different config\.
Setting `py-keep-windows-configuration' to `t' will restore windows-config regardless of settings mentioned above\. However, if an error occurs, it's displayed\.
To suppres window-changes due to error-signaling also: M-x customize-variable RET. Set `py-keep-4windows-configuration' onto 'force
Default is nil Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-keep-windows-configuration]
["Which split windows on execute function"
(progn
(if (eq 'split-window-vertically py-split-windows-on-execute-function)
(setq py-split-windows-on-execute-function'split-window-horizontally)
(setq py-split-windows-on-execute-function 'split-window-vertically))
(message "py-split-windows-on-execute-function set to: %s" py-split-windows-on-execute-function))
:help "If `split-window-vertically' or `...-horizontally'. Use `M-x customize-variable' RET `py-split-windows-on-execute-function' RET to set it permanently"
:style toggle :selected py-split-windows-on-execute-function]
["Modeline display full path "
(setq py-modeline-display-full-path-p
(not py-modeline-display-full-path-p))
:help "If the full PATH/TO/PYTHON should be displayed in shell modeline.
Default is nil. Note: when `py-shell-name' is specified with path, it's shown as an acronym in buffer-name already. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-modeline-display-full-path-p]
["Modeline acronym display home "
(setq py-modeline-acronym-display-home-p
(not py-modeline-acronym-display-home-p))
:help "If the modeline acronym should contain chars indicating the home-directory.
Default is nil Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-modeline-acronym-display-home-p]
["Hide show hide docstrings"
(setq py-hide-show-hide-docstrings
(not py-hide-show-hide-docstrings))
:help "Controls if doc strings can be hidden by hide-showUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-hide-show-hide-docstrings]
["Hide comments when hiding all"
(setq py-hide-comments-when-hiding-all
(not py-hide-comments-when-hiding-all))
:help "Hide the comments too when you do `hs-hide-all'. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-hide-comments-when-hiding-all]
["Max help buffer "
(setq py-max-help-buffer-p
(not py-max-help-buffer-p))
:help "If \"\*Python-Help\*\"-buffer should appear as the only visible.
Default is nil. In help-buffer, \"q\" will close it. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-max-help-buffer-p]
["Current defun show"
(setq py-current-defun-show
(not py-current-defun-show))
:help "If `py-current-defun' should jump to the definition, highlight it while waiting PY-WHICH-FUNC-DELAY seconds, before returning to previous position.
Default is `t'.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-current-defun-show]
["Match paren mode"
(setq py-match-paren-mode
(not py-match-paren-mode))
:help "Non-nil means, cursor will jump to beginning or end of a block.
This vice versa, to beginning first.
Sets `py-match-paren-key' in python-mode-map.
Customize `py-match-paren-key' which key to use. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-match-paren-mode])
("Debug"
["py-debug-p"
(setq py-debug-p
(not py-debug-p))
:help "When non-nil, keep resp\. store information useful for debugging\.
Temporary files are not deleted\. Other functions might implement
some logging etc\. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-debug-p]
["Pdbtrack do tracking "
(setq py-pdbtrack-do-tracking-p
(not py-pdbtrack-do-tracking-p))
:help "Controls whether the pdbtrack feature is enabled or not.
When non-nil, pdbtrack is enabled in all comint-based buffers,
e.g. shell buffers and the \*Python\* buffer. When using pdb to debug a
Python program, pdbtrack notices the pdb prompt and displays the
source file and line that the program is stopped at, much the same way
as gud-mode does for debugging C programs with gdb.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-pdbtrack-do-tracking-p]
["Jump on exception"
(setq py-jump-on-exception
(not py-jump-on-exception))
:help "Jump to innermost exception frame in Python output buffer.
When this variable is non-nil and an exception occurs when running
Python code synchronously in a subprocess, jump immediately to the
source code of the innermost traceback frame.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-jump-on-exception]
["Highlight error in source "
(setq py-highlight-error-source-p
(not py-highlight-error-source-p))
:help "Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-highlight-error-source-p])
("Other"
("Directory"
["Guess install directory "
(setq py-guess-py-install-directory-p
(not py-guess-py-install-directory-p))
:help "If in cases, `py-install-directory' isn't set, `py-set-load-path'should guess it from `buffer-file-name'. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-guess-py-install-directory-p]
["Use local default"
(setq py-use-local-default
(not py-use-local-default))
:help "If `t', py-shell will use `py-shell-local-path' instead
of default Python.
Making switch between several virtualenv's easier,
`python-mode' should deliver an installer, so named-shells pointing to virtualenv's will be available. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-use-local-default]
["Use current dir when execute "
(setq py-use-current-dir-when-execute-p
(not py-use-current-dir-when-execute-p))
:help "When `t', current directory is used by Python-shell for output of `py-execute-buffer' and related commands.
See also `py-execute-directory'Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-use-current-dir-when-execute-p]
["Keep shell dir when execute "
(setq py-keep-shell-dir-when-execute-p
(not py-keep-shell-dir-when-execute-p))
:help "Don't change Python shell's current working directory when sending code.
See also `py-execute-directory'Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-keep-shell-dir-when-execute-p]
["Fileless buffer use default directory "
(setq py-fileless-buffer-use-default-directory-p
(not py-fileless-buffer-use-default-directory-p))
:help "When `py-use-current-dir-when-execute-p' is non-nil and no buffer-file exists, value of `default-directory' sets current working directory of Python output shellUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-fileless-buffer-use-default-directory-p])
("Underscore word syntax"
:help "Toggle `py-underscore-word-syntax-p'"
["Toggle underscore word syntax" toggle-py-underscore-word-syntax-p
:help " `toggle-py-underscore-word-syntax-p'
If `py-underscore-word-syntax-p' should be on or off.
Returns value of `py-underscore-word-syntax-p' switched to. .
Use `M-x customize-variable' to set it permanently"]
["Underscore word syntax on" py-underscore-word-syntax-p-on
:help " `py-underscore-word-syntax-p-on'
Make sure, py-underscore-word-syntax-p' is on.
Returns value of `py-underscore-word-syntax-p'. .
Use `M-x customize-variable' to set it permanently"]
["Underscore word syntax off" py-underscore-word-syntax-p-off
:help " `py-underscore-word-syntax-p-off'
Make sure, `py-underscore-word-syntax-p' is off.
Returns value of `py-underscore-word-syntax-p'. .
Use `M-x customize-variable' to set it permanently"])
["Load pymacs "
(setq py-load-pymacs-p
(not py-load-pymacs-p))
:help "If Pymacs related stuff should be loaded.
Default is nil.
Pymacs has been written by François Pinard and many others.
See original source: http://pymacs.progiciels-bpi.caUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-load-pymacs-p]
["Verbose "
(setq py-verbose-p
(not py-verbose-p))
:help "If functions should report results.
Default is nil. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-verbose-p]
["Empty comment line separates paragraph "
(setq py-empty-comment-line-separates-paragraph-p
(not py-empty-comment-line-separates-paragraph-p))
:help "Consider paragraph start/end lines with nothing inside but comment sign.
Default is non-nilUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-empty-comment-line-separates-paragraph-p]
["Org cycle "
(setq py-org-cycle-p
(not py-org-cycle-p))
:help "When non-nil, command `org-cycle' is available at shift-TAB,
Default is nil. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-org-cycle-p]
["Set pager cat"
(setq py-set-pager-cat-p
(not py-set-pager-cat-p))
:help "If the shell environment variable \$PAGER should set to `cat'.
If `t', use `C-c C-r' to jump to beginning of output. Then scroll normally.
Avoids lp:783828, \"Terminal not fully functional\", for help('COMMAND') in python-shell
When non-nil, imports module `os' Use `M-x customize-variable' to
set it permanently"
:style toggle :selected py-set-pager-cat-p]
["Edit only "
(setq py-edit-only-p
(not py-edit-only-p))
:help "When `t' `python-mode' will not take resort nor check for installed Python executables. Default is nil.
See bug report at launchpad, lp:944093. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-edit-only-p])))
("Other"
["Boolswitch" py-boolswitch
:help " `py-boolswitch'
Edit the assignment of a boolean variable, revert them."]
["Empty out list backward" py-empty-out-list-backward
:help " `py-empty-out-list-backward'
Deletes all elements from list before point."]
["Kill buffer unconditional" py-kill-buffer-unconditional
:help " `py-kill-buffer-unconditional'
Kill buffer unconditional, kill buffer-process if existing."]
["Remove overlays at point" py-remove-overlays-at-point
:help " `py-remove-overlays-at-point'
Remove overlays as set when ‘py-highlight-error-source-p’ is non-nil."]
("Electric"
["Complete electric comma" py-complete-electric-comma
:help " `py-complete-electric-comma'"]
["Complete electric lparen" py-complete-electric-lparen
:help " `py-complete-electric-lparen'"]
["Electric backspace" py-electric-backspace
:help " `py-electric-backspace'
Delete preceding character or level of indentation."]
["Electric colon" py-electric-colon
:help " `py-electric-colon'
Insert a colon and indent accordingly."]
["Electric comment" py-electric-comment
:help " `py-electric-comment'
Insert a comment. If starting a comment, indent accordingly."]
["Electric delete" py-electric-delete
:help " `py-electric-delete'
Delete following character or levels of whitespace."]
["Electric yank" py-electric-yank
:help " `py-electric-yank'
Perform command ‘yank’ followed by an ‘indent-according-to-mode’"]
["Hungry delete backwards" py-hungry-delete-backwards
:help " `py-hungry-delete-backwards'
Delete the preceding character or all preceding whitespace"]
["Hungry delete forward" py-hungry-delete-forward
:help " `py-hungry-delete-forward'
Delete the following character or all following whitespace"])
("Filling"
["Py docstring style" py-py-docstring-style
:help " `py-py-docstring-style'"]
["Py fill comment" py-py-fill-comment
:help " `py-py-fill-comment'"]
["Py fill paragraph" py-py-fill-paragraph
:help " `py-py-fill-paragraph'"]
["Py fill string" py-py-fill-string
:help " `py-py-fill-string'"]
["Py fill string django" py-py-fill-string-django
:help " `py-py-fill-string-django'"]
["Py fill string onetwo" py-py-fill-string-onetwo
:help " `py-py-fill-string-onetwo'"]
["Py fill string pep 257" py-py-fill-string-pep-257
:help " `py-py-fill-string-pep-257'"]
["Py fill string pep 257 nn" py-py-fill-string-pep-257-nn
:help " `py-py-fill-string-pep-257-nn'"]
["Py fill string symmetric" py-py-fill-string-symmetric
:help " `py-py-fill-string-symmetric'"])
("Abbrevs" :help "see also `py-add-abbrev'"
:filter (lambda (&rest junk)
(abbrev-table-menu python-mode-abbrev-table)))
["Add abbrev" py-add-abbrev
:help " `py-add-abbrev'
Defines python-mode specific abbrev for last expressions before point."]
("Completion"
["Py indent or complete" py-py-indent-or-complete
:help " `py-py-indent-or-complete'"]
["Py shell complete" py-py-shell-complete
:help " `py-py-shell-complete'"]
["Py complete" py-py-complete
:help " `py-py-complete'"])
["Find function" py-find-function
:help " `py-find-function'
Find source of definition of SYMBOL."])))
map)
;; python-components-map
(defvar py-use-menu-p t
"If the menu should be loaded.
Default is `t'")
(defvar py-menu nil
"Make a dynamically bound variable py-menu")
(defvar python-mode-map nil)
(setq python-mode-map
(let ((map (make-sparse-keymap)))
;; electric keys
(define-key map [(:)] 'py-electric-colon)
(define-key map [(\#)] 'py-electric-comment)
(define-key map [(delete)] 'py-electric-delete)
(define-key map [(backspace)] 'py-electric-backspace)
(define-key map [(control backspace)] 'py-hungry-delete-backwards)
(define-key map [(control c) (delete)] 'py-hungry-delete-forward)
;; (define-key map [(control y)] 'py-electric-yank)
;; moving point
(define-key map [(control c)(control p)] 'py-backward-statement)
(define-key map [(control c)(control n)] 'py-forward-statement)
(define-key map [(control c)(control u)] 'py-backward-block)
(define-key map [(control c)(control q)] 'py-forward-block)
(define-key map [(control meta a)] 'py-backward-def-or-class)
(define-key map [(control meta e)] 'py-forward-def-or-class)
;; (define-key map [(meta i)] 'py-indent-forward-line)
(define-key map [(control j)] 'py-newline-and-indent)
;; Most Pythoneers expect RET `py-newline-and-indent'
;; (define-key map (kbd "RET") 'py-newline-and-dedent)
(define-key map (kbd "RET") py-return-key)
;; (define-key map (kbd "RET") 'newline)
(define-key map [(super backspace)] 'py-dedent)
;; (define-key map [(control return)] 'py-newline-and-dedent)
;; indentation level modifiers
(define-key map [(control c)(control l)] 'py-shift-left)
(define-key map [(control c)(control r)] 'py-shift-right)
(define-key map [(control c)(<)] 'py-shift-left)
(define-key map [(control c)(>)] 'py-shift-right)
(define-key map [(control c)(tab)] 'py-indent-region)
(define-key map [(control c)(:)] 'py-guess-indent-offset)
;; subprocess commands
(define-key map [(control c)(control c)] 'py-execute-buffer)
(define-key map [(control c)(control m)] 'py-execute-import-or-reload)
(define-key map [(control c)(control s)] 'py-execute-string)
(define-key map [(control c)(|)] 'py-execute-region)
(define-key map [(control meta x)] 'py-execute-def-or-class)
(define-key map [(control c)(!)] 'py-shell)
(define-key map [(control c)(control t)] 'py-toggle-shell)
(define-key map [(control meta h)] 'py-mark-def-or-class)
(define-key map [(control c)(control k)] 'py-mark-block-or-clause)
(define-key map [(control c)(.)] 'py-expression)
;; Miscellaneous
;; (define-key map [(super q)] 'py-copy-statement)
(define-key map [(control c)(control d)] 'py-pdbtrack-toggle-stack-tracking)
(define-key map [(control c)(control f)] 'py-sort-imports)
(define-key map [(control c)(\#)] 'py-comment-region)
(define-key map [(control c)(\?)] 'py-describe-mode)
(define-key map [(control c)(control e)] 'py-help-at-point)
(define-key map [(control c)(-)] 'py-up-exception)
(define-key map [(control c)(=)] 'py-down-exception)
(define-key map [(control x) (n) (d)] 'py-narrow-to-defun)
;; information
(define-key map [(control c)(control b)] 'py-submit-bug-report)
(define-key map [(control c)(control v)] 'py-version)
(define-key map [(control c)(control w)] 'py-pychecker-run)
;; (define-key map (kbd "TAB") 'py-indent-line)
(define-key map (kbd "TAB") 'py-indent-or-complete)
;; (if py-complete-function
;; (progn
;; (define-key map [(meta tab)] py-complete-function)
;; (define-key map [(esc) (tab)] py-complete-function))
;; (define-key map [(meta tab)] 'py-shell-complete)
;; (define-key map [(esc) (tab)] 'py-shell-complete))
(substitute-key-definition 'complete-symbol 'completion-at-point
map global-map)
(substitute-key-definition 'backward-up-list 'py-up
map global-map)
(substitute-key-definition 'down-list 'py-down
map global-map)
(when py-use-menu-p
(setq map (py-define-menu map)))
map))
(defvaralias 'py-mode-map 'python-mode-map)
(defvar py-python-shell-mode-map
(let ((map (make-sparse-keymap)))
(define-key map (kbd "RET") 'comint-send-input)
(define-key map [(control c)(-)] 'py-up-exception)
(define-key map [(control c)(=)] 'py-down-exception)
(define-key map (kbd "TAB") 'py-indent-or-complete)
(define-key map [(meta tab)] 'py-shell-complete)
(define-key map [(control c)(!)] 'py-shell)
(define-key map [(control c)(control t)] 'py-toggle-shell)
;; electric keys
;; (define-key map [(:)] 'py-electric-colon)
;; (define-key map [(\#)] 'py-electric-comment)
;; (define-key map [(delete)] 'py-electric-delete)
;; (define-key map [(backspace)] 'py-electric-backspace)
;; (define-key map [(control backspace)] 'py-hungry-delete-backwards)
;; (define-key map [(control c) (delete)] 'py-hungry-delete-forward)
;; (define-key map [(control y)] 'py-electric-yank)
;; moving point
(define-key map [(control c)(control p)] 'py-backward-statement)
(define-key map [(control c)(control n)] 'py-forward-statement)
(define-key map [(control c)(control u)] 'py-backward-block)
(define-key map [(control c)(control q)] 'py-forward-block)
(define-key map [(control meta a)] 'py-backward-def-or-class)
(define-key map [(control meta e)] 'py-forward-def-or-class)
(define-key map [(control j)] 'py-newline-and-indent)
(define-key map [(super backspace)] 'py-dedent)
;; (define-key map [(control return)] 'py-newline-and-dedent)
;; indentation level modifiers
(define-key map [(control c)(control l)] 'comint-dynamic-list-input-ring)
(define-key map [(control c)(control r)] 'comint-previous-prompt)
(define-key map [(control c)(<)] 'py-shift-left)
(define-key map [(control c)(>)] 'py-shift-right)
(define-key map [(control c)(tab)] 'py-indent-region)
(define-key map [(control c)(:)] 'py-guess-indent-offset)
;; subprocess commands
(define-key map [(control meta h)] 'py-mark-def-or-class)
(define-key map [(control c)(control k)] 'py-mark-block-or-clause)
(define-key map [(control c)(.)] 'py-expression)
;; Miscellaneous
;; (define-key map [(super q)] 'py-copy-statement)
(define-key map [(control c)(control d)] 'py-pdbtrack-toggle-stack-tracking)
(define-key map [(control c)(\#)] 'py-comment-region)
(define-key map [(control c)(\?)] 'py-describe-mode)
(define-key map [(control c)(control e)] 'py-help-at-point)
(define-key map [(control x) (n) (d)] 'py-narrow-to-defun)
;; information
(define-key map [(control c)(control b)] 'py-submit-bug-report)
(define-key map [(control c)(control v)] 'py-version)
(define-key map [(control c)(control w)] 'py-pychecker-run)
(substitute-key-definition 'complete-symbol 'completion-at-point
map global-map)
(substitute-key-definition 'backward-up-list 'py-up
map global-map)
(substitute-key-definition 'down-list 'py-down
map global-map)
map)
"Used inside a Python-shell")
(defvar py-ipython-shell-mode-map py-python-shell-mode-map
"Unless setting of ipython-shell-mode needs to be different, let's save some lines of code and copy py-python-shell-mode-map here.")
(defvar py-shell-map py-python-shell-mode-map)
(setq python-font-lock-keywords
;; Keywords
`(,(rx symbol-start
(or
"if" "and" "del" "not" "while" "as" "elif" "global"
"or" "async with" "with" "assert" "else" "pass" "yield" "break"
"exec" "in" "continue" "finally" "is" "except" "raise"
"return" "async for" "for" "lambda" "await")
symbol-end)
(,(rx symbol-start (or "async def" "def" "class") symbol-end) . py-def-class-face)
(,(rx symbol-start (or "import" "from") symbol-end) . py-import-from-face)
(,(rx symbol-start (or "try" "if") symbol-end) . py-try-if-face)
;; functions
(,(rx symbol-start "def" (1+ space) (group (1+ (or word ?_))))
(1 font-lock-function-name-face))
(,(rx symbol-start "async def" (1+ space) (group (1+ (or word ?_))))
(1 font-lock-function-name-face))
;; classes
(,(rx symbol-start (group "class") (1+ space) (group (1+ (or word ?_))))
(1 py-def-class-face) (2 py-class-name-face))
(,(rx symbol-start
(or "Ellipsis" "True" "False" "None" "__debug__" "NotImplemented")
symbol-end) . py-pseudo-keyword-face)
;; Decorators.
(,(rx line-start (* (any " \t")) (group "@" (1+ (or word ?_))
(0+ "." (1+ (or word ?_)))))
(1 py-decorators-face))
(,(rx symbol-start (or "cls" "self")
symbol-end) . py-object-reference-face)
;; Exceptions
(,(rx word-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" "NoResultFound"
"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")
word-end) . py-exception-name-face)
;; Builtins
(,(rx
(or space line-start (not (any ".(")))
symbol-start
(group (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" "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" "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) (1 py-builtins-face))
("\\([._[:word:]]+\\)\\(?:\\[[^]]+]\\)?[[:space:]]*\\(?:\\(?:\\*\\*\\|//\\|<<\\|>>\\|[%&*+/|^-]\\)?=\\)"
(1 py-variable-name-face nil nil))
;; a, b, c = (1, 2, 3)
(,(lambda (limit)
(let ((re (rx (group (+ (any word ?. ?_))) (* space)
(* ?, (* space) (+ (any word ?. ?_)) (* space))
?, (* space) (+ (any word ?. ?_)) (* space)
(or "=" "+=" "-=" "*=" "/=" "//=" "%=" "**=" ">>=" "<<=" "&=" "^=" "|=")))
(res nil))
(while (and (setq res (re-search-forward re limit t))
(goto-char (match-end 1))
(nth 1 (parse-partial-sexp (point-min) (point)))
;; (python-syntax-context 'paren)
))
res))
(1 py-variable-name-face nil nil))
;; Numbers
;; (,(rx symbol-start (or (1+ digit) (1+ hex-digit)) symbol-end) . py-number-face)
(,(rx symbol-start (1+ digit) symbol-end) . py-number-face)))
;; python-components-switches
;; Toggle highlight-indentation
(defun py-toggle-highlight-indentation (&optional indent)
"If `highlight-indentation-p' should be on or off. "
(interactive "P")
;; (let ((indent indent))
(unless (featurep 'highlight-indentation)
(load (concat (py--normalize-directory py-install-directory) "extensions" (char-to-string py-separator-char) "highlight-indentation.el")))
(highlight-indentation indent)
(when py-verbose-p (message "highlight-indent-active: %s" highlight-indent-active))
highlight-indent-active)
(defun py-highlight-indentation-off ()
"If `highlight-indentation-p' should be on or off. "
(interactive)
(unless (featurep 'highlight-indentation)
(load (concat (py--normalize-directory py-install-directory) "extensions" (char-to-string py-separator-char) "highlight-indentation.el")))
(highlight-indentation-off)
(when py-verbose-p (message "highlight-indent-active: %s" highlight-indent-active))
highlight-indent-active)
(defun py-highlight-indentation-on ()
"If `highlight-indentation-p' should be on or off. "
(interactive "P")
(unless (featurep 'highlight-indentation)
(load (concat (py--normalize-directory py-install-directory) "extensions" (char-to-string py-separator-char) "highlight-indentation.el")))
(highlight-indentation-on)
(when py-verbose-p (message "highlight-indent-active: %s" highlight-indent-active))
highlight-indent-active)
;; Smart indentation
(defalias 'toggle-py-smart-indentation 'py-toggle-smart-indentation)
(defun py-toggle-smart-indentation (&optional arg)
"If `py-smart-indentation' should be on or off.
Returns value of `py-smart-indentation' switched to. "
(interactive)
(let ((arg (or arg (if py-smart-indentation -1 1))))
(if (< 0 arg)
(progn
(setq py-smart-indentation t)
(py-guess-indent-offset))
(setq py-smart-indentation nil)
(setq py-indent-offset (default-value 'py-indent-offset)))
(when (called-interactively-p 'any) (message "py-smart-indentation: %s" py-smart-indentation))
py-smart-indentation))
(defun py-smart-indentation-on (&optional arg)
"Make sure, `py-smart-indentation' is on.
Returns value of `py-smart-indentation'. "
(interactive "p")
(let ((arg (or arg 1)))
(toggle-py-smart-indentation arg))
(when (called-interactively-p 'any) (message "py-smart-indentation: %s" py-smart-indentation))
py-smart-indentation)
(defun py-smart-indentation-off (&optional arg)
"Make sure, `py-smart-indentation' is off.
Returns value of `py-smart-indentation'. "
(interactive "p")
(let ((arg (if arg (- arg) -1)))
(toggle-py-smart-indentation arg))
(when (called-interactively-p 'any) (message "py-smart-indentation: %s" py-smart-indentation))
py-smart-indentation)
(defun py-toggle-sexp-function ()
"Opens customization "
(interactive)
(customize-variable 'py-sexp-function))
;; Autopair mode
;; py-autopair-mode forms
(defalias 'toggle-py-autopair-mode 'py-toggle-autopair-mode)
(defun py-toggle-autopair-mode ()
"If `py-autopair-mode' should be on or off.
Returns value of `py-autopair-mode' switched to. "
(interactive)
(and (py-autopair-check)
(setq py-autopair-mode (autopair-mode (if autopair-mode 0 1)))))
(defun py-autopair-mode-on ()
"Make sure, py-autopair-mode' is on.
Returns value of `py-autopair-mode'. "
(interactive)
(and (py-autopair-check)
(setq py-autopair-mode (autopair-mode 1))))
(defun py-autopair-mode-off ()
"Make sure, py-autopair-mode' is off.
Returns value of `py-autopair-mode'. "
(interactive)
(setq py-autopair-mode (autopair-mode 0)))
;; Smart operator
;; py-smart-operator-mode-p forms
(defun toggle-py-smart-operator-mode-p ()
"If `py-smart-operator-mode-p' should be on or off.
Returns value of `py-smart-operator-mode-p' switched to. "
(interactive)
(and (py-smart-operator-check)
(setq py-smart-operator-mode-p (smart-operator-mode (if smart-operator-mode 0 1)))))
(defun py-smart-operator-mode-p-on ()
"Make sure, py-smart-operator-mode-p' is on.
Returns value of `py-smart-operator-mode-p'. "
(interactive)
(and (py-smart-operator-check)
(setq py-smart-operator-mode-p (smart-operator-mode 1))))
(defun py-smart-operator-mode-p-off ()
"Make sure, py-smart-operator-mode-p' is off.
Returns value of `py-smart-operator-mode-p'. "
(interactive)
(setq py-smart-operator-mode-p (smart-operator-mode 0)))
;; py-switch-buffers-on-execute-p forms
(defun toggle-py-switch-buffers-on-execute-p (&optional arg)
"If `py-switch-buffers-on-execute-p' should be on or off.
Returns value of `py-switch-buffers-on-execute-p' switched to. "
(interactive)
(let ((arg (or arg (if py-switch-buffers-on-execute-p -1 1))))
(if (< 0 arg)
(setq py-switch-buffers-on-execute-p t)
(setq py-switch-buffers-on-execute-p nil))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-switch-buffers-on-execute-p: %s" py-switch-buffers-on-execute-p))
py-switch-buffers-on-execute-p))
(defun py-switch-buffers-on-execute-p-on (&optional arg)
"Make sure, `py-py-switch-buffers-on-execute-p' is on.
Returns value of `py-switch-buffers-on-execute-p'. "
(interactive)
(let ((arg (or arg 1)))
(toggle-py-switch-buffers-on-execute-p arg))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-switch-buffers-on-execute-p: %s" py-switch-buffers-on-execute-p))
py-switch-buffers-on-execute-p)
(defun py-switch-buffers-on-execute-p-off ()
"Make sure, `py-switch-buffers-on-execute-p' is off.
Returns value of `py-switch-buffers-on-execute-p'. "
(interactive)
(toggle-py-switch-buffers-on-execute-p -1)
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-switch-buffers-on-execute-p: %s" py-switch-buffers-on-execute-p))
py-switch-buffers-on-execute-p)
;; py-split-window-on-execute forms
(defun toggle-py-split-window-on-execute (&optional arg)
"If `py-split-window-on-execute' should be on or off.
Returns value of `py-split-window-on-execute' switched to. "
(interactive)
(let ((arg (or arg (if py-split-window-on-execute -1 1))))
(if (< 0 arg)
(setq py-split-window-on-execute t)
(setq py-split-window-on-execute nil))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-split-window-on-execute: %s" py-split-window-on-execute))
py-split-window-on-execute))
(defun py-split-window-on-execute-on (&optional arg)
"Make sure, `py-py-split-window-on-execute' is on.
Returns value of `py-split-window-on-execute'. "
(interactive)
(let ((arg (or arg 1)))
(toggle-py-split-window-on-execute arg))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-split-window-on-execute: %s" py-split-window-on-execute))
py-split-window-on-execute)
(defun py-split-window-on-execute-off ()
"Make sure, `py-split-window-on-execute' is off.
Returns value of `py-split-window-on-execute'. "
(interactive)
(toggle-py-split-window-on-execute -1)
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-split-window-on-execute: %s" py-split-window-on-execute))
py-split-window-on-execute)
;; py-fontify-shell-buffer-p forms
(defun toggle-py-fontify-shell-buffer-p (&optional arg)
"If `py-fontify-shell-buffer-p' should be on or off.
Returns value of `py-fontify-shell-buffer-p' switched to. "
(interactive)
(let ((arg (or arg (if py-fontify-shell-buffer-p -1 1))))
(if (< 0 arg)
(progn
(setq py-fontify-shell-buffer-p t)
(set (make-local-variable 'font-lock-defaults)
'(python-font-lock-keywords nil nil nil nil
(font-lock-syntactic-keywords
. py-font-lock-syntactic-keywords)))
(unless (looking-at comint-prompt-regexp)
(when (re-search-backward comint-prompt-regexp nil t 1)
(font-lock-fontify-region (line-beginning-position) (point-max)))))
(setq py-fontify-shell-buffer-p nil))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-fontify-shell-buffer-p: %s" py-fontify-shell-buffer-p))
py-fontify-shell-buffer-p))
(defun py-fontify-shell-buffer-p-on (&optional arg)
"Make sure, `py-py-fontify-shell-buffer-p' is on.
Returns value of `py-fontify-shell-buffer-p'. "
(interactive)
(let ((arg (or arg 1)))
(toggle-py-fontify-shell-buffer-p arg))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-fontify-shell-buffer-p: %s" py-fontify-shell-buffer-p))
py-fontify-shell-buffer-p)
(defun py-fontify-shell-buffer-p-off ()
"Make sure, `py-fontify-shell-buffer-p' is off.
Returns value of `py-fontify-shell-buffer-p'. "
(interactive)
(toggle-py-fontify-shell-buffer-p -1)
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-fontify-shell-buffer-p: %s" py-fontify-shell-buffer-p))
py-fontify-shell-buffer-p)
;; python-mode-v5-behavior-p forms
(defun toggle-python-mode-v5-behavior-p (&optional arg)
"If `python-mode-v5-behavior-p' should be on or off.
Returns value of `python-mode-v5-behavior-p' switched to. "
(interactive)
(let ((arg (or arg (if python-mode-v5-behavior-p -1 1))))
(if (< 0 arg)
(setq python-mode-v5-behavior-p t)
(setq python-mode-v5-behavior-p nil))
(when (or py-verbose-p (called-interactively-p 'any)) (message "python-mode-v5-behavior-p: %s" python-mode-v5-behavior-p))
python-mode-v5-behavior-p))
(defun python-mode-v5-behavior-p-on (&optional arg)
"Make sure, `python-mode-v5-behavior-p' is on.
Returns value of `python-mode-v5-behavior-p'. "
(interactive)
(let ((arg (or arg 1)))
(toggle-python-mode-v5-behavior-p arg))
(when (or py-verbose-p (called-interactively-p 'any)) (message "python-mode-v5-behavior-p: %s" python-mode-v5-behavior-p))
python-mode-v5-behavior-p)
(defun python-mode-v5-behavior-p-off ()
"Make sure, `python-mode-v5-behavior-p' is off.
Returns value of `python-mode-v5-behavior-p'. "
(interactive)
(toggle-python-mode-v5-behavior-p -1)
(when (or py-verbose-p (called-interactively-p 'any)) (message "python-mode-v5-behavior-p: %s" python-mode-v5-behavior-p))
python-mode-v5-behavior-p)
;; py-jump-on-exception forms
(defun toggle-py-jump-on-exception (&optional arg)
"If `py-jump-on-exception' should be on or off.
Returns value of `py-jump-on-exception' switched to. "
(interactive)
(let ((arg (or arg (if py-jump-on-exception -1 1))))
(if (< 0 arg)
(setq py-jump-on-exception t)
(setq py-jump-on-exception nil))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-jump-on-exception: %s" py-jump-on-exception))
py-jump-on-exception))
(defun py-jump-on-exception-on (&optional arg)
"Make sure, py-jump-on-exception' is on.
Returns value of `py-jump-on-exception'. "
(interactive)
(let ((arg (or arg 1)))
(toggle-py-jump-on-exception arg))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-jump-on-exception: %s" py-jump-on-exception))
py-jump-on-exception)
(defun py-jump-on-exception-off ()
"Make sure, `py-jump-on-exception' is off.
Returns value of `py-jump-on-exception'. "
(interactive)
(toggle-py-jump-on-exception -1)
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-jump-on-exception: %s" py-jump-on-exception))
py-jump-on-exception)
;; py-use-current-dir-when-execute-p forms
(defun toggle-py-use-current-dir-when-execute-p (&optional arg)
"If `py-use-current-dir-when-execute-p' should be on or off.
Returns value of `py-use-current-dir-when-execute-p' switched to. "
(interactive)
(let ((arg (or arg (if py-use-current-dir-when-execute-p -1 1))))
(if (< 0 arg)
(setq py-use-current-dir-when-execute-p t)
(setq py-use-current-dir-when-execute-p nil))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-use-current-dir-when-execute-p: %s" py-use-current-dir-when-execute-p))
py-use-current-dir-when-execute-p))
(defun py-use-current-dir-when-execute-p-on (&optional arg)
"Make sure, py-use-current-dir-when-execute-p' is on.
Returns value of `py-use-current-dir-when-execute-p'. "
(interactive)
(let ((arg (or arg 1)))
(toggle-py-use-current-dir-when-execute-p arg))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-use-current-dir-when-execute-p: %s" py-use-current-dir-when-execute-p))
py-use-current-dir-when-execute-p)
(defun py-use-current-dir-when-execute-p-off ()
"Make sure, `py-use-current-dir-when-execute-p' is off.
Returns value of `py-use-current-dir-when-execute-p'. "
(interactive)
(toggle-py-use-current-dir-when-execute-p -1)
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-use-current-dir-when-execute-p: %s" py-use-current-dir-when-execute-p))
py-use-current-dir-when-execute-p)
;; py-electric-comment-p forms
(defun toggle-py-electric-comment-p (&optional arg)
"If `py-electric-comment-p' should be on or off.
Returns value of `py-electric-comment-p' switched to. "
(interactive)
(let ((arg (or arg (if py-electric-comment-p -1 1))))
(if (< 0 arg)
(setq py-electric-comment-p t)
(setq py-electric-comment-p nil))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-electric-comment-p: %s" py-electric-comment-p))
py-electric-comment-p))
(defun py-electric-comment-p-on (&optional arg)
"Make sure, py-electric-comment-p' is on.
Returns value of `py-electric-comment-p'. "
(interactive)
(let ((arg (or arg 1)))
(toggle-py-electric-comment-p arg))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-electric-comment-p: %s" py-electric-comment-p))
py-electric-comment-p)
(defun py-electric-comment-p-off ()
"Make sure, `py-electric-comment-p' is off.
Returns value of `py-electric-comment-p'. "
(interactive)
(toggle-py-electric-comment-p -1)
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-electric-comment-p: %s" py-electric-comment-p))
py-electric-comment-p)
;; py-underscore-word-syntax-p forms
(defun toggle-py-underscore-word-syntax-p (&optional arg)
"If `py-underscore-word-syntax-p' should be on or off.
Returns value of `py-underscore-word-syntax-p' switched to. "
(interactive)
(let ((arg (or arg (if py-underscore-word-syntax-p -1 1))))
(if (< 0 arg)
(progn
(setq py-underscore-word-syntax-p t)
(modify-syntax-entry ?\_ "w" python-mode-syntax-table))
(setq py-underscore-word-syntax-p nil)
(modify-syntax-entry ?\_ "_" python-mode-syntax-table))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-underscore-word-syntax-p: %s" py-underscore-word-syntax-p))
py-underscore-word-syntax-p))
(defun py-underscore-word-syntax-p-on (&optional arg)
"Make sure, py-underscore-word-syntax-p' is on.
Returns value of `py-underscore-word-syntax-p'. "
(interactive)
(let ((arg (or arg 1)))
(toggle-py-underscore-word-syntax-p arg))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-underscore-word-syntax-p: %s" py-underscore-word-syntax-p))
py-underscore-word-syntax-p)
(defun py-underscore-word-syntax-p-off ()
"Make sure, `py-underscore-word-syntax-p' is off.
Returns value of `py-underscore-word-syntax-p'. "
(interactive)
(toggle-py-underscore-word-syntax-p -1)
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-underscore-word-syntax-p: %s" py-underscore-word-syntax-p))
py-underscore-word-syntax-p)
;; toggle-py-underscore-word-syntax-p must be known already
;; circular: toggle-py-underscore-word-syntax-p sets and calls it
(defcustom py-underscore-word-syntax-p t
"If underscore chars should be of syntax-class `word', not of `symbol'.
Underscores in word-class makes `forward-word' etc. travel the indentifiers. Default is `t'.
See bug report at launchpad, lp:940812 "
:type 'boolean
:tag "py-underscore-word-syntax-p"
:group 'python-mode
:set (lambda (symbol value)
(set-default symbol value)
(toggle-py-underscore-word-syntax-p (if value 1 0))))
;; python-components-edit
(defvar py-keywords "\\<\\(ArithmeticError\\|AssertionError\\|AttributeError\\|BaseException\\|BufferError\\|BytesWarning\\|DeprecationWarning\\|EOFError\\|Ellipsis\\|EnvironmentError\\|Exception\\|False\\|FloatingPointError\\|FutureWarning\\|GeneratorExit\\|IOError\\|ImportError\\|ImportWarning\\|IndentationError\\|IndexError\\|KeyError\\|KeyboardInterrupt\\|LookupError\\|MemoryError\\|NameError\\|NoneNotImplementedError\\|NotImplemented\\|OSError\\|OverflowError\\|PendingDeprecationWarning\\|ReferenceError\\|RuntimeError\\|RuntimeWarning\\|StandardError\\|StopIteration\\|SyntaxError\\|SyntaxWarning\\|SystemError\\|SystemExit\\|TabError\\|True\\|TypeError\\|UnboundLocalError\\|UnicodeDecodeError\\|UnicodeEncodeError\\|UnicodeError\\|UnicodeTranslateError\\|UnicodeWarning\\|UserWarning\\|ValueError\\|Warning\\|ZeroDivisionError\\|__debug__\\|__import__\\|__name__\\|abs\\|all\\|and\\|any\\|apply\\|as\\|assert\\|basestring\\|bin\\|bool\\|break\\|buffer\\|bytearray\\|callable\\|chr\\|class\\|classmethod\\|cmp\\|coerce\\|compile\\|complex\\|continue\\|copyright\\|credits\\|def\\|del\\|delattr\\|dict\\|dir\\|divmod\\|elif\\|else\\|enumerate\\|eval\\|except\\|exec\\|execfile\\|exit\\|file\\|filter\\|float\\|for\\|format\\|from\\|getattr\\|global\\|globals\\|hasattr\\|hash\\|help\\|hex\\|id\\|if\\|import\\|in\\|input\\|int\\|intern\\|is\\|isinstance\\|issubclass\\|iter\\|lambda\\|len\\|license\\|list\\|locals\\|long\\|map\\|max\\|memoryview\\|min\\|next\\|not\\|object\\|oct\\|open\\|or\\|ord\\|pass\\|pow\\|print\\|property\\|quit\\|raise\\|range\\|raw_input\\|reduce\\|reload\\|repr\\|return\\|round\\|set\\|setattr\\|slice\\|sorted\\|staticmethod\\|str\\|sum\\|super\\|tuple\\|type\\|unichr\\|unicode\\|vars\\|while\\|with\\|xrange\\|yield\\|zip\\|\\)\\>"
"Contents like py-fond-lock-keyword")
;; ;
(defun py-insert-default-shebang ()
"Insert in buffer shebang of installed default Python. "
(interactive "*")
(let* ((erg (if py-edit-only-p
py-shell-name
(executable-find py-shell-name)))
(sheb (concat "#! " erg)))
(insert sheb)))
(defun py--top-level-form-p ()
"Return non-nil, if line starts with a top level definition.
Used by `py-electric-colon', which will not indent than. "
(let (erg)
(save-excursion
(beginning-of-line)
(setq erg (or (looking-at py-class-re)
(looking-at py-def-re))))
erg))
(defun py-indent-line-outmost (&optional arg)
"Indent the current line to the outmost reasonable indent.
With optional \\[universal-argument] an indent with length `py-indent-offset' is inserted unconditionally "
(interactive "*P")
(let* ((need (py-compute-indentation (point)))
(cui (current-indentation))
(cuc (current-column)))
(cond ((eq 4 (prefix-numeric-value arg))
(if indent-tabs-mode
(insert (make-string 1 9))
(insert (make-string py-indent-offset 32))))
(t
(if (and (eq need cui)(not (eq cuc cui)))
(back-to-indentation)
(beginning-of-line)
(delete-horizontal-space)
(indent-to need))))))
(defun py--indent-fix-region-intern (beg end)
"Used when `py-tab-indents-region-p' is non-nil. "
(let ()
(save-excursion
(save-restriction
(beginning-of-line)
(narrow-to-region beg end)
(forward-line 1)
(narrow-to-region (line-beginning-position) end)
(beginning-of-line)
(delete-region (point) (progn (skip-chars-forward " \t\r\n\f") (point)))
(indent-to (py-compute-indentation))
(while
(< (line-end-position) end)
(forward-line 1)
(beginning-of-line)
(delete-region (point) (progn (skip-chars-forward " \t\r\n\f") (point)))
(indent-to (py-compute-indentation)))))))
(defun py--indent-line-intern (need cui indent col &optional beg end region)
(let (erg)
(if py-tab-indent
(progn
(and py-tab-indents-region-p region
(py--indent-fix-region-intern beg end))
(cond
((bolp)
(if (and py-tab-shifts-region-p region)
(progn
(while (< (current-indentation) need)
(py-shift-region-right 1)))
(beginning-of-line)
(delete-horizontal-space)
(indent-to need)))
((< need cui)
(if (and py-tab-shifts-region-p region)
(progn
(when (eq (point) (region-end))
(exchange-point-and-mark))
(while (< 0 (current-indentation))
(py-shift-region-left 1)))
(beginning-of-line)
(delete-horizontal-space)
(indent-to need)))
((eq need cui)
(if (or (eq this-command last-command)
(eq this-command 'py-indent-line))
(if (and py-tab-shifts-region-p region)
(while (and (goto-char beg) (< 0 (current-indentation)))
(py-shift-region-left 1 beg end))
(beginning-of-line)
(delete-horizontal-space)
(if (<= (line-beginning-position) (+ (point) (- col cui)))
(forward-char (- col cui))
(beginning-of-line)))))
((< cui need)
(if (and py-tab-shifts-region-p region)
(progn
(py-shift-region-right 1))
(progn
(beginning-of-line)
(delete-horizontal-space)
;; indent one indent only if goal < need
(setq erg (+ (* (/ cui indent) indent) indent))
(if (< need erg)
(indent-to need)
(indent-to erg))
(forward-char (- col cui)))))
(t
(if (and py-tab-shifts-region-p region)
(progn
(while (< (current-indentation) need)
(py-shift-region-right 1)))
(beginning-of-line)
(delete-horizontal-space)
(indent-to need)
(back-to-indentation)
(if (<= (line-beginning-position) (+ (point) (- col cui)))
(forward-char (- col cui))
(beginning-of-line))))))
(insert-tab))))
(defun py--indent-line-base (beg end region cui need arg this-indent-offset col)
(cond ((eq 4 (prefix-numeric-value arg))
(if (and (eq cui (current-indentation))
(<= need cui))
(if indent-tabs-mode (insert "\t")(insert (make-string py-indent-offset 32)))
(beginning-of-line)
(delete-horizontal-space)
(indent-to (+ need py-indent-offset))))
((not (eq 1 (prefix-numeric-value arg)))
(py-smart-indentation-off)
(py--indent-line-intern need cui this-indent-offset col beg end region))
(t (py--indent-line-intern need cui this-indent-offset col beg end region))))
(defun py--calculate-indent-backwards (cui indent-offset)
"Return the next reasonable indent lower than current indentation. "
(if (< 0 (% cui py-indent-offset))
;; not correctly indented at all
(/ cui indent-offset)
(- cui indent-offset)))
(defun py-indent-line (&optional arg outmost-only)
"Indent the current line according to Python rules.
When called interactivly with \\[universal-argument], ignore dedenting rules for block closing statements
\(e.g. return, raise, break, continue, pass)
An optional \\[universal-argument] followed by a numeric argument neither 1 nor 4 will switch off `py-smart-indentation' for this execution. This permits to correct allowed but unwanted indents.
Similar to `toggle-py-smart-indentation' resp. `py-smart-indentation-off' followed by TAB.
This function is normally used by `indent-line-function' resp.
\\[indent-for-tab-command].
When bound to TAB, C-q TAB inserts a TAB.
OUTMOST-ONLY stops circling possible indent.
When `py-tab-shifts-region-p' is `t', not just the current line,
but the region is shiftet that way.
If `py-tab-indents-region-p' is `t' and first TAB doesn't shift
--as indent is at outmost reasonable--, indent-region is called.
C-q TAB inserts a literal TAB-character."
(interactive "P")
(unless (eq this-command last-command)
(setq py-already-guessed-indent-offset nil))
(let ((orig (copy-marker (point)))
;; TAB-leaves-point-in-the-wrong-lp-1178453-test
(region (use-region-p))
cui
outmost
col
beg
end
need
this-indent-offset)
(and region
(setq beg (region-beginning))
(setq end (region-end))
(goto-char beg))
(setq cui (current-indentation))
(setq col (current-column))
(setq this-indent-offset
(cond ((and py-smart-indentation (not (eq this-command last-command)))
(py-guess-indent-offset))
((and py-smart-indentation (eq this-command last-command) py-already-guessed-indent-offset)
py-already-guessed-indent-offset)
(t (default-value 'py-indent-offset))))
(setq outmost (py-compute-indentation nil nil nil nil nil nil this-indent-offset))
;; now choose the indent
(setq need
(cond ((eq this-command last-command)
(if (eq cui outmost)
(when (not outmost-only)
(py--calculate-indent-backwards cui this-indent-offset)))
(if (bolp)
(py-compute-indentation orig)
(py--calculate-indent-backwards cui this-indent-offset)))
(t
outmost
;; (py-compute-indentation orig)
)))
(when (and (called-interactively-p 'any) py-verbose-p) (message "py-indent-line, need: %s" need))
;; if at outmost
;; and not (eq this-command last-command), need remains nil
(when need
(py--indent-line-base beg end region cui need arg this-indent-offset col)
(and region (or py-tab-shifts-region-p
py-tab-indents-region-p)
(not (eq (point) orig))
(exchange-point-and-mark))
(when (and (called-interactively-p 'any) py-verbose-p)(message "%s" (current-indentation)))
(current-indentation))))
(defun py--delete-trailing-whitespace (orig)
"Delete trailing whitespace if either `py-newline-delete-trailing-whitespace-p' or `py-trailing-whitespace-smart-delete-p' are `t' "
(when (or py-newline-delete-trailing-whitespace-p py-trailing-whitespace-smart-delete-p)
(let ((pos (copy-marker (point))))
(save-excursion
(goto-char orig)
(if (empty-line-p)
(if (py---emacs-version-greater-23)
(delete-trailing-whitespace (line-beginning-position) pos)
(save-restriction
(narrow-to-region (line-beginning-position) pos)
(delete-trailing-whitespace)))
(skip-chars-backward " \t")
(if (py---emacs-version-greater-23)
(delete-trailing-whitespace (line-beginning-position) pos)
(save-restriction
(narrow-to-region (point) pos)
(delete-trailing-whitespace))))))))
(defun py-newline-and-indent ()
"Add a newline and indent to outmost reasonable indent.
When indent is set back manually, this is honoured in following lines. "
(interactive "*")
(let* ((orig (point))
;; lp:1280982, deliberatly dedented by user
(this-dedent
(when (and (or (eq 10 (char-after))(eobp))(looking-back "^[ \t]*" (line-beginning-position)))
(current-column)))
erg)
(newline)
(py--delete-trailing-whitespace orig)
(setq erg
(cond (this-dedent
(indent-to-column this-dedent))
((and py-empty-line-closes-p (or (eq this-command last-command)(py--after-empty-line)))
(indent-to-column (save-excursion (py-backward-statement)(- (current-indentation) py-indent-offset))))
(t
(fixup-whitespace)
(indent-to-column (py-compute-indentation)))))
(when (and (called-interactively-p 'any) py-verbose-p) (message "%s" erg))
erg))
(defalias 'py-newline-and-close-block 'py-newline-and-dedent)
(defun py-newline-and-dedent ()
"Add a newline and indent to one level below current.
Returns column. "
(interactive "*")
(let ((cui (current-indentation))
erg)
(newline)
(when (< 0 cui)
(setq erg (- (py-compute-indentation) py-indent-offset))
(indent-to-column erg))
(when (and (called-interactively-p 'any) py-verbose-p) (message "%s" erg))
erg))
(defun py-toggle-indent-tabs-mode ()
"Toggle `indent-tabs-mode'.
Returns value of `indent-tabs-mode' switched to. "
(interactive)
(when
(setq indent-tabs-mode (not indent-tabs-mode))
(setq tab-width py-indent-offset))
(when (and py-verbose-p (called-interactively-p 'any)) (message "indent-tabs-mode %s py-indent-offset %s" indent-tabs-mode py-indent-offset))
indent-tabs-mode)
(defun py-indent-tabs-mode (arg &optional iact)
"With positive ARG switch `indent-tabs-mode' on.
With negative ARG switch `indent-tabs-mode' off.
Returns value of `indent-tabs-mode' switched to. "
(interactive "p")
(if (< 0 arg)
(progn
(setq indent-tabs-mode t)
(setq tab-width py-indent-offset))
(setq indent-tabs-mode nil))
(when (and py-verbose-p (or iact (called-interactively-p 'any))) (message "indent-tabs-mode %s py-indent-offset %s" indent-tabs-mode py-indent-offset))
indent-tabs-mode)
(defun py-indent-tabs-mode-on (arg)
"Switch `indent-tabs-mode' on. "
(interactive "p")
(py-indent-tabs-mode (abs arg)(called-interactively-p 'any)))
(defun py-indent-tabs-mode-off (arg)
"Switch `indent-tabs-mode' off. "
(interactive "p")
(py-indent-tabs-mode (- (abs arg))(called-interactively-p 'any)))
;; Guess indent offset
(defun py-guessed-sanity-check (guessed)
(and (>= guessed 2)(<= guessed 8)(eq 0 (% guessed 2))))
(defun py--guess-indent-final (indents)
"Calculate and do sanity-check. "
(let* ((first (car indents))
(second (cadr indents))
(erg (if (and first second)
(if (< second first)
(- first second)
(- second first))
(default-value 'py-indent-offset))))
(setq erg (and (py-guessed-sanity-check erg) erg))
erg))
(defun py--guess-indent-forward ()
"Called when moving to end of a form and `py-smart-indentation' is on. "
(let* ((first (if
(py--beginning-of-statement-p)
(current-indentation)
(progn
(py-forward-statement)
(py-backward-statement)
(current-indentation))))
(second (if (or (looking-at py-extended-block-or-clause-re)(eq 0 first))
(progn
(py-forward-statement)
(py-forward-statement)
(py-backward-statement)
(current-indentation))
;; when not starting from block, look above
(while (and (re-search-backward py-extended-block-or-clause-re nil 'movet 1)
(or (>= (current-indentation) first)
(nth 8 (parse-partial-sexp (point-min) (point))))))
(current-indentation))))
(list first second)))
(defun py--guess-indent-backward ()
"Called when moving to beginning of a form and `py-smart-indentation' is on. "
(let* ((cui (current-indentation))
(indent (if (< 0 cui) cui 999))
(pos (progn (while (and (re-search-backward py-extended-block-or-clause-re nil 'move 1)
(or (>= (current-indentation) indent)
(nth 8 (parse-partial-sexp (point-min) (point))))))
(unless (bobp) (point))))
(first (and pos (current-indentation)))
(second (and pos (py-forward-statement) (py-forward-statement) (py-backward-statement)(current-indentation))))
(list first second)))
(defun py-guess-indent-offset (&optional direction)
"Guess `py-indent-offset'.
Set local value of `py-indent-offset', return it
Might change local value of `py-indent-offset' only when called
downwards from beginning of block followed by a statement. Otherwise default-value is returned."
(interactive)
(save-excursion
(let* ((indents
(cond (direction
(if (eq 'forward direction)
(py--guess-indent-forward)
(py--guess-indent-backward)))
;; guess some usable indent is above current position
((eq 0 (current-indentation))
(py--guess-indent-forward))
(t (py--guess-indent-backward))))
(erg (py--guess-indent-final indents)))
(if erg (setq py-indent-offset erg)
(setq py-indent-offset
(default-value 'py-indent-offset)))
(when (called-interactively-p 'any) (message "%s" py-indent-offset))
py-indent-offset)))
(defun py--comment-indent-function ()
"Python version of `comment-indent-function'."
;; This is required when filladapt is turned off. Without it, when
;; filladapt is not used, comments which start in column zero
;; cascade one character to the right
(save-excursion
(beginning-of-line)
(let ((eol (line-end-position)))
(and comment-start-skip
(re-search-forward comment-start-skip eol t)
(setq eol (match-beginning 0)))
(goto-char eol)
(skip-chars-backward " \t")
(max comment-column (+ (current-column) (if (bolp) 0 1))))))
;; make general form below work also in these cases
;; (defalias 'py-backward-paragraph 'backward-paragraph)
(defun py-backward-paragraph ()
(interactive)
(let ((erg (and (backward-paragraph)(point))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
;; (defalias 'py-end-of-paragraph 'forward-paragraph)
(defun py-forward-paragraph ()
(interactive)
(let ((erg (and (forward-paragraph)(point))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
;; ;
(defun py-indent-and-forward (&optional indent)
"Indent current line according to mode, move one line forward.
If optional INDENT is given, use it"
(interactive "*")
(beginning-of-line)
(when (member (char-after) (list 32 9 10 12 13)) (delete-region (point) (progn (skip-chars-forward " \t\r\n\f")(point))))
(indent-to (or indent (py-compute-indentation)))
(if (eobp)
(newline-and-indent)
(forward-line 1))
(back-to-indentation))
(defun py--indent-line-by-line (beg end)
"Indent every line until end to max reasonable extend.
Starts from second line of region specified"
(goto-char beg)
(py-indent-and-forward)
;; (forward-line 1)
(while (< (line-end-position) end)
(if (empty-line-p)
(forward-line 1)
(py-indent-and-forward)))
(unless (empty-line-p) (py-indent-and-forward)))
(defun py-indent-region (beg end)
"Reindent a region of Python code.
In case first line accepts an indent, keep the remaining
lines relative.
Otherwise lines in region get outmost indent,
same with optional argument
In order to shift a chunk of code, where the first line is okay, start with second line.
"
(interactive "*")
(let ((end (copy-marker end)))
(goto-char beg)
(beginning-of-line)
(setq beg (point))
(skip-chars-forward " \t\r\n\f")
(py--indent-line-by-line beg end)))
(defun py--beginning-of-buffer-position ()
(point-min))
(defun py--end-of-buffer-position ()
(point-max))
;; Declarations start
(defun py--bounds-of-declarations ()
"Bounds of consecutive multitude of assigments resp. statements around point.
Indented same level, which don't open blocks.
Typically declarations resp. initialisations of variables following
a class or function definition.
See also py--bounds-of-statements "
(let* ((orig-indent (progn
(back-to-indentation)
(unless (py--beginning-of-statement-p)
(py-backward-statement))
(unless (py--beginning-of-block-p)
(current-indentation))))
(orig (point))
last beg end)
(when orig-indent
(setq beg (line-beginning-position))
;; look upward first
(while (and
(progn
(unless (py--beginning-of-statement-p)
(py-backward-statement))
(line-beginning-position))
(py-backward-statement)
(not (py--beginning-of-block-p))
(eq (current-indentation) orig-indent))
(setq beg (line-beginning-position)))
(goto-char orig)
(while (and (setq last (line-end-position))
(setq end (py-down-statement))
(not (py--beginning-of-block-p))
(eq (py-indentation-of-statement) orig-indent)))
(setq end last)
(goto-char beg)
(if (and beg end)
(progn
(when (called-interactively-p 'any) (message "%s %s" beg end))
(cons beg end))
(when (called-interactively-p 'any) (message "%s" nil))
nil))))
(defun py-backward-declarations ()
"Got to the beginning of assigments resp. statements in current level which don't open blocks.
"
(interactive)
(let* ((bounds (py--bounds-of-declarations))
(erg (car bounds)))
(when erg (goto-char erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-declarations ()
"Got to the end of assigments resp. statements in current level which don't open blocks. "
(interactive)
(let* ((bounds (py--bounds-of-declarations))
(erg (cdr bounds)))
(when erg (goto-char erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defalias 'py-copy-declarations 'py-declarations)
(defun py-declarations ()
"Copy and mark assigments resp. statements in current level which don't open blocks or start with a keyword.
See also `py-statements', which is more general, taking also simple statements starting with a keyword. "
(interactive)
(let* ((bounds (py--bounds-of-declarations))
(beg (car bounds))
(end (cdr bounds)))
(when (and beg end)
(goto-char beg)
(push-mark)
(goto-char end)
(kill-new (buffer-substring-no-properties beg end))
(exchange-point-and-mark))))
(defun py-kill-declarations ()
"Delete variables declared in current level.
Store deleted variables in kill-ring "
(interactive "*")
(let* ((bounds (py--bounds-of-declarations))
(beg (car bounds))
(end (cdr bounds)))
(when (and beg end)
(goto-char beg)
(push-mark)
(goto-char end)
(kill-new (buffer-substring-no-properties beg end))
(delete-region beg end))))
;; Declarations end
;; Statements start
(defun py--bounds-of-statements ()
"Bounds of consecutive multitude of statements around point.
Indented same level, which don't open blocks. "
(interactive)
(let* ((orig-indent (progn
(back-to-indentation)
(unless (py--beginning-of-statement-p)
(py-backward-statement))
(unless (py--beginning-of-block-p)
(current-indentation))))
(orig (point))
last beg end)
(when orig-indent
(setq beg (point))
(while (and (setq last beg)
(setq beg
(when (py-backward-statement)
(line-beginning-position)))
(not (py-in-string-p))
(not (py--beginning-of-block-p))
(eq (current-indentation) orig-indent)))
(setq beg last)
(goto-char orig)
(setq end (line-end-position))
(while (and (setq last (py--end-of-statement-position))
(setq end (py-down-statement))
(not (py--beginning-of-block-p))
;; (not (looking-at py-keywords))
;; (not (looking-at "pdb\."))
(not (py-in-string-p))
(eq (py-indentation-of-statement) orig-indent)))
(setq end last)
(goto-char orig)
(if (and beg end)
(progn
(when (called-interactively-p 'any) (message "%s %s" beg end))
(cons beg end))
(when (called-interactively-p 'any) (message "%s" nil))
nil))))
(defun py-backward-statements ()
"Got to the beginning of statements in current level which don't open blocks. "
(interactive)
(let* ((bounds (py--bounds-of-statements))
(erg (car bounds)))
(when erg (goto-char erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-statements ()
"Got to the end of statements in current level which don't open blocks. "
(interactive)
(let* ((bounds (py--bounds-of-statements))
(erg (cdr bounds)))
(when erg (goto-char erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defalias 'py-copy-statements 'py-statements)
(defun py-statements ()
"Copy and mark simple statements in current level which don't open blocks.
More general than py-declarations, which would stop at keywords like a print-statement. "
(interactive)
(let* ((bounds (py--bounds-of-statements))
(beg (car bounds))
(end (cdr bounds)))
(when (and beg end)
(goto-char beg)
(push-mark)
(goto-char end)
(kill-new (buffer-substring-no-properties beg end))
(exchange-point-and-mark))))
(defun py-kill-statements ()
"Delete statements declared in current level.
Store deleted statements in kill-ring "
(interactive "*")
(let* ((bounds (py--bounds-of-statements))
(beg (car bounds))
(end (cdr bounds)))
(when (and beg end)
(kill-new (buffer-substring-no-properties beg end))
(delete-region beg end))))
(defun py--join-words-wrapping (words separator prefix line-length)
(let ((lines ())
(current-line prefix))
(while words
(let* ((word (car words))
(maybe-line (concat current-line word separator)))
(if (> (length maybe-line) line-length)
(setq lines (cons (substring current-line 0 -1) lines)
current-line (concat prefix word separator " "))
(setq current-line (concat maybe-line " "))))
(setq words (cdr words)))
(setq lines (cons (substring
current-line 0 (- 0 (length separator) 1)) lines))
(mapconcat 'identity (nreverse lines) "\n")))
(defun py-insert-super ()
"Insert a function \"super()\" from current environment.
As example given in Python v3.1 documentation » The Python Standard Library »
class C(B):
def method(self, arg):
super().method(arg) # This does the same thing as:
# super(C, self).method(arg)
Returns the string inserted. "
(interactive "*")
(let* ((orig (point))
(funcname (progn
(py-backward-def)
(when (looking-at (concat py-def-re " *\\([^(]+\\) *(\\(?:[^),]*\\),? *\\([^)]*\\))"))
(match-string-no-properties 2))))
(args (match-string-no-properties 3))
(ver (py-which-python))
classname erg)
(if (< ver 3)
(progn
(py-backward-class)
(when (looking-at (concat py-class-re " *\\([^( ]+\\)"))
(setq classname (match-string-no-properties 2)))
(goto-char orig)
(setq erg (concat "super(" classname ", self)." funcname "(" args ")"))
;; super(C, self).method(arg)"
(insert erg))
(goto-char orig)
(setq erg (concat "super()." funcname "(" args ")"))
(insert erg))
erg))
;; Comments
(defun py-delete-comments-in-def-or-class ()
"Delete all commented lines in def-or-class at point"
(interactive "*")
(save-excursion
(let ((beg (py--beginning-of-def-or-class-position))
(end (py--end-of-def-or-class-position)))
(and beg end (py--delete-comments-intern beg end)))))
(defun py-delete-comments-in-class ()
"Delete all commented lines in class at point"
(interactive "*")
(save-excursion
(let ((beg (py--beginning-of-class-position))
(end (py--end-of-class-position)))
(and beg end (py--delete-comments-intern beg end)))))
(defun py-delete-comments-in-block ()
"Delete all commented lines in block at point"
(interactive "*")
(save-excursion
(let ((beg (py--beginning-of-block-position))
(end (py--end-of-block-position)))
(and beg end (py--delete-comments-intern beg end)))))
(defun py-delete-comments-in-region (beg end)
"Delete all commented lines in region. "
(interactive "r*")
(save-excursion
(py--delete-comments-intern beg end)))
(defun py--delete-comments-intern (beg end)
(save-restriction
(narrow-to-region beg end)
(goto-char beg)
(while (and (< (line-end-position) end) (not (eobp)))
(beginning-of-line)
(if (looking-at (concat "[ \t]*" comment-start))
(delete-region (point) (1+ (line-end-position)))
(forward-line 1)))))
;; Edit docstring
(defun py--edit-docstring-set-vars ()
(save-excursion
(setq py--docbeg (when (use-region-p) (region-beginning)))
(setq py--docend (when (use-region-p) (region-end)))
(let ((pps (parse-partial-sexp (point-min) (point))))
(when (nth 3 pps)
(setq py--docbeg (or py--docbeg (progn (goto-char (nth 8 pps))
(skip-chars-forward (char-to-string (char-after)))(push-mark)(point))))
(setq py--docend (or py--docend
(progn (goto-char (nth 8 pps))
(forward-sexp)
(skip-chars-backward (char-to-string (char-before)))
(point)))))
(setq py--docbeg (copy-marker py--docbeg))
(setq py--docend (copy-marker py--docend)))))
(defun py--write-back-docstring ()
(interactive)
(unless (eq (current-buffer) (get-buffer py-edit-docstring-buffer))
(set-buffer py-edit-docstring-buffer))
(goto-char (point-min))
(while (re-search-forward "[\"']" nil t 1)
(or (py-escaped)
(replace-match (concat "\\\\" (match-string-no-properties 0)))))
(jump-to-register py--edit-docstring-register)
;; (py-restore-window-configuration)
(delete-region py--docbeg py--docend)
(insert-buffer-substring py-edit-docstring-buffer))
(defun py-edit-docstring ()
"Edit docstring or active region in python-mode. "
(interactive "*")
(save-excursion
(save-restriction
(window-configuration-to-register py--edit-docstring-register)
(setq py--oldbuf (current-buffer))
(let ((orig (point))
relpos docstring)
(py--edit-docstring-set-vars)
;; store relative position in docstring
(setq relpos (1+ (- orig py--docbeg)))
(setq docstring (buffer-substring py--docbeg py--docend))
(setq py-edit-docstring-orig-pos orig)
(set-buffer (get-buffer-create py-edit-docstring-buffer))
(erase-buffer)
(switch-to-buffer (current-buffer))
(insert docstring)
(python-mode)
(local-set-key [(control c)(control c)] 'py--write-back-docstring)
(goto-char relpos)
(message "%s" "Type C-c C-c writes contents back")))))
;; python-components-backward-forms
(defun py-backward-region ()
"Go to the beginning of current region"
(interactive)
(let ((beg (region-beginning)))
(when beg (goto-char beg))))
(defun py-backward-block (&optional indent)
"Go to beginning of `block'.
If already at beginning, go one `block' backward.
Returns beginning of `block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-block-re 'py-block-re (called-interactively-p 'any)))
(defun py-backward-block-or-clause (&optional indent)
"Go to beginning of `block-or-clause'.
If already at beginning, go one `block-or-clause' backward.
Returns beginning of `block-or-clause' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-extended-block-or-clause-re 'py-extended-block-or-clause-re (called-interactively-p 'any)))
;;;###autoload
(defun py-backward-class (&optional indent decorator bol)
"Go to beginning of `class'.
If already at beginning, go one `class' backward.
Returns beginning of `class' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-class-re 'py-class-re (called-interactively-p 'any) decorator bol))
(defun py-backward-clause (&optional indent)
"Go to beginning of `clause'.
If already at beginning, go one `clause' backward.
Returns beginning of `clause' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-extended-block-or-clause-re 'py-extended-block-or-clause-re (called-interactively-p 'any)))
;;;###autoload
(defun py-backward-def (&optional indent decorator bol)
"Go to beginning of `def'.
If already at beginning, go one `def' backward.
Returns beginning of `def' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-def-re 'py-def-re (called-interactively-p 'any) decorator bol))
;;;###autoload
(defun py-backward-def-or-class (&optional indent decorator bol)
"Go to beginning of `def-or-class'.
If already at beginning, go one `def-or-class' backward.
Returns beginning of `def-or-class' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-def-or-class-re 'py-def-or-class-re (called-interactively-p 'any) decorator bol))
(defun py-backward-elif-block (&optional indent)
"Go to beginning of `elif-block'.
If already at beginning, go one `elif-block' backward.
Returns beginning of `elif-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-elif-block-re 'py-elif-block-re (called-interactively-p 'any)))
(defun py-backward-else-block (&optional indent)
"Go to beginning of `else-block'.
If already at beginning, go one `else-block' backward.
Returns beginning of `else-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-else-block-re 'py-else-block-re (called-interactively-p 'any)))
(defun py-backward-except-block (&optional indent)
"Go to beginning of `except-block'.
If already at beginning, go one `except-block' backward.
Returns beginning of `except-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-except-block-re 'py-except-block-re (called-interactively-p 'any)))
(defun py-backward-for-block (&optional indent)
"Go to beginning of `for-block'.
If already at beginning, go one `for-block' backward.
Returns beginning of `for-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-for-block-re 'py-for-block-re (called-interactively-p 'any)))
(defun py-backward-if-block (&optional indent)
"Go to beginning of `if-block'.
If already at beginning, go one `if-block' backward.
Returns beginning of `if-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-if-block-re 'py-if-block-re (called-interactively-p 'any)))
(defun py-backward-minor-block (&optional indent)
"Go to beginning of `minor-block'.
If already at beginning, go one `minor-block' backward.
Returns beginning of `minor-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-minor-block-re 'py-minor-block-re (called-interactively-p 'any)))
(defun py-backward-try-block (&optional indent)
"Go to beginning of `try-block'.
If already at beginning, go one `try-block' backward.
Returns beginning of `try-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-try-block-re 'py-try-block-re (called-interactively-p 'any)))
(defun py-backward-block-bol (&optional indent)
"Go to beginning of `block', go to BOL.
If already at beginning, go one `block' backward.
Returns beginning of `block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-block-re 'py-clause-re (called-interactively-p 'any) nil t))
(defun py-backward-block-or-clause-bol (&optional indent)
"Go to beginning of `block-or-clause', go to BOL.
If already at beginning, go one `block-or-clause' backward.
Returns beginning of `block-or-clause' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-extended-block-or-clause-re 'py-extended-block-or-clause-re (called-interactively-p 'any) nil t))
;;;###autoload
(defun py-backward-class-bol (&optional indent decorator)
"Go to beginning of `class', go to BOL.
If already at beginning, go one `class' backward.
Returns beginning of `class' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-class-re 'py-extended-block-or-clause-re (called-interactively-p 'any) decorator t))
(defun py-backward-clause-bol (&optional indent)
"Go to beginning of `clause', go to BOL.
If already at beginning, go one `clause' backward.
Returns beginning of `clause' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-extended-block-or-clause-re 'py-extended-block-or-clause-re (called-interactively-p 'any) nil t))
;;;###autoload
(defun py-backward-def-bol (&optional indent decorator)
"Go to beginning of `def', go to BOL.
If already at beginning, go one `def' backward.
Returns beginning of `def' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-def-re 'py-extended-block-or-clause-re (called-interactively-p 'any) decorator t))
;;;###autoload
(defun py-backward-def-or-class-bol (&optional indent decorator)
"Go to beginning of `def-or-class', go to BOL.
If already at beginning, go one `def-or-class' backward.
Returns beginning of `def-or-class' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-def-or-class-re 'py-extended-block-or-clause-re (called-interactively-p 'any) decorator t))
(defun py-backward-elif-block-bol (&optional indent)
"Go to beginning of `elif-block', go to BOL.
If already at beginning, go one `elif-block' backward.
Returns beginning of `elif-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-elif-block-re 'py-clause-re (called-interactively-p 'any) nil t))
(defun py-backward-else-block-bol (&optional indent)
"Go to beginning of `else-block', go to BOL.
If already at beginning, go one `else-block' backward.
Returns beginning of `else-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-else-block-re 'py-clause-re (called-interactively-p 'any) nil t))
(defun py-backward-except-block-bol (&optional indent)
"Go to beginning of `except-block', go to BOL.
If already at beginning, go one `except-block' backward.
Returns beginning of `except-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-except-block-re 'py-clause-re (called-interactively-p 'any) nil t))
(defun py-backward-for-block-bol (&optional indent)
"Go to beginning of `for-block', go to BOL.
If already at beginning, go one `for-block' backward.
Returns beginning of `for-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-for-block-re 'py-clause-re (called-interactively-p 'any) nil t))
(defun py-backward-if-block-bol (&optional indent)
"Go to beginning of `if-block', go to BOL.
If already at beginning, go one `if-block' backward.
Returns beginning of `if-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-if-block-re 'py-clause-re (called-interactively-p 'any) nil t))
(defun py-backward-minor-block-bol (&optional indent)
"Go to beginning of `minor-block', go to BOL.
If already at beginning, go one `minor-block' backward.
Returns beginning of `minor-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-minor-block-re 'py-clause-re (called-interactively-p 'any) nil t))
(defun py-backward-try-block-bol (&optional indent)
"Go to beginning of `try-block', go to BOL.
If already at beginning, go one `try-block' backward.
Returns beginning of `try-block' if successful, nil otherwise"
(interactive)
(py--backward-prepare indent 'py-try-block-re 'py-clause-re (called-interactively-p 'any) nil t))
;; python-components-forward-forms
(defun py-forward-region ()
"Go to the end of current region"
(interactive)
(let ((end (region-end)))
(when end (goto-char end))))
(defun py-forward-block (&optional decorator bol)
"Go to end of block.
Returns end of block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-block-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-block-bol ()
"Goto beginning of line following end of block.
Returns position reached, if successful, nil otherwise.
See also `py-down-block': down from current definition to next beginning of block below. "
(interactive)
(let ((erg (py-forward-block)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-block-or-clause (&optional decorator bol)
"Go to end of block-or-clause.
Returns end of block-or-clause if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-block-or-clause-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-block-or-clause-bol ()
"Goto beginning of line following end of block-or-clause.
Returns position reached, if successful, nil otherwise.
See also `py-down-block-or-clause': down from current definition to next beginning of block-or-clause below. "
(interactive)
(let ((erg (py-forward-block-or-clause)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
;;;###autoload
(defun py-forward-class (&optional decorator bol)
"Go to end of class.
Returns end of class if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-class-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-class-bol ()
"Goto beginning of line following end of class.
Returns position reached, if successful, nil otherwise.
See also `py-down-class': down from current definition to next beginning of class below. "
(interactive)
(let ((erg (py-forward-class)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-clause (&optional decorator bol)
"Go to end of clause.
Returns end of clause if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-clause-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-clause-bol ()
"Goto beginning of line following end of clause.
Returns position reached, if successful, nil otherwise.
See also `py-down-clause': down from current definition to next beginning of clause below. "
(interactive)
(let ((erg (py-forward-clause)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
;;;###autoload
(defun py-forward-def-or-class (&optional decorator bol)
"Go to end of def-or-class.
Returns end of def-or-class if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-def-or-class-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-def-or-class-bol ()
"Goto beginning of line following end of def-or-class.
Returns position reached, if successful, nil otherwise.
See also `py-down-def-or-class': down from current definition to next beginning of def-or-class below. "
(interactive)
(let ((erg (py-forward-def-or-class)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
;;;###autoload
(defun py-forward-def (&optional decorator bol)
"Go to end of def.
Returns end of def if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-def-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-def-bol ()
"Goto beginning of line following end of def.
Returns position reached, if successful, nil otherwise.
See also `py-down-def': down from current definition to next beginning of def below. "
(interactive)
(let ((erg (py-forward-def)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-if-block (&optional decorator bol)
"Go to end of if-block.
Returns end of if-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-if-block-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-if-block-bol ()
"Goto beginning of line following end of if-block.
Returns position reached, if successful, nil otherwise.
See also `py-down-if-block': down from current definition to next beginning of if-block below. "
(interactive)
(let ((erg (py-forward-if-block)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-elif-block (&optional decorator bol)
"Go to end of elif-block.
Returns end of elif-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-elif-block-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-elif-block-bol ()
"Goto beginning of line following end of elif-block.
Returns position reached, if successful, nil otherwise.
See also `py-down-elif-block': down from current definition to next beginning of elif-block below. "
(interactive)
(let ((erg (py-forward-elif-block)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-else-block (&optional decorator bol)
"Go to end of else-block.
Returns end of else-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-else-block-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-else-block-bol ()
"Goto beginning of line following end of else-block.
Returns position reached, if successful, nil otherwise.
See also `py-down-else-block': down from current definition to next beginning of else-block below. "
(interactive)
(let ((erg (py-forward-else-block)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-for-block (&optional decorator bol)
"Go to end of for-block.
Returns end of for-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-for-block-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-for-block-bol ()
"Goto beginning of line following end of for-block.
Returns position reached, if successful, nil otherwise.
See also `py-down-for-block': down from current definition to next beginning of for-block below. "
(interactive)
(let ((erg (py-forward-for-block)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-except-block (&optional decorator bol)
"Go to end of except-block.
Returns end of except-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-except-block-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-except-block-bol ()
"Goto beginning of line following end of except-block.
Returns position reached, if successful, nil otherwise.
See also `py-down-except-block': down from current definition to next beginning of except-block below. "
(interactive)
(let ((erg (py-forward-except-block)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-try-block (&optional decorator bol)
"Go to end of try-block.
Returns end of try-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-try-block-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-try-block-bol ()
"Goto beginning of line following end of try-block.
Returns position reached, if successful, nil otherwise.
See also `py-down-try-block': down from current definition to next beginning of try-block below. "
(interactive)
(let ((erg (py-forward-try-block)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-minor-block (&optional decorator bol)
"Go to end of minor-block.
Returns end of minor-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match."
(interactive)
(let* ((orig (point))
(erg (py--end-base 'py-minor-block-re orig decorator bol)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-minor-block-bol ()
"Goto beginning of line following end of minor-block.
Returns position reached, if successful, nil otherwise.
See also `py-down-minor-block': down from current definition to next beginning of minor-block below. "
(interactive)
(let ((erg (py-forward-minor-block)))
(setq erg (py--beginning-of-line-form erg))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
;; python-components-forward-forms.el ends here
;; python-components-move
;; Indentation
;; Travel current level of indentation
(defun py--travel-this-indent-backward (&optional indent)
(let (erg)
(while (and (py-backward-statement)
(or indent (setq indent (current-indentation)))
(eq indent (current-indentation))(setq erg (point)) (not (bobp))))
erg))
(defun py-backward-indent ()
"Go to the beginning of a section of equal indent.
If already at the beginning or before a indent, go to next indent in buffer upwards
Returns final position when called from inside section, nil otherwise"
(interactive)
(unless (bobp)
(let (erg)
(setq erg (py--travel-this-indent-backward))
(when erg (goto-char erg))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg)))
(defun py--travel-this-indent-backward-bol (indent)
(let (erg)
(while (and (py-backward-statement-bol)
(or indent (setq indent (current-indentation)))
(eq indent (current-indentation))(setq erg (point)) (not (bobp))))
(when erg (goto-char erg))))
(defun py-backward-indent-bol ()
"Go to the beginning of line of a section of equal indent.
If already at the beginning or before an indent, go to next indent in buffer upwards
Returns final position when called from inside section, nil otherwise"
(interactive)
(unless (bobp)
(let ((indent (when (eq (current-indentation) (current-column)) (current-column)))
erg)
(setq erg (py--travel-this-indent-backward-bol indent))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg)))
(defun py--travel-this-indent-forward (indent)
(let (last erg)
(while (and (py-down-statement)
(eq indent (current-indentation))
(setq last (point))))
(when last (goto-char last))
(setq erg (py-forward-statement))
erg))
(defun py-forward-indent ()
"Go to the end of a section of equal indentation.
If already at the end, go down to next indent in buffer
Returns final position when called from inside section, nil otherwise"
(interactive)
(unless (eobp)
(let (done indent)
(when (py-forward-statement)
(save-excursion
(setq done (point))
(setq indent (and (py-backward-statement)(current-indentation)))))
(setq done (py--travel-this-indent-forward indent))
(when done (goto-char done))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" done))
done)))
(defun py-forward-indent-bol ()
"Go to beginning of line following of a section of equal indentation.
If already at the end, go down to next indent in buffer
Returns final position when called from inside section, nil otherwise"
(interactive)
(unless (eobp)
(let (erg indent)
(when (py-forward-statement)
(save-excursion
(setq indent (and (py-backward-statement)(current-indentation))))
(setq erg (py--travel-this-indent-forward indent))
(unless (eobp) (forward-line 1) (beginning-of-line) (setq erg (point)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg)))
erg)))
(defun py-backward-expression (&optional orig done repeat)
"Go to the beginning of a python expression.
If already at the beginning or before a expression, go to next expression in buffer upwards"
(interactive)
(unless (bobp)
(unless done (skip-chars-backward " \t\r\n\f"))
(let ((repeat (or (and repeat (1+ repeat)) 0))
(pps (parse-partial-sexp (point-min) (point)))
(orig (or orig (point)))
erg)
(if (< py-max-specpdl-size repeat)
(error "`py-backward-expression' reached loops max.")
(cond
;; comments
((nth 8 pps)
(goto-char (nth 8 pps))
(py-backward-expression orig done repeat))
;; lists
((nth 1 pps)
(goto-char (nth 1 pps))
(skip-chars-backward py-expression-skip-chars))
;; in string
((nth 3 pps)
(goto-char (nth 8 pps)))
;; after operator
((and (not done) (looking-back py-operator-re (line-beginning-position)))
(skip-chars-backward "^ \t\r\n\f")
(skip-chars-backward " \t\r\n\f")
(py-backward-expression orig done repeat))
((and (not done)
(< 0 (abs (skip-chars-backward py-expression-skip-chars))))
(setq done t)
(py-backward-expression orig done repeat))))
(unless (or (eq (point) orig)(and (bobp)(eolp)))
(setq erg (point)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg)))
(defun py-forward-expression (&optional orig done repeat)
"Go to the end of a compound python expression.
Operators are ignored. "
(interactive)
(unless done (skip-chars-forward " \t\r\n\f"))
(unless (eobp)
(let ((repeat (or (and repeat (1+ repeat)) 0))
(pps (parse-partial-sexp (point-min) (point)))
(orig (or orig (point)))
erg)
(if (< py-max-specpdl-size repeat)
(error "`py-forward-expression' reached loops max.")
(cond
;; in comment
((nth 4 pps)
(or (< (point) (progn (forward-comment 1)(point)))(forward-line 1))
(py-forward-expression orig done repeat))
;; empty before comment
((and (looking-at "[ \t]*#")(looking-back "^[ \t]*" (line-beginning-position)))
(while (and (looking-at "[ \t]*#") (not (eobp)))
(forward-line 1))
(py-forward-expression orig done repeat))
;; inside string
((nth 3 pps)
(goto-char (nth 8 pps))
(goto-char (scan-sexps (point) 1))
(setq done t)
(py-forward-expression orig done repeat))
((looking-at "\"\"\"\\|'''\\|\"\\|'")
(goto-char (scan-sexps (point) 1))
(setq done t)
(py-forward-expression orig done repeat))
((nth 1 pps)
(goto-char (nth 1 pps))
(goto-char (scan-sexps (point) 1))
(setq done t)
(py-forward-expression orig done repeat))
;; looking at opening delimiter
((eq 4 (car-safe (syntax-after (point))))
(goto-char (scan-sexps (point) 1))
(setq done t)
(py-forward-expression orig done repeat))
((and (eq orig (point)) (looking-at py-operator-re))
(goto-char (match-end 0))
(py-forward-expression orig done repeat))
((and (not done)
(< 0 (skip-chars-forward py-expression-skip-chars)))
(setq done t)
(py-forward-expression orig done repeat))
;; at colon following arglist
((looking-at ":[ \t]*$")
(forward-char 1)))
(unless (or (eq (point) orig)(and (eobp)(bolp)))
(setq erg (point)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))))
(defun py-backward-partial-expression ()
(interactive)
(let ((orig (point))
erg)
(and (< 0 (abs (skip-chars-backward " \t\r\n\f")))(not (bobp))(forward-char -1))
(when (py--in-comment-p)
(py-backward-comment)
(skip-chars-backward " \t\r\n\f"))
;; part of py-partial-expression-forward-chars
(when (member (char-after) (list ?\ ?\" ?' ?\) ?} ?\] ?: ?#))
(forward-char -1))
(skip-chars-backward py-partial-expression-forward-chars)
(when (< 0 (abs (skip-chars-backward py-partial-expression-backward-chars)))
(while (and (not (bobp)) (py--in-comment-p)(< 0 (abs (skip-chars-backward py-partial-expression-backward-chars))))))
(when (< (point) orig)
(unless
(and (bobp) (member (char-after) (list ?\ ?\t ?\r ?\n ?\f)))
(setq erg (point))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-partial-expression ()
(interactive)
(let (erg)
(skip-chars-forward py-partial-expression-backward-chars)
;; group arg
(while
(looking-at "[\[{(]")
(goto-char (scan-sexps (point) 1)))
(setq erg (point))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
;; Partial- or Minor Expression
;; Line
(defun py-backward-line ()
"Go to beginning-of-line, return position.
If already at beginning-of-line and not at BOB, go to beginning of previous line. "
(interactive)
(unless (bobp)
(let ((erg
(if (bolp)
(progn
(forward-line -1)
(progn (beginning-of-line)(point)))
(progn (beginning-of-line)(point)))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg)))
(defun py-forward-line ()
"Go to end-of-line, return position.
If already at end-of-line and not at EOB, go to end of next line. "
(interactive)
(unless (eobp)
(let ((orig (point))
erg)
(when (eolp) (forward-line 1))
(end-of-line)
(when (< orig (point))(setq erg (point)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg)))
;; Statement
(defun py-backward-statement (&optional orig done limit ignore-in-string-p repeat)
"Go to the initial line of a simple statement.
For beginning of compound statement use py-backward-block.
For beginning of clause py-backward-clause.
`ignore-in-string-p' allows moves inside a docstring, used when
computing indents"
(interactive)
(save-restriction
(unless (bobp)
(let* ((repeat (or (and repeat (1+ repeat)) 999))
(orig (or orig (point)))
(pps (parse-partial-sexp (or limit (point-min))(point)))
(done done)
erg)
;; lp:1382788
(unless done
(and (< 0 (abs (skip-chars-backward " \t\r\n\f")))
(setq pps (parse-partial-sexp (or limit (point-min))(point)))))
(cond
((< py-max-specpdl-size repeat)
(error "py-forward-statement reached loops max. If no error, customize `py-max-specpdl-size'"))
((and (bolp)(eolp))
(skip-chars-backward " \t\r\n\f")
(py-backward-statement orig done limit ignore-in-string-p repeat))
;; inside string
((and (nth 3 pps)(not ignore-in-string-p))
(setq done t)
(goto-char (nth 8 pps))
(py-backward-statement orig done limit ignore-in-string-p repeat))
((nth 4 pps)
(goto-char (nth 8 pps))
(skip-chars-backward " \t\r\n\f")
(py-backward-statement orig done limit ignore-in-string-p repeat))
((nth 1 pps)
(goto-char (1- (nth 1 pps)))
(when (py--skip-to-semicolon-backward (save-excursion (back-to-indentation)(point)))
(setq done t))
(py-backward-statement orig done limit ignore-in-string-p repeat))
((py-preceding-line-backslashed-p)
(forward-line -1)
(back-to-indentation)
(setq done t)
(py-backward-statement orig done limit ignore-in-string-p repeat))
;; at raw-string
;; (and (looking-at "\"\"\"\\|'''") (member (char-before) (list ?u ?U ?r ?R)))
((py--at-raw-string)
(forward-char -1)
(py-backward-statement orig done limit ignore-in-string-p repeat))
;; BOL or at space before comment
((and (looking-at "[ \t]*#")(looking-back "^[ \t]*" (line-beginning-position)))
(forward-comment -1)
(while (and (not (bobp)) (looking-at "[ \t]*#")(looking-back "^[ \t]*" (line-beginning-position)))
(forward-comment -1))
(unless (bobp)
(py-backward-statement orig done limit ignore-in-string-p repeat)))
;; at inline comment
((looking-at "[ \t]*#")
(when (py--skip-to-semicolon-backward (save-excursion (back-to-indentation)(point)))
(setq done t))
(py-backward-statement orig done limit ignore-in-string-p repeat))
;; at beginning of string
((looking-at py-string-delim-re)
(when (< 0 (abs (skip-chars-backward " \t\r\n\f")))
(setq done t))
(back-to-indentation)
(py-backward-statement orig done limit ignore-in-string-p repeat))
;; after end of statement
((and (not done) (eq (char-before) ?\;))
(skip-chars-backward ";")
(py-backward-statement orig done limit ignore-in-string-p repeat))
;; travel until indentation or semicolon
((and (not done) (py--skip-to-semicolon-backward (save-excursion (back-to-indentation)(point))))
(setq done t)
(py-backward-statement orig done limit ignore-in-string-p repeat))
;; at current indent
((and (not done) (not (eq 0 (skip-chars-backward " \t\r\n\f"))))
(py-backward-statement orig done limit ignore-in-string-p repeat)))
;; return nil when before comment
(unless (and (looking-at "[ \t]*#") (looking-back "^[ \t]*" (line-beginning-position)))
(when (< (point) orig)(setq erg (point))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))))
(defun py-backward-statement-bol ()
"Goto beginning of line where statement starts.
Returns position reached, if successful, nil otherwise.
See also `py-up-statement': up from current definition to next beginning of statement above. "
(interactive)
(let* ((orig (point))
erg)
(unless (bobp)
(cond ((bolp)
(and (py-backward-statement orig)
(progn (beginning-of-line)
(setq erg (point)))))
(t (setq erg
(and
(py-backward-statement)
(progn (beginning-of-line) (point)))))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-forward-statement (&optional orig done repeat)
"Go to the last char of current statement.
Optional argument REPEAT, the number of loops done already, is checked for py-max-specpdl-size error. Avoid eternal loops due to missing string delimters etc. "
(interactive)
(if (not (eq major-mode 'python-mode))
(error "py-forward-statement: buffer not in python-mode")
(unless (eobp)
(let ((repeat (or (and repeat (1+ repeat)) 0))
(orig (or orig (point)))
erg last
;; use by scan-lists
forward-sexp-function pps err)
;; (unless done (py--skip-to-comment-or-semicolon done))
(setq pps (parse-partial-sexp (point-min) (point)))
;; (origline (or origline (py-count-lines)))
(cond
;; which-function-mode, lp:1235375
((< py-max-specpdl-size repeat)
(error "py-forward-statement reached loops max. If no error, customize `py-max-specpdl-size'"))
;; list
((nth 1 pps)
(if (<= orig (point))
(progn
(setq orig (point))
;; do not go back at a possible unclosed list
(goto-char (nth 1 pps))
(if
(ignore-errors (forward-list))
(progn
(when (looking-at ":[ \t]*$")
(forward-char 1))
(setq done t)
(skip-chars-forward "^#" (line-end-position))
(skip-chars-backward " \t\r\n\f" (line-beginning-position))
(py-forward-statement orig done repeat))
(setq err (py--record-list-error pps))
(goto-char orig)))))
;; in comment
((looking-at (concat " *" comment-start))
(goto-char (match-end 0))
(py-forward-statement orig done repeat))
((nth 4 pps)
(py--end-of-comment-intern (point))
(py--skip-to-comment-or-semicolon done)
(while (and (eq (char-before (point)) ?\\ )
(py-escaped)(setq last (point)))
(forward-line 1)(end-of-line))
(and last (goto-char last)
(forward-line 1)
(back-to-indentation))
(py-forward-statement orig done repeat))
;; string
((looking-at py-string-delim-re)
(goto-char (match-end 0))
(py-forward-statement orig done repeat))
((nth 3 pps)
(when (py-end-of-string)
(end-of-line)
(skip-chars-forward " \t\r\n\f")
(setq pps (parse-partial-sexp (point-min) (point)))
(unless (and done (not (or (nth 1 pps) (nth 8 pps))) (eolp)) (py-forward-statement orig done repeat))))
((py-current-line-backslashed-p)
(end-of-line)
(skip-chars-backward " \t\r\n\f" (line-beginning-position))
(while (and (eq (char-before (point)) ?\\ )
(py-escaped))
(forward-line 1)
(end-of-line)
(skip-chars-backward " \t\r\n\f" (line-beginning-position)))
(unless (eobp)
(py-forward-statement orig done repeat)))
((eq orig (point))
(if (eolp)
(skip-chars-forward " \t\r\n\f#'\"")
(end-of-line)
(skip-chars-backward " \t\r\n\f"))
(setq done t)
(py-forward-statement orig done repeat))
((eq (current-indentation) (current-column))
(py--skip-to-comment-or-semicolon done)
(setq pps (parse-partial-sexp orig (point)))
(if (nth 1 pps)
(py-forward-statement orig done repeat)
(unless done
(py-forward-statement orig done repeat))))
((and (looking-at "[[:print:]]+$") (not done) (py--skip-to-comment-or-semicolon done))
(py-forward-statement orig done repeat)))
(unless
(or
(eq (point) orig)
(member (char-before) (list 10 32 9 ?#)))
(setq erg (point)))
(if (and py-verbose-p err)
(py--message-error err)
(and py-verbose-p (called-interactively-p 'any) (message "%s" erg)))
erg))))
(defun py-forward-statement-bol ()
"Go to the beginning-of-line following current statement."
(interactive)
(let ((erg (py-forward-statement)))
(setq erg (py--beginning-of-line-form erg))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
;; Decorator
(defun py-backward-decorator ()
"Go to the beginning of a decorator.
Returns position if succesful "
(interactive)
(back-to-indentation)
(while (and (not (looking-at "@\\w+"))
(not
;; (empty-line-p)
(eq 9 (char-after)))
(not (bobp))(forward-line -1))
(back-to-indentation))
(let ((erg (when (looking-at "@\\w+")(match-beginning 0))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-decorator ()
"Go to the end of a decorator.
Returns position if succesful "
(interactive)
(let ((orig (point)) erg)
(unless (looking-at "@\\w+")
(setq erg (py-backward-decorator)))
(when erg
(if
(re-search-forward py-def-or-class-re nil t)
(progn
(back-to-indentation)
(skip-chars-backward " \t\r\n\f")
(py-leave-comment-or-string-backward)
(skip-chars-backward " \t\r\n\f")
(setq erg (point)))
(goto-char orig)
(end-of-line)
(skip-chars-backward " \t\r\n\f")
(when (ignore-errors (goto-char (py-in-list-p)))
(forward-list))
(when (< orig (point))
(setq erg (point))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg)))
(defun py-backward-comment (&optional pos)
"Got to beginning of a commented section. "
(interactive)
(let ((erg pos)
last)
(when erg (goto-char erg))
(while (and (not (bobp)) (setq erg (py-in-comment-p)))
(when (< erg (point))
(goto-char erg)
(setq last (point)))
(skip-chars-backward " \t\r\n\f"))
(when last (goto-char last))
last))
(defun py-forward-comment (&optional pos char)
"Go to end of commented section.
Optional args position and comment-start character
Travel empty lines "
(interactive)
(let ((orig (or pos (point)))
(char (or char (string-to-char comment-start)))
py-forward-comment-last erg)
(while (and (not (eobp))
(or
(forward-comment 99999)
(when (py--in-comment-p)
(progn
(end-of-line)
(skip-chars-backward " \t\r\n\f")
(setq py-forward-comment-last (point))))
(prog1 (forward-line 1)
(end-of-line)))))
(when py-forward-comment-last (goto-char py-forward-comment-last))
;; forward-comment fails sometimes
(and (eq orig (point)) (prog1 (forward-line 1) (back-to-indentation))
(while (member (char-after) (list char 10))(forward-line 1)(back-to-indentation)))
(when (< orig (point)) (setq erg (point)))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
;; Helper functions
(defun py-go-to-beginning-of-comment ()
"Go to the beginning of current line's comment, if any.
From a programm use macro `py-backward-comment' instead "
(interactive)
(let ((erg (py-backward-comment)))
(when (and py-verbose-p (called-interactively-p 'any))
(message "%s" erg))))
(defun py--up-decorators-maybe (indent)
(let (done erg)
(while (and (not done) (not (bobp)))
(py-backward-statement)
(if
(and (current-indentation) indent
(looking-at py-decorator-re))
(setq erg (point))
(setq done t)))
erg))
(defun py--go-to-keyword (regexp &optional maxindent)
"Returns a list, whose car is indentation, cdr position. "
(let ((maxindent
(or maxindent
(if (empty-line-p)
(progn
(py-backward-statement)
(current-indentation))
(or maxindent (and (< 0 (current-indentation))(current-indentation))
;; make maxindent large enough if not set
(* 99 py-indent-offset)))))
done erg)
(while (and (not done) (not (bobp)))
(py-backward-statement)
(cond ((eq 0 (current-indentation))
(when (looking-at regexp) (setq erg (point)))
(setq done t))
((and (<= (current-indentation) maxindent)
(setq maxindent (current-indentation))
(looking-at regexp))
(setq erg (point))
(setq done t))))
(when (and py-mark-decorators (looking-at py-def-or-class-re))
(setq done (py--up-decorators-maybe (current-indentation)))
(when done (setq erg done)))
(when erg (setq erg (cons (current-indentation) erg)))
erg))
(defun py--clause-lookup-keyword (regexp arg &optional indent origline)
"Returns a list, whose car is indentation, cdr position. "
(let* ((origline (or origline (py-count-lines)))
(stop (if (< 0 arg)'(eobp)'(bobp)))
(function (if (< 0 arg) 'py-forward-statement 'py-backward-statement))
(count 1)
(maxindent (cond (indent indent)
((< (py-count-lines) origline)
(current-indentation))
(t 0)))
(complement-re
(cond ((or (string-match "finally" regexp)
(string-match "except" regexp))
py-try-re)
((string-match "elif" regexp)
py-if-re)
((string-match "else" regexp)
py-minor-block-re)))
(first t)
erg done strict)
(while (and (not (eval stop))
(< 0 count)
(or done (setq erg (funcall function))))
(setq done nil)
(when (and first (< maxindent (current-indentation)))
(setq maxindent (current-indentation))
(setq first nil))
(when (if strict
(< (current-indentation) maxindent)
(<= (current-indentation) maxindent))
(unless (looking-at py-block-or-clause-re)
(setq maxindent (current-indentation)))
;; nesting
(cond
((and (looking-at "\\_[: \n\t]")(save-match-data (string-match regexp "finally")))
(setq indent (current-indentation))
(while
(and
(not (eval stop))
(funcall function)
(setq done t)
(not (and (eq indent (current-indentation)) (looking-at "try"))))))
((and (looking-at "\\[: \n\t]")(save-match-data (string-match "else" regexp)))
(setq indent (current-indentation))
(setq count (1+ count))
(while
(and
(not (eval stop))
(funcall function)
(setq done t)
(not (and (eq indent (current-indentation)) (looking-at "try\\|if"))))))
((and (looking-at "\\_[: \n\t]")(save-match-data (string-match "else" regexp)))
(setq indent (current-indentation))
(setq count (1+ count))
(while
(and
(not (eval stop))
(funcall function)
(setq done t)
(not (and (eq indent (current-indentation)) (looking-at "try\\|if"))))))
((and (looking-at "\\_[ \n\t]")(save-match-data (string-match "elif" regexp)))
(setq indent (current-indentation))
(while
(and
(not (eval stop))
(funcall function)
(setq done t)
;; doesn't mean nesting yet
(setq count (1- count))
(not (and (eq indent (current-indentation)) (looking-at "if"))))))
((and (looking-at complement-re)(<= (current-indentation) maxindent))
(setq count (1- count)))
(t (cond ((and (string-match "except" regexp)(looking-at py-block-re))
(setq count (1- count)))
((and (string-match "else" regexp)(looking-at "except"))
(current-indentation))
(t
(setq strict t)
))))))
(when erg
(if (looking-at py-def-or-class-re)
(setq erg (cons (+ (current-indentation) py-indent-offset) erg))
(setq erg (cons (current-indentation) erg))))
erg))
(defun py-leave-comment-or-string-backward ()
"If inside a comment or string, leave it backward. "
(interactive)
(let ((pps
(if (featurep 'xemacs)
(parse-partial-sexp (point-min) (point))
(parse-partial-sexp (point-min) (point)))))
(when (nth 8 pps)
(goto-char (1- (nth 8 pps))))))
(defun py-beginning-of-list-pps (&optional iact last ppstart orig done)
"Go to the beginning of a list.
Optional ARG indicates a start-position for `parse-partial-sexp'.
Return beginning position, nil if not inside."
(interactive "p")
(let* ((orig (or orig (point)))
(ppstart (or ppstart (re-search-backward "^[a-zA-Z]" nil t 1) (point-min)))
erg)
(unless done (goto-char orig))
(setq done t)
(if
(setq erg (nth 1 (if (featurep 'xemacs)
(parse-partial-sexp ppstart (point))
(parse-partial-sexp (point-min) (point)))))
(progn
(setq last erg)
(goto-char erg)
(py-beginning-of-list-pps iact last ppstart orig done))
(when iact (message "%s" last))
last)))
(defun py-forward-into-nomenclature (&optional arg iact)
"Move forward to end of a nomenclature symbol.
With \\[universal-argument] (programmatically, optional argument ARG), do it that many times.
A `nomenclature' is a fancy way of saying AWordWithMixedCaseNotUnderscores."
(interactive "p")
(or arg (setq arg 1))
(let ((case-fold-search nil)
(orig (point))
erg)
(if (> arg 0)
(while (and (not (eobp)) (> arg 0))
;; (setq erg (re-search-forward "\\(\\W+[_[:lower:][:digit:]ß]+\\)" nil t 1))
(cond
((or (not (eq 0 (skip-chars-forward "[[:blank:][:punct:]\n\r]")))
(not (eq 0 (skip-chars-forward "_"))))
(when (or
(< 1 (skip-chars-forward "[:upper:]"))
(not (eq 0 (skip-chars-forward "[[:lower:][:digit:]ß]")))
(not (eq 0 (skip-chars-forward "[[:lower:][:digit:]]"))))
(setq arg (1- arg))))
((or
(< 1 (skip-chars-forward "[:upper:]"))
(not (eq 0 (skip-chars-forward "[[:lower:][:digit:]ß]")))
(not (eq 0 (skip-chars-forward "[[:lower:][:digit:]]"))))
(setq arg (1- arg)))))
(while (and (not (bobp)) (< arg 0))
(when (not (eq 0 (skip-chars-backward "[[:blank:][:punct:]\n\r\f_]")))
(forward-char -1))
(or
(not (eq 0 (skip-chars-backward "[:upper:]")))
(not (eq 0 (skip-chars-backward "[[:lower:][:digit:]ß]")))
(skip-chars-backward "[[:lower:][:digit:]ß]"))
(setq arg (1+ arg))))
(if (< (point) orig)
(progn
(when (looking-back "[[:upper:]]" (line-beginning-position))
;; (looking-back "[[:blank:]]"
(forward-char -1))
(if (looking-at "[[:alnum:]ß]")
(setq erg (point))
(setq erg nil)))
(if (and (< orig (point)) (not (eobp)))
(setq erg (point))
(setq erg nil)))
(when (and py-verbose-p (or iact (called-interactively-p 'any))) (message "%s" erg))
erg))
(defun py-backward-into-nomenclature (&optional arg)
"Move backward to beginning of a nomenclature symbol.
With optional ARG, move that many times. If ARG is negative, move
forward.
A `nomenclature' is a fancy way of saying AWordWithMixedCaseNotUnderscores."
(interactive "p")
(setq arg (or arg 1))
(py-forward-into-nomenclature (- arg) arg))
(defun py--travel-current-indent (indent &optional orig)
"Moves down until clause is closed, i.e. current indentation is reached.
Takes a list, INDENT and START position. "
(unless (eobp)
(let ((orig (or orig (point)))
last)
(while (and (setq last (point))(not (eobp))(py-forward-statement)
(save-excursion (or (<= indent (progn (py-backward-statement)(current-indentation)))(eq last (line-beginning-position))))
;; (py--end-of-statement-p)
))
(goto-char last)
(when (< orig last)
last))))
(defun py-beginning-of-block-current-column ()
"Reach next beginning of block upwards which starts at current column.
Return position"
(interactive)
(let* ((orig (point))
(cuco (current-column))
(str (make-string cuco ?\s))
pps erg)
(while (and (not (bobp))(re-search-backward (concat "^" str py-block-keywords) nil t)(or (nth 8 (setq pps (parse-partial-sexp (point-min) (point)))) (nth 1 pps))))
(back-to-indentation)
(and (< (point) orig)(setq erg (point)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-backward-section ()
"Go to next section start upward in buffer.
Return position if successful"
(interactive)
(let ((orig (point)))
(while (and (re-search-backward py-section-start nil t 1)
(nth 8 (parse-partial-sexp (point-min) (point)))))
(when (and (looking-at py-section-start)(< (point) orig))
(point))))
(defun py-forward-section ()
"Go to next section end downward in buffer.
Return position if successful"
(interactive)
(let ((orig (point))
last)
(while (and (re-search-forward py-section-end nil t 1)
(setq last (point))
(goto-char (match-beginning 0))
(nth 8 (parse-partial-sexp (point-min) (point)))
(goto-char (match-end 0))))
(and last (goto-char last))
(when (and (looking-back py-section-end (line-beginning-position))(< orig (point)))
(point))))
;; python-components-kill-forms
(defun py-kill-comment ()
"Delete comment at point.
Stores data in kill ring"
(interactive "*")
(let ((erg (py--mark-base "comment")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-line ()
"Delete line at point.
Stores data in kill ring"
(interactive "*")
(let ((erg (py--mark-base "line")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-paragraph ()
"Delete paragraph at point.
Stores data in kill ring"
(interactive "*")
(let ((erg (py--mark-base "paragraph")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-expression ()
"Delete expression at point.
Stores data in kill ring"
(interactive "*")
(let ((erg (py--mark-base "expression")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-partial-expression ()
"Delete partial-expression at point.
Stores data in kill ring"
(interactive "*")
(let ((erg (py--mark-base "partial-expression")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-section ()
"Delete section at point.
Stores data in kill ring"
(interactive "*")
(let ((erg (py--mark-base "section")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-top-level ()
"Delete top-level at point.
Stores data in kill ring"
(interactive "*")
(let ((erg (py--mark-base "top-level")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-block ()
"Delete block at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "block")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-block-or-clause ()
"Delete block-or-clause at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "block-or-clause")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-class ()
"Delete class at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "class")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-clause ()
"Delete clause at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "clause")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-def ()
"Delete def at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "def")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-def-or-class ()
"Delete def-or-class at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "def-or-class")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-elif-block ()
"Delete elif-block at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "elif-block")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-else-block ()
"Delete else-block at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "else-block")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-except-block ()
"Delete except-block at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "except-block")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-for-block ()
"Delete for-block at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "for-block")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-if-block ()
"Delete if-block at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "if-block")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-indent ()
"Delete indent at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "indent")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-minor-block ()
"Delete minor-block at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "minor-block")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-statement ()
"Delete statement at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "statement")))
(kill-region (car erg) (cdr erg))))
(defun py-kill-try-block ()
"Delete try-block at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(let ((erg (py--mark-base-bol "try-block")))
(kill-region (car erg) (cdr erg))))
;; python-components-close-forms
(defun py-close-block ()
"Close block at point.
Set indent level to that of beginning of function definition.
If final line isn't empty and `py-close-block-provides-newline' non-nil, insert a newline.
"
(interactive "*")
(let ((erg (py--close-intern 'py-block-re)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-close-class ()
"Close class at point.
Set indent level to that of beginning of function definition.
If final line isn't empty and `py-close-block-provides-newline' non-nil, insert a newline.
"
(interactive "*")
(let ((erg (py--close-intern 'py-class-re)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-close-def ()
"Close def at point.
Set indent level to that of beginning of function definition.
If final line isn't empty and `py-close-block-provides-newline' non-nil, insert a newline.
"
(interactive "*")
(let ((erg (py--close-intern 'py-def-re)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-close-def-or-class ()
"Close def-or-class at point.
Set indent level to that of beginning of function definition.
If final line isn't empty and `py-close-block-provides-newline' non-nil, insert a newline.
"
(interactive "*")
(let ((erg (py--close-intern 'py-def-or-class-re)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-close-minor-block ()
"Close minor-block at point.
Set indent level to that of beginning of function definition.
If final line isn't empty and `py-close-block-provides-newline' non-nil, insert a newline.
"
(interactive "*")
(let ((erg (py--close-intern 'py-minor-block-re)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-close-statement ()
"Close statement at point.
Set indent level to that of beginning of function definition.
If final line isn't empty and `py-close-block-provides-newline' non-nil, insert a newline.
"
(interactive "*")
(let ((erg (py--close-intern 'py-statement-re)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
;; python-components-mark-forms
(defun py-mark-comment ()
"Mark comment at point.
Returns beginning and end positions of marked area, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base "comment"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-line ()
"Mark line at point.
Returns beginning and end positions of marked area, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base "line"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-paragraph ()
"Mark paragraph at point.
Returns beginning and end positions of marked area, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base "paragraph"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-expression ()
"Mark expression at point.
Returns beginning and end positions of marked area, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base "expression"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-partial-expression ()
"Mark partial-expression at point.
Returns beginning and end positions of marked area, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base "partial-expression"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-section ()
"Mark section at point.
Returns beginning and end positions of marked area, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base "section"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-top-level ()
"Mark top-level at point.
Returns beginning and end positions of marked area, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base "top-level"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-block ()
"Mark block, take beginning of line positions.
Returns beginning and end positions of region, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base-bol "block"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-block-or-clause ()
"Mark block-or-clause, take beginning of line positions.
Returns beginning and end positions of region, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base-bol "block-or-clause"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-class (&optional arg)
"Mark class, take beginning of line positions.
With \\[universal-argument] or `py-mark-decorators' set to `t', decorators are marked too.
Returns beginning and end positions of region, a cons. "
(interactive "P")
(let ((py-mark-decorators (or arg py-mark-decorators))
erg)
(py--mark-base-bol "class" py-mark-decorators)
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-clause ()
"Mark clause, take beginning of line positions.
Returns beginning and end positions of region, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base-bol "clause"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-def (&optional arg)
"Mark def, take beginning of line positions.
With \\[universal-argument] or `py-mark-decorators' set to `t', decorators are marked too.
Returns beginning and end positions of region, a cons. "
(interactive "P")
(let ((py-mark-decorators (or arg py-mark-decorators))
erg)
(py--mark-base-bol "def" py-mark-decorators)
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-def-or-class (&optional arg)
"Mark def-or-class, take beginning of line positions.
With \\[universal-argument] or `py-mark-decorators' set to `t', decorators are marked too.
Returns beginning and end positions of region, a cons. "
(interactive "P")
(let ((py-mark-decorators (or arg py-mark-decorators))
erg)
(py--mark-base-bol "def-or-class" py-mark-decorators)
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-elif-block ()
"Mark elif-block, take beginning of line positions.
Returns beginning and end positions of region, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base-bol "elif-block"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-else-block ()
"Mark else-block, take beginning of line positions.
Returns beginning and end positions of region, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base-bol "else-block"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-except-block ()
"Mark except-block, take beginning of line positions.
Returns beginning and end positions of region, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base-bol "except-block"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-for-block ()
"Mark for-block, take beginning of line positions.
Returns beginning and end positions of region, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base-bol "for-block"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-if-block ()
"Mark if-block, take beginning of line positions.
Returns beginning and end positions of region, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base-bol "if-block"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-indent ()
"Mark indent, take beginning of line positions.
Returns beginning and end positions of region, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base-bol "indent"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-minor-block ()
"Mark minor-block, take beginning of line positions.
Returns beginning and end positions of region, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base-bol "minor-block"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-statement ()
"Mark statement, take beginning of line positions.
Returns beginning and end positions of region, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base-bol "statement"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-mark-try-block ()
"Mark try-block, take beginning of line positions.
Returns beginning and end positions of region, a cons. "
(interactive)
(let (erg)
(setq erg (py--mark-base-bol "try-block"))
(exchange-point-and-mark)
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
;; python-components-copy-forms
(defun py-copy-block ()
"Copy block at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "block")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-block-or-clause ()
"Copy block-or-clause at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "block-or-clause")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-buffer ()
"Copy buffer at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "buffer")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-class ()
"Copy class at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "class")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-clause ()
"Copy clause at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "clause")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-def ()
"Copy def at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "def")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-def-or-class ()
"Copy def-or-class at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "def-or-class")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-expression ()
"Copy expression at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "expression")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-indent ()
"Copy indent at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "indent")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-line ()
"Copy line at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "line")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-minor-block ()
"Copy minor-block at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "minor-block")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-paragraph ()
"Copy paragraph at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "paragraph")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-partial-expression ()
"Copy partial-expression at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "partial-expression")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-region ()
"Copy region at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "region")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-statement ()
"Copy statement at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "statement")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-top-level ()
"Copy top-level at point.
Store data in kill ring, so it might yanked back. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "top-level")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-block-bol ()
"Delete block bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "block")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-block-or-clause-bol ()
"Delete block-or-clause bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "block-or-clause")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-buffer-bol ()
"Delete buffer bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "buffer")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-class-bol ()
"Delete class bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "class")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-clause-bol ()
"Delete clause bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "clause")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-def-bol ()
"Delete def bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "def")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-def-or-class-bol ()
"Delete def-or-class bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "def-or-class")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-expression-bol ()
"Delete expression bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "expression")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-indent-bol ()
"Delete indent bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "indent")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-line-bol ()
"Delete line bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "line")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-minor-block-bol ()
"Delete minor-block bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "minor-block")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-paragraph-bol ()
"Delete paragraph bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "paragraph")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-partial-expression-bol ()
"Delete partial-expression bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "partial-expression")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-region-bol ()
"Delete region bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "region")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-statement-bol ()
"Delete statement bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "statement")))
(copy-region-as-kill (car erg) (cdr erg)))))
(defun py-copy-top-level-bol ()
"Delete top-level bol at point.
Stores data in kill ring. Might be yanked back using `C-y'. "
(interactive "*")
(save-excursion
(let ((erg (py--mark-base-bol "top-level")))
(copy-region-as-kill (car erg) (cdr erg)))))
;; python-components-delete-forms
(defun py-delete-block ()
"Delete BLOCK at point until beginning-of-line.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base-bol "block")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-block-or-clause ()
"Delete BLOCK-OR-CLAUSE at point until beginning-of-line.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base-bol "block-or-clause")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-class (&optional arg)
"Delete CLASS at point until beginning-of-line.
Don't store data in kill ring.
With \\[universal-argument] or `py-mark-decorators' set to `t', `decorators' are included."
(interactive "P")
(let* ((py-mark-decorators (or arg py-mark-decorators))
(erg (py--mark-base "class" py-mark-decorators)))
(delete-region (car erg) (cdr erg))))
(defun py-delete-clause ()
"Delete CLAUSE at point until beginning-of-line.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base-bol "clause")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-def (&optional arg)
"Delete DEF at point until beginning-of-line.
Don't store data in kill ring.
With \\[universal-argument] or `py-mark-decorators' set to `t', `decorators' are included."
(interactive "P")
(let* ((py-mark-decorators (or arg py-mark-decorators))
(erg (py--mark-base "def" py-mark-decorators)))
(delete-region (car erg) (cdr erg))))
(defun py-delete-def-or-class (&optional arg)
"Delete DEF-OR-CLASS at point until beginning-of-line.
Don't store data in kill ring.
With \\[universal-argument] or `py-mark-decorators' set to `t', `decorators' are included."
(interactive "P")
(let* ((py-mark-decorators (or arg py-mark-decorators))
(erg (py--mark-base "def-or-class" py-mark-decorators)))
(delete-region (car erg) (cdr erg))))
(defun py-delete-elif-block ()
"Delete ELIF-BLOCK at point until beginning-of-line.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base-bol "elif-block")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-else-block ()
"Delete ELSE-BLOCK at point until beginning-of-line.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base-bol "else-block")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-except-block ()
"Delete EXCEPT-BLOCK at point until beginning-of-line.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base-bol "except-block")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-for-block ()
"Delete FOR-BLOCK at point until beginning-of-line.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base-bol "for-block")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-if-block ()
"Delete IF-BLOCK at point until beginning-of-line.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base-bol "if-block")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-indent ()
"Delete INDENT at point until beginning-of-line.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base-bol "indent")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-minor-block ()
"Delete MINOR-BLOCK at point until beginning-of-line.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base-bol "minor-block")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-statement ()
"Delete STATEMENT at point until beginning-of-line.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base-bol "statement")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-try-block ()
"Delete TRY-BLOCK at point until beginning-of-line.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base-bol "try-block")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-comment ()
"Delete COMMENT at point.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base "comment")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-line ()
"Delete LINE at point.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base "line")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-paragraph ()
"Delete PARAGRAPH at point.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base "paragraph")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-expression ()
"Delete EXPRESSION at point.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base "expression")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-partial-expression ()
"Delete PARTIAL-EXPRESSION at point.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base "partial-expression")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-section ()
"Delete SECTION at point.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base "section")))
(delete-region (car erg) (cdr erg))))
(defun py-delete-top-level ()
"Delete TOP-LEVEL at point.
Don't store data in kill ring. "
(interactive)
(let ((erg (py--mark-base "top-level")))
(delete-region (car erg) (cdr erg))))
;; python-components-execute
(defun py-restore-window-configuration ()
"Restore py-restore-window-configuration when completion is done resp. abandoned. "
(let (val)
(and (setq val (get-register py-windows-config-register))(and (consp val) (window-configuration-p (car val))(markerp (cadr val)))(marker-buffer (cadr val))
(jump-to-register py-windows-config-register))))
(defun py-shell-execute-string-now (strg &optional shell buffer proc)
"Send to Python interpreter process PROC \"exec STRING in {}\".
and return collected output"
(let* (wait
(procbuf (or buffer (process-buffer proc) (progn (setq wait py-new-shell-delay) (py-shell nil nil shell))))
(proc (or proc (get-buffer-process procbuf)))
(cmd (format "exec '''%s''' in {}"
(mapconcat 'identity (split-string strg "\n") "\\n")))
;; TBD remove redundant outbuf
(outbuf procbuf))
;; wait is used only when a new py-shell buffer was connected
(and wait (sit-for wait))
(unwind-protect
(condition-case nil
(progn
(with-current-buffer outbuf
(delete-region (point-min) (point-max)))
(with-current-buffer procbuf
;; (sit-for 3)
(comint-redirect-send-command-to-process
cmd outbuf proc nil t)
(accept-process-output proc 5))
(with-current-buffer outbuf
(buffer-substring (point-min) (point-max))))
(quit (with-current-buffer procbuf
(interrupt-process proc comint-ptyp)
(while (not comint-redirect-completed) ; wait for output
(accept-process-output proc 1)))
(signal 'quit nil))))))
(defun py-switch-to-python (eob-p)
"Switch to the Python process buffer, maybe starting new process.
With prefix arg, position cursor at end of buffer."
(interactive "P")
(pop-to-buffer (process-buffer (py-proc)) t) ;Runs python if needed.
(when eob-p
(goto-char (point-max))))
(defalias 'py-shell-send-file 'py-send-file)
(defun py-send-file (file-name &optional process temp-file-name)
"Send FILE-NAME to Python PROCESS.
If TEMP-FILE-NAME is passed then that file is used for processing
instead, while internally the shell will continue to use
FILE-NAME."
(interactive "fFile to send: ")
(let* ((process (or process (get-buffer-process (py-shell))))
(temp-file-name (when temp-file-name
(expand-file-name temp-file-name)))
(file-name (or (expand-file-name file-name) temp-file-name)))
(when (not file-name)
(error "If FILE-NAME is nil then TEMP-FILE-NAME must be non-nil"))
(py-send-string
(format
(concat "__pyfile = open('''%s''');"
"exec(compile(__pyfile.read(), '''%s''', 'exec'));"
"__pyfile.close()")
file-name file-name)
process)))
(defun toggle-force-local-shell (&optional arg fast)
"If locally indicated Python shell should be taken and
enforced upon sessions execute commands.
Toggles boolean `py-force-local-shell-p' along with `py-force-py-shell-name-p'
Returns value of `toggle-force-local-shell' switched to.
When on, kind of an option 'follow', local shell sets `py-shell-name', enforces its use afterwards.
See also commands
`py-force-local-shell-on'
`py-force-local-shell-off'
"
(interactive)
(let ((arg (or arg (if py-force-local-shell-p -1 1))))
(if (< 0 arg)
(progn
(setq py-shell-name (or py-local-command (py-choose-shell nil fast)))
(setq py-force-local-shell-p t))
(setq py-shell-name (default-value 'py-shell-name))
(setq py-force-local-shell-p nil))
(when (called-interactively-p 'any)
(if py-force-local-shell-p
(when py-verbose-p (message "Enforce %s" py-shell-name))
(when py-verbose-p (message "py-shell-name default restored to: %s" py-shell-name))))
py-shell-name))
(defun py-force-local-shell-on (&optional fast)
"Make sure, `py-force-local-shell-p' is on.
Returns value of `py-force-local-shell-p'.
Kind of an option 'follow', local shell sets `py-shell-name', enforces its use afterwards "
(interactive)
(toggle-force-local-shell 1 fast)
(when (or py-verbose-p (called-interactively-p 'any))
(message "Enforce %s" py-shell-name)))
(defun py-force-local-shell-off (&optional fast)
"Restore `py-shell-name' default value and `behaviour'. "
(interactive)
(toggle-force-local-shell 1 fast)
(when (or py-verbose-p (called-interactively-p 'any))
(message "py-shell-name default restored to: %s" py-shell-name)))
(defun toggle-force-py-shell-name-p (&optional arg)
"If customized default `py-shell-name' should be enforced upon execution.
If `py-force-py-shell-name-p' should be on or off.
Returns value of `py-force-py-shell-name-p' switched to.
See also commands
force-py-shell-name-p-on
force-py-shell-name-p-off
Caveat: Completion might not work that way.
"
(interactive)
(let ((arg (or arg (if py-force-py-shell-name-p -1 1))))
(if (< 0 arg)
(setq py-force-py-shell-name-p t)
(setq py-force-py-shell-name-p nil))
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-force-py-shell-name-p: %s" py-force-py-shell-name-p))
py-force-py-shell-name-p))
(defun force-py-shell-name-p-on ()
"Switches `py-force-py-shell-name-p' on.
Customized default `py-shell-name' will be enforced upon execution.
Returns value of `py-force-py-shell-name-p'.
Caveat: Completion might not work that way.
"
(interactive)
(toggle-force-py-shell-name-p 1)
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-force-py-shell-name-p: %s" py-force-py-shell-name-p))
py-force-py-shell-name-p)
(defun force-py-shell-name-p-off ()
"Make sure, `py-force-py-shell-name-p' is off.
Function to use by executes will be guessed from environment.
Returns value of `py-force-py-shell-name-p'. "
(interactive)
(toggle-force-py-shell-name-p -1)
(when (or py-verbose-p (called-interactively-p 'any)) (message "py-force-py-shell-name-p: %s" py-force-py-shell-name-p))
py-force-py-shell-name-p)
;; Split-Windows-On-Execute forms
(defalias 'toggle-py-split-windows-on-execute 'py-toggle-split-windows-on-execute)
(defun py-toggle-split-windows-on-execute (&optional arg)
"If `py-split-window-on-execute' should be on or off.
Returns value of `py-split-window-on-execute' switched to. "
(interactive)
(let ((arg (or arg (if py-split-window-on-execute -1 1))))
(if (< 0 arg)
(setq py-split-window-on-execute t)
(setq py-split-window-on-execute nil))
(when (called-interactively-p 'any) (message "py-split-window-on-execute: %s" py-split-window-on-execute))
py-split-window-on-execute))
(defun py-split-windows-on-execute-on (&optional arg)
"Make sure, `py-split-window-on-execute' is on.
Returns value of `py-split-window-on-execute'. "
(interactive "p")
(let ((arg (or arg 1)))
(toggle-py-split-windows-on-execute arg))
(when (called-interactively-p 'any) (message "py-split-window-on-execute: %s" py-split-window-on-execute))
py-split-window-on-execute)
(defun py-split-windows-on-execute-off ()
"Make sure, `py-split-window-on-execute' is off.
Returns value of `py-split-window-on-execute'. "
(interactive)
(toggle-py-split-windows-on-execute -1)
(when (called-interactively-p 'any) (message "py-split-window-on-execute: %s" py-split-window-on-execute))
py-split-window-on-execute)
;; Shell-Switch-Buffers-On-Execute forms
(defalias 'py-toggle-switch-buffers-on-execute 'py-toggle-shell-switch-buffers-on-execute)
(defalias 'toggle-py-shell-switch-buffers-on-execute 'py-toggle-shell-switch-buffers-on-execute)
(defun py-toggle-shell-switch-buffers-on-execute (&optional arg)
"If `py-switch-buffers-on-execute-p' should be on or off.
Returns value of `py-switch-buffers-on-execute-p' switched to. "
(interactive)
(let ((arg (or arg (if py-switch-buffers-on-execute-p -1 1))))
(if (< 0 arg)
(setq py-switch-buffers-on-execute-p t)
(setq py-switch-buffers-on-execute-p nil))
(when (called-interactively-p 'any) (message "py-shell-switch-buffers-on-execute: %s" py-switch-buffers-on-execute-p))
py-switch-buffers-on-execute-p))
(defun py-shell-switch-buffers-on-execute-on (&optional arg)
"Make sure, `py-switch-buffers-on-execute-p' is on.
Returns value of `py-switch-buffers-on-execute-p'. "
(interactive "p")
(let ((arg (or arg 1)))
(toggle-py-shell-switch-buffers-on-execute arg))
(when (called-interactively-p 'any) (message "py-shell-switch-buffers-on-execute: %s" py-switch-buffers-on-execute-p))
py-switch-buffers-on-execute-p)
(defun py-shell-switch-buffers-on-execute-off ()
"Make sure, `py-switch-buffers-on-execute-p' is off.
Returns value of `py-switch-buffers-on-execute-p'. "
(interactive)
(toggle-py-shell-switch-buffers-on-execute -1)
(when (called-interactively-p 'any) (message "py-shell-switch-buffers-on-execute: %s" py-switch-buffers-on-execute-p))
py-switch-buffers-on-execute-p)
(defun py-guess-default-python ()
"Defaults to \"python\", if guessing didn't succeed. "
(interactive)
(let* ((ptn (or py-shell-name (py-choose-shell) "python"))
(erg (if py-edit-only-p ptn (executable-find ptn))))
(when (called-interactively-p 'any)
(if erg
(message "%s" ptn)
(message "%s" "Could not detect Python on your system")))))
;; from ipython.el
(defun py-dirstack-hook ()
;; the following is to synchronize dir-changes
(make-local-variable 'shell-dirstack)
(setq shell-dirstack nil)
(make-local-variable 'shell-last-dir)
(setq shell-last-dir nil)
(make-local-variable 'shell-dirtrackp)
(setq shell-dirtrackp t)
(add-hook 'comint-input-filter-functions 'shell-directory-tracker nil t))
(defalias 'py-dedicated-shell 'py-shell-dedicated)
(defun py-shell-dedicated (&optional argprompt)
"Start an interactive Python interpreter in another window.
With optional \\[universal-argument] user is prompted by
`py-choose-shell' for command and options to pass to the Python
interpreter.
"
(interactive "P")
(py-shell argprompt t))
(defun py-set-ipython-completion-command-string (shell)
"Set and return `py-ipython-completion-command-string'. "
(interactive)
(let* ((ipython-version (shell-command-to-string (concat shell " -V"))))
(if (string-match "[0-9]" ipython-version)
(setq py-ipython-completion-command-string
(cond ((string-match "^[^0].+" ipython-version)
py-ipython0.11-completion-command-string)
((string-match "^0.1[1-3]" ipython-version)
py-ipython0.11-completion-command-string)
((string= "^0.10" ipython-version)
py-ipython0.10-completion-command-string)))
(error ipython-version))))
(defun py-ipython--module-completion-import (proc)
"Import module-completion "
(interactive)
(let ((ipython-version (shell-command-to-string (concat py-shell-name " -V"))))
(when (and (string-match "^[0-9]" ipython-version)
(string-match "^[^0].+" ipython-version))
(process-send-string proc "from IPython.core.completerlib import module_completion"))))
(defun py--compose-buffer-name-initials (liste)
(let (erg)
(dolist (ele liste)
(unless (string= "" ele)
(setq erg (concat erg (char-to-string (aref ele 0))))))
erg))
(defun py--remove-home-directory-from-list (liste)
"Prepare for compose-buffer-name-initials. "
(let ((case-fold-search t)
(liste liste)
erg)
(if (listp (setq erg (split-string (expand-file-name "~") "\/")))
erg
(setq erg (split-string (expand-file-name "~") "\\\\")))
(while erg
(when (member (car erg) liste)
(setq liste (cdr (member (car erg) liste))))
(setq erg (cdr erg)))
(butlast liste)))
(defun py--choose-buffer-name (&optional name dedicated fast-process)
"Return an appropriate name to display in modeline.
SEPCHAR is the file-path separator of your system. "
(let* ((name-first (or name py-shell-name))
(erg (when name-first (if (stringp name-first) name-first (prin1-to-string name-first))))
(fast-process (or fast-process py-fast-process-p))
prefix)
(when (string-match "^py-" erg)
(setq erg (nth 1 (split-string erg "-"))))
;; remove home-directory from prefix to display
(unless py-modeline-acronym-display-home-p
(save-match-data
(let ((case-fold-search t))
(when (string-match (concat ".*" (expand-file-name "~")) erg)
(setq erg (replace-regexp-in-string (concat "^" (expand-file-name "~")) "" erg))))))
(if (or (and (setq prefix (split-string erg "\\\\"))
(< 1 (length prefix)))
(and (setq prefix (split-string erg "\/"))
(< 1 (length prefix))))
(progn
;; exect something like default py-shell-name
(setq erg (car (last prefix)))
(unless py-modeline-acronym-display-home-p
;; home-directory may still inside
(setq prefix (py--remove-home-directory-from-list prefix))
(setq prefix (py--compose-buffer-name-initials prefix))))
(setq erg (or name py-shell-name))
(setq prefix nil))
(when fast-process (setq erg (concat erg " Fast")))
(setq erg
(cond ((string-match "^ipython" erg)
(replace-regexp-in-string "ipython" "IPython" erg))
((string-match "^jython" erg)
(replace-regexp-in-string "jython" "Jython" erg))
((string-match "^python" erg)
(replace-regexp-in-string "python" "Python" erg))
((string-match "^python2" erg)
(replace-regexp-in-string "python2" "Python2" erg))
((string-match "^python3" erg)
(replace-regexp-in-string "python3" "Python3" erg))
(t erg)))
(when (or dedicated py-dedicated-process-p)
(setq erg (make-temp-name (concat erg "-"))))
(cond ((and prefix (string-match "^\*" erg))
(setq erg (replace-regexp-in-string "^\*" (concat "*" prefix " ") erg)))
(prefix
(setq erg (concat "*" prefix " " erg "*")))
(t (unless (string-match "^\*" erg)(setq erg (concat "*" erg "*")))))
erg))
(defun py--jump-to-exception-intern (act exception-buffer origline)
(let (erg)
(set-buffer exception-buffer)
(goto-char (point-min))
(forward-line (1- origline))
(and (search-forward act (line-end-position) t)
(and py-verbose-p (message "exception-buffer: %s on line %d" py-exception-buffer origline))
(and py-highlight-error-source-p
(setq erg (make-overlay (match-beginning 0) (match-end 0)))
(overlay-put erg
'face 'highlight)))))
(defun py--jump-to-exception (perr origline &optional file)
"Jump to the Python code in FILE at LINE."
(let (
;; (inhibit-point-motion-hooks t)
(file (or file (car perr)))
(act (nth 2 perr)))
(cond ((and py-exception-buffer
(buffer-live-p py-exception-buffer))
;; (pop-to-buffer procbuf)
(py--jump-to-exception-intern act py-exception-buffer origline))
((ignore-errors (file-readable-p file))
(find-file file)
(py--jump-to-exception-intern act (get-buffer (file-name-nondirectory file)) origline))
((buffer-live-p (get-buffer file))
(set-buffer file)
(py--jump-to-exception-intern act file origline))
(t (setq file (find-file (read-file-name "Exception file: "
nil
file t)))
(py--jump-to-exception-intern act file origline)))))
(defalias 'py-toggle-split-window-on-execute-function 'py-toggle-split-window-function)
(defun py-toggle-split-window-function ()
"If window is splitted vertically or horizontally.
When code is executed and `py-split-window-on-execute' is `t', the result is displays in an output-buffer, \"\*Python\*\" by default.
Customizable variable `py-split-windows-on-execute-function' tells how to split the screen."
(interactive)
(if (eq 'split-window-vertically py-split-windows-on-execute-function)
(setq py-split-windows-on-execute-function'split-window-horizontally)
(setq py-split-windows-on-execute-function 'split-window-vertically))
(when (and py-verbose-p (called-interactively-p 'any))
(message "py-split-windows-on-execute-function set to: %s" py-split-windows-on-execute-function)))
(defun py--manage-windows-set-and-switch (buffer)
"Switch to output-buffer, go to point-max.
Internal use"
(set-buffer buffer)
(goto-char (process-mark (get-buffer-process (current-buffer)))))
(defun py--alternative-split-windows-on-execute-function ()
"If `py--split-windows-on-execute-function' is `split-window-vertically' return `split-window-horizontally' and vice versa"
(if (eq py-split-windows-on-execute-function 'split-window-vertically)
'split-window-horizontally
'split-window-vertically))
(defun py--get-splittable-window ()
"If selected window doesn't permit a further split, search window-list for a suitable one. "
(or (and (window-left-child)(split-window (window-left-child)))
(and (window-top-child)(split-window (window-top-child)))
(and (window-parent)(ignore-errors (split-window (window-parent))))
(and (window-atom-root)(split-window (window-atom-root)))))
(defun py--manage-windows-split (exception-buffer)
"If one window, split according to `py-split-windows-on-execute-function. "
(interactive)
(set-buffer exception-buffer)
(or
(ignore-errors (funcall py-split-windows-on-execute-function))
;; If call didn't succeed according to settings of
;; `split-height-threshold', `split-width-threshold'
;; resp. `window-min-height', `window-min-width'
;; try alternative split
(unless (ignore-errors (funcall (py--alternative-split-windows-on-execute-function)))
;; if alternative split fails, look for larger window
(py--get-splittable-window)
(ignore-errors (funcall (py--alternative-split-windows-on-execute-function))))))
;; (defun py--display-windows (output-buffer)
;; "Otherwise new window appears above"
;; (display-buffer output-buffer)
;; (select-window py-exception-window))
(defun py--split-t-not-switch-wm (output-buffer number-of-windows)
(unless (window-live-p output-buffer)
(with-current-buffer (get-buffer output-buffer)
(when (< number-of-windows py-split-window-on-execute-threshold)
(unless
(member (get-buffer-window output-buffer)(window-list))
(py--manage-windows-split py-exception-buffer)))
(display-buffer output-buffer t))))
(defun py--shell-manage-windows (output-buffer &optional exception-buffer split switch)
"Adapt or restore window configuration. Return nil "
(let* ((py-exception-buffer (or exception-buffer (and py-exception-buffer (buffer-live-p py-exception-buffer) py-exception-buffer)))
(output-buffer (or output-buffer py-buffer-name))
(old-window-list (window-list))
(number-of-windows (length old-window-list))
(split (or split py-split-window-on-execute))
(switch (or switch py-switch-buffers-on-execute-p)))
;; (output-buffer-displayed-p)
(cond
(py-keep-windows-configuration
(py-restore-window-configuration)
(set-buffer output-buffer)
(goto-char (point-max)))
((and (eq split 'always)
switch)
(if (member (get-buffer-window output-buffer)(window-list))
;; (delete-window (get-buffer-window output-buffer))
(select-window (get-buffer-window output-buffer))
(py--manage-windows-split py-exception-buffer)
;; otherwise new window appears above
(save-excursion
(other-window 1)
(switch-to-buffer output-buffer))
(display-buffer py-exception-buffer)))
((and
(eq split 'always)
(not switch))
(if (member (get-buffer-window output-buffer)(window-list))
(select-window (get-buffer-window output-buffer))
(py--manage-windows-split py-exception-buffer)
(display-buffer output-buffer)
(pop-to-buffer py-exception-buffer)))
((and
(eq split 'just-two)
switch)
(switch-to-buffer (current-buffer))
(delete-other-windows)
;; (sit-for py-new-shell-delay)
(py--manage-windows-split py-exception-buffer)
;; otherwise new window appears above
(other-window 1)
(set-buffer output-buffer)
(switch-to-buffer (current-buffer)))
((and
(eq split 'just-two)
(not switch))
(switch-to-buffer py-exception-buffer)
(delete-other-windows)
(unless
(member (get-buffer-window output-buffer)(window-list))
(py--manage-windows-split py-exception-buffer))
;; Fixme: otherwise new window appears above
(save-excursion
(other-window 1)
(pop-to-buffer output-buffer)
(goto-char (point-max))
(other-window 1)))
((and
split
(not switch))
;; https://bugs.launchpad.net/python-mode/+bug/1478122
;; > If the shell is visible in any of the windows it should re-use that window
;; > I did double check and py-keep-window-configuration is nil and split is t.
(py--split-t-not-switch-wm output-buffer number-of-windows))
((and split switch)
(unless
(member (get-buffer-window output-buffer)(window-list))
(py--manage-windows-split py-exception-buffer))
;; Fixme: otherwise new window appears above
;; (save-excursion
;; (other-window 1)
;; (pop-to-buffer output-buffer)
;; [Bug 1579309] python buffer window on top when using python3
(set-buffer output-buffer)
(switch-to-buffer output-buffer)
(goto-char (point-max))
;; (other-window 1)
)
((not switch)
(let (pop-up-windows)
(py-restore-window-configuration))))))
(defun py-kill-shell-unconditional (&optional shell)
"With optional argument SHELL.
Otherwise kill default (I)Python shell.
Kill buffer and its process.
Receives a buffer-name as argument"
(interactive)
(let ((shell (or shell (py-shell))))
(py-kill-buffer-unconditional shell)))
(defun py-kill-default-shell-unconditional ()
"Kill buffer \"\*Python\*\" and its process. "
(interactive)
(py-kill-buffer-unconditional "*Python*"))
(defun py--report-executable (buffer)
(let ((erg (downcase (replace-regexp-in-string
"<\\([0-9]+\\)>" ""
(replace-regexp-in-string
"\*" ""
(if
(string-match " " buffer)
(substring buffer (1+ (string-match " " buffer)))
buffer))))))
(when (string-match "-" erg)
(setq erg (substring erg 0 (string-match "-" erg))))
erg))
(defun py--shell-make-comint (executable buffer args)
"Returns the buffer of the comint-proces created. "
(let* ((buffer (apply #'make-comint-in-buffer executable buffer executable nil (split-string-and-unquote (car args))))
(proc (get-buffer-process buffer)))
(with-current-buffer buffer
(if (string-match "^i" (process-name proc))
(py-ipython-shell-mode)
(py-python-shell-mode)))
buffer))
(defun py--guess-buffer-name (argprompt dedicated)
"Guess the buffer-name core string. "
(when (and (not dedicated) argprompt
(eq 4 (prefix-numeric-value argprompt)))
(read-buffer "Py-Shell buffer: "
(generate-new-buffer-name (py--choose-buffer-name)))))
(defun py--configured-shell (name)
"Return the configured PATH/TO/STRING if any. "
(if (string-match "//\\|\\\\" name)
name
(cond ((string-match "^[Ii]" name)
(or py-ipython-command name))
((string-match "[Pp]ython3" name)
(or py-python3-command name))
((string-match "[Pp]ython2" name)
(or py-python2-command name))
((string-match "[Jj]ython" name)
(or py-jython-command name))
(t (or py-python-command name)))))
(defun py--grab-prompt-ps1 (proc buffer)
(py--send-string-no-output "import sys")
(py--fast-send-string-intern "sys.ps1" proc buffer t))
(defun py--start-fast-process (shell buffer)
(let ((proc (start-process shell buffer shell)))
(with-current-buffer buffer
(erase-buffer))
proc))
(defun py--shell-fast-proceeding (proc buffer shell setup-code)
(unless (get-buffer-process (get-buffer buffer))
(setq proc (py--start-fast-process shell buffer))
(setq py-output-buffer buffer)
(py--fast-send-string-no-output setup-code proc buffer)))
(defun py--reuse-existing-shell (exception-buffer)
(setq py-exception-buffer (or exception-buffer (and py-exception-buffer (buffer-live-p py-exception-buffer) py-exception-buffer) py-buffer-name)))
(defun py--create-new-shell (executable args buffer-name exception-buffer)
(let ((buf (current-buffer)))
(with-current-buffer
(apply #'make-comint-in-buffer executable buffer-name executable nil (split-string-and-unquote args))
(let ((proc (get-buffer-process (current-buffer))))
(if (string-match "^i" (process-name proc))
(py-ipython-shell-mode)
(py-python-shell-mode)))
(setq py-output-buffer (current-buffer))
(sit-for 0.1 t)
(goto-char (point-max))
;; otherwise comint might initialize it with point-min
(set-marker comint-last-input-end (point))
(setq py-exception-buffer (or exception-buffer (and py-exception-buffer (buffer-live-p py-exception-buffer) py-exception-buffer) buf)))))
(defun py--determine-local-default ()
(if (not (string= "" py-shell-local-path))
(expand-file-name py-shell-local-path)
(when py-use-local-default
(error "Abort: `py-use-local-default' is set to `t' but `py-shell-local-path' is empty. Maybe call `py-toggle-local-default-use'"))))
(defun py--provide-command-args (fast-process argprompt)
(cond (fast-process nil)
((eq 2 (prefix-numeric-value argprompt))
(mapconcat 'identity py-python2-command-args " "))
((string-match "^[Ii]" py-shell-name)
py-ipython-command-args)
((string-match "^[^-]+3" py-shell-name)
(mapconcat 'identity py-python3-command-args " "))
(t (mapconcat 'identity py-python-command-args " "))))
;;;###autoload
(defun py-shell (&optional argprompt dedicated shell buffer fast exception-buffer split switch)
"Start an interactive Python interpreter in another window.
Interactively, \\[universal-argument] prompts for a new buffer-name.
\\[universal-argument] 2 prompts for `py-python-command-args'.
If `default-directory' is a remote file name, it is also prompted
to change if called with a prefix arg.
Optional string SHELL overrides default `py-shell-name'.
Returns py-shell's buffer-name.
BUFFER allows specifying a name, the Python process is connected to
FAST process not in comint-mode buffer
EXCEPTION-BUFFER point to error
SPLIT see var `py-split-window-on-execute'
SWITCH see var `py-switch-buffers-on-execute-p'
"
(interactive "P")
;; done by py-shell-mode
(let* (
;; (windows-config (window-configuration-to-register 313465889))
(fast (or fast py-fast-process-p))
(dedicated (or dedicated py-dedicated-process-p))
(py-shell-name (or shell
(py-choose-shell nil fast)))
(args (py--provide-command-args fast argprompt))
(py-use-local-default (py--determine-local-default))
(py-buffer-name (or buffer (py--guess-buffer-name argprompt dedicated)))
(py-buffer-name (or py-buffer-name (py--choose-buffer-name nil dedicated fast)))
(executable (cond (py-shell-name)
(py-buffer-name
(py--report-executable py-buffer-name))))
proc)
(and (bufferp (get-buffer py-buffer-name))(buffer-live-p (get-buffer py-buffer-name))(string= (buffer-name (current-buffer)) (buffer-name (get-buffer py-buffer-name)))
(setq py-buffer-name (generate-new-buffer-name py-buffer-name)))
(sit-for 0.1 t)
(if fast
;; user rather wants an interactive shell
(py--shell-fast-proceeding proc py-buffer-name py-shell-name py-shell-completion-setup-code)
(if (comint-check-proc py-buffer-name)
(py--reuse-existing-shell exception-buffer)
;; buffer might exist but not being empty
(when (buffer-live-p py-buffer-name)
(with-current-buffer py-buffer-name
(erase-buffer)))
(py--create-new-shell executable args py-buffer-name exception-buffer))
(when (or (called-interactively-p 'any)
(eq 1 argprompt)
(or switch py-switch-buffers-on-execute-p))
(py--shell-manage-windows py-buffer-name py-exception-buffer split switch)))
py-buffer-name))
(defun py-shell-get-process (&optional argprompt dedicated shell buffer)
"Get appropriate Python process for current buffer and return it."
(interactive)
(let ((erg (get-buffer-process (py-shell argprompt dedicated shell buffer))))
(when (called-interactively-p 'any) (message "%S" erg))
erg))
(defun py-switch-to-shell ()
"Switch to Python process buffer."
(interactive)
(pop-to-buffer (py-shell) t))
;; Code execution commands
(defun py-which-execute-file-command (filename)
"Return the command appropriate to Python version.
Per default it's \"(format \"execfile(r'%s') # PYTHON-MODE\\n\" filename)\" for Python 2 series."
(format "exec(compile(open(r'%s').read(), r'%s', 'exec')) # PYTHON-MODE\n" filename filename))
(defun py--store-result-maybe (erg)
"If no error occurred and `py-store-result-p' store result for yank. "
(and (not py-error) erg (or py-debug-p py-store-result-p) (kill-new erg)))
(defun py--close-execution (tempbuf tempfile)
"Delete temporary buffer and and run `py--store-result-maybe'"
(unless py-debug-p
(when tempfile (py-delete-temporary tempfile tempbuf))))
(defun py--execute-base (&optional start end shell filename proc file wholebuf fast dedicated split switch return)
"Update variables. "
(setq py-error nil)
(let* ((exception-buffer (current-buffer))
(start (or start (and (use-region-p) (region-beginning)) (point-min)))
(end (or end (and (use-region-p) (region-end)) (point-max)))
(strg-raw (if py-if-name-main-permission-p
(buffer-substring-no-properties start end)
(py--fix-if-name-main-permission (buffer-substring-no-properties start end))))
(strg (py--fix-start strg-raw))
(wholebuf (unless file (or wholebuf (and (eq (buffer-size) (- end start))))))
;; (windows-config (window-configuration-to-register py-windows-config-register))
(origline
(save-restriction
(widen)
(py-count-lines (point-min) end)))
;; argument SHELL might be a string like "python", "IPython" "python3", a symbol holding PATH/TO/EXECUTABLE or just a symbol like 'python3
(shell (or
(and shell
;; shell might be specified in different ways
(or (and (stringp shell) shell)
(ignore-errors (eval shell))
(and (symbolp shell) (format "%s" shell))))
(py-choose-shell nil fast)))
(execute-directory
(cond ((ignore-errors (file-name-directory (file-remote-p (buffer-file-name) 'localname))))
((and py-use-current-dir-when-execute-p (buffer-file-name))
(file-name-directory (buffer-file-name)))
((and py-use-current-dir-when-execute-p
py-fileless-buffer-use-default-directory-p)
(expand-file-name default-directory))
((stringp py-execute-directory)
py-execute-directory)
((getenv "VIRTUAL_ENV"))
(t (getenv "HOME"))))
(buffer (py--choose-buffer-name shell dedicated fast))
(filename (or (and filename (expand-file-name filename))
(py--buffer-filename-remote-maybe)))
(py-orig-buffer-or-file (or filename (current-buffer)))
(proc (or proc (get-buffer-process buffer)
(get-buffer-process (py-shell nil dedicated shell buffer fast exception-buffer split switch))))
(fast (or fast py-fast-process-p))
(return (or return py-return-result-p)))
(setq py-buffer-name buffer)
(py--execute-base-intern strg filename proc file wholebuf buffer origline execute-directory start end shell fast return)
(when (or split py-split-window-on-execute py-switch-buffers-on-execute-p)
(py--shell-manage-windows buffer exception-buffer split switch))))
(defun py--send-to-fast-process (strg proc output-buffer return)
"Called inside of `py--execute-base-intern' "
(let ((output-buffer (or output-buffer (process-buffer proc))))
(with-current-buffer output-buffer
(py--fast-send-string-intern strg
proc
output-buffer py-return-result-p)
(sit-for 0.1))))
(defun py--delete-temp-file (tempfile &optional tempbuf)
"The called, after `py--execute-buffer-finally' returned. "
(sit-for py--delete-temp-file-delay t)
(py--close-execution tempbuf tempfile))
(defun py--execute-buffer-finally (strg which-shell proc procbuf origline)
(let* ((temp (make-temp-name
;; FixMe: that should be simpler
(concat (replace-regexp-in-string py-separator-char "-" (replace-regexp-in-string (concat "^" py-separator-char) "" (replace-regexp-in-string ":" "-" (if (stringp which-shell) which-shell (prin1-to-string which-shell))))) "-")))
(tempbuf (get-buffer-create temp))
erg)
(setq py-tempfile (concat (expand-file-name py-temp-directory) py-separator-char (replace-regexp-in-string py-separator-char "-" temp) ".py"))
(with-current-buffer tempbuf
(insert strg)
(write-file py-tempfile))
(unwind-protect
(setq erg (py--execute-file-base proc py-tempfile nil procbuf origline)))
erg))
(defun py--execute-base-intern (strg filename proc file wholebuf buffer origline execute-directory start end which-shell &optional fast return)
"Select the handler.
When optional FILE is `t', no temporary file is needed. "
(let ()
(setq py-error nil)
(py--update-execute-directory proc buffer execute-directory)
(cond (fast (py--send-to-fast-process strg proc buffer return))
;; enforce proceeding as python-mode.el v5
(python-mode-v5-behavior-p
(py-execute-python-mode-v5 start end py-exception-buffer origline))
(py-execute-no-temp-p
(py--execute-ge24.3 start end execute-directory which-shell py-exception-buffer proc file origline))
((and filename wholebuf)
(py--execute-file-base proc filename nil buffer origline))
(t
(py--execute-buffer-finally strg which-shell proc buffer origline)
(py--delete-temp-file py-tempfile)))))
(defun py--fetch-error (&optional origline)
"Highlight exceptions found in BUF.
If an exception occurred return error-string, otherwise return nil. BUF must exist.
Indicate LINE if code wasn't run from a file, thus remember line of source buffer "
(let* (erg)
(when py-debug-p (switch-to-buffer (current-buffer)))
(goto-char (point-min))
(when (re-search-forward "File \"\\(.+\\)\", line \\([0-9]+\\)\\(.*\\)$" nil t)
(setq erg (copy-marker (point)))
;; Replace hints to temp-file by orig-file
(delete-region (progn (beginning-of-line)
(save-match-data
(when (looking-at
;; all prompt-regexp known
py-fast-filter-re)
(goto-char (match-end 0))))
(skip-chars-forward " \t\r\n\f")(point)) (line-end-position))
(insert (concat " File " (buffer-name py-exception-buffer) ", line "
(prin1-to-string origline))))
(when erg
(goto-char erg)
(save-match-data
(and (not (py--buffer-filename-remote-maybe
(or
(get-buffer py-exception-buffer)
(get-buffer (file-name-nondirectory py-exception-buffer)))))
(string-match "^[ \t]*File" (buffer-substring-no-properties (point) (line-end-position)))
(looking-at "[ \t]*File")
(replace-match " Buffer")))
(setq py-error (buffer-substring-no-properties (point-min) (point-max)))
(sit-for 0.1 t)
py-error)))
(defun py--fetch-result (orig)
"Return buffer-substring from orig to point-max. "
(replace-regexp-in-string
(format "[ \n]*%s[ \n]*" py-fast-filter-re)
""
(buffer-substring-no-properties orig (point-max))))
(defun py--postprocess-comint (output-buffer origline orig)
"Provide return values, check result for error, manage windows. "
;; py--fast-send-string doesn't set origline
(let (py-result py-error)
(with-current-buffer output-buffer
(sit-for 0.1 t)
;; (when py-debug-p (switch-to-buffer (current-buffer)))
;; (delete-region (point-min) orig)
(setq py-result (py--fetch-result orig)))
;; (when py-debug-p (message "py-result: %s" py-result))
(and (string-match "\n$" py-result)
(setq py-result (replace-regexp-in-string py-fast-filter-re "" (substring py-result 0 (match-beginning 0)))))
(if py-result
(if (string-match "^Traceback" py-result)
(progn
(with-temp-buffer
(insert py-result)
(sit-for 0.1 t)
(setq py-error (py--fetch-error origline)))
;; (with-current-buffer output-buffer
;; ;; `comint-last-prompt' must not exist
;; (delete-region (point) (or (ignore-errors (car comint-last-prompt)) (point-max)))
;; (sit-for 0.1 t)
;; (insert py-error)
;; (newline)
;; (goto-char (point-max)))
)
;; position no longer needed, no need to correct
(when py-store-result-p
(when (and py-result (not (string= "" py-result))(not (string= (car kill-ring) py-result))) (kill-new py-result)))
py-result)
(message "py--postprocess-comint: %s" "Don't see any result"))))
(defun py--execute-ge24.3 (start end execute-directory which-shell &optional exception-buffer proc file origline)
"An alternative way to do it.
May we get rid of the temporary file? "
(and (py--buffer-filename-remote-maybe) buffer-offer-save (buffer-modified-p (py--buffer-filename-remote-maybe)) (y-or-n-p "Save buffer before executing? ")
(write-file (py--buffer-filename-remote-maybe)))
(let* ((start (copy-marker start))
(end (copy-marker end))
(exception-buffer (or exception-buffer (current-buffer)))
(line (py-count-lines (point-min) (if (eq start (line-beginning-position)) (1+ start) start)))
(strg (buffer-substring-no-properties start end))
(tempfile (or (py--buffer-filename-remote-maybe) (concat (expand-file-name py-temp-directory) py-separator-char (replace-regexp-in-string py-separator-char "-" "temp") ".py")))
(proc (or proc (if py-dedicated-process-p
(get-buffer-process (py-shell nil py-dedicated-process-p which-shell py-buffer-name))
(or (get-buffer-process py-buffer-name)
(get-buffer-process (py-shell nil py-dedicated-process-p which-shell py-buffer-name))))))
(procbuf (process-buffer proc))
(file (or file (with-current-buffer py-buffer-name
(concat (file-remote-p default-directory) tempfile))))
(filebuf (get-buffer-create file)))
(set-buffer filebuf)
(erase-buffer)
(newline line)
(save-excursion
(insert strg))
(py--fix-start (buffer-substring-no-properties (point) (point-max)))
(unless (string-match "[jJ]ython" which-shell)
;; (when (and execute-directory py-use-current-dir-when-execute-p
;; (not (string= execute-directory default-directory)))
;; (message "Warning: options `execute-directory' and `py-use-current-dir-when-execute-p' may conflict"))
(and execute-directory
(process-send-string proc (concat "import os; os.chdir(\"" execute-directory "\")\n"))
))
(set-buffer filebuf)
(process-send-string proc
(buffer-substring-no-properties
(point-min) (point-max)))
(sit-for 0.1 t)
(if (and (setq py-error (save-excursion (py--postprocess-intern origline exception-buffer)))
(car py-error)
(not (markerp py-error)))
(py--jump-to-exception py-error origline)
(unless (string= (buffer-name (current-buffer)) (buffer-name procbuf))
(when py-verbose-p (message "Output buffer: %s" procbuf))))))
(defun py-delete-temporary (&optional file filebuf)
(when (file-readable-p file)
(delete-file file))
(when (buffer-live-p filebuf)
(set-buffer filebuf)
(set-buffer-modified-p 'nil)
(kill-buffer filebuf)))
(defun py-execute-python-mode-v5 (start end &optional exception-buffer origline)
(interactive "r")
(let ((exception-buffer (or exception-buffer (current-buffer)))
(pcmd (concat py-shell-name (if (string-equal py-which-bufname
"Jython")
" -"
;; " -c "
""))))
(save-excursion
(shell-command-on-region start end
pcmd py-output-buffer))
(if (not (get-buffer py-output-buffer))
(message "No output.")
(setq py-error (py--postprocess-intern origline exception-buffer))
(let* ((line (cadr py-error)))
(if py-error
(when (and py-jump-on-exception line)
(pop-to-buffer exception-buffer))
(pop-to-buffer py-output-buffer)
(goto-char (point-max))
(copy-marker (point)))))))
(defun py--insert-offset-lines (line)
"Fix offline amount, make error point at the corect line. "
(insert (make-string (- line (py-count-lines (point-min) (point))) 10)))
(defun py--execute-file-base (&optional proc filename cmd procbuf origline)
"Send to Python interpreter process PROC, in Python version 2.. \"execfile('FILENAME')\".
Make that process's buffer visible and force display. Also make
comint believe the user typed this string so that
`kill-output-from-shell' does The Right Thing.
Returns position where output starts. "
(let* ((origline (or (ignore-errors origline) 1))
(buffer (or procbuf (py-shell nil nil nil procbuf)))
(proc (or proc (get-buffer-process buffer)))
(cmd (or cmd (py-which-execute-file-command filename)))
;; (windows-config (window-configuration-to-register py-windows-config-register))
erg orig)
(with-current-buffer buffer
;; (when py-debug-p (switch-to-buffer (current-buffer)))
(goto-char (point-max))
(setq orig (copy-marker (point)))
(py-send-string cmd proc)
(when py-return-result-p
(setq erg (py--postprocess-comint buffer origline orig))
(if py-error
(setq py-error (prin1-to-string py-error))
erg)))))
(defun py-execute-file (filename)
"When called interactively, user is prompted for filename. "
(interactive "fFilename: ")
(let (;; postprocess-output-buffer might want origline
(origline 1)
;; (windows-config (window-configuration-to-register 313465889))
(py-exception-buffer filename)
erg)
(if (file-readable-p filename)
(if py-store-result-p
(setq erg (py--execute-file-base nil (expand-file-name filename) nil nil origline))
(py--execute-file-base nil (expand-file-name filename)))
(message "%s not readable. %s" filename "Do you have write permissions?"))
erg))
(defun py--current-working-directory (&optional shell)
"Return the directory of current `py-shell'."
(replace-regexp-in-string "\n" "" (shell-command-to-string (concat (or shell py-shell-name) " -c \"import os; print(os.getcwd())\""))))
(defun py--update-execute-directory-intern (dir proc)
(comint-send-string proc (concat "import os;os.chdir(\"" dir "\")\n")))
(defun py--update-execute-directory (proc procbuf execute-directory)
(let ((py-exception-buffer (current-buffer))
orig cwd)
(set-buffer procbuf)
(setq cwd (py--current-working-directory))
(setq orig (point))
(unless (string= execute-directory (concat cwd "/"))
(py--update-execute-directory-intern (or py-execute-directory execute-directory) proc)
(delete-region orig (point-max)))
(set-buffer py-exception-buffer)))
(defun py-execute-string (&optional strg shell dedicated switch fast)
"Send the argument STRING to Python default interpreter.
See also `py-execute-region'. "
(interactive)
(let ((strg (or strg (read-from-minibuffer "String: ")))
(shell (or shell (default-value 'py-shell-name))))
(with-temp-buffer
(insert strg)
(py-execute-region (point-min) (point-max) shell dedicated switch fast))))
(defun py-execute-string-dedicated (&optional strg shell switch fast)
"Send the argument STRING to an unique Python interpreter.
See also `py-execute-region'. "
(interactive)
(let ((strg (or strg (read-from-minibuffer "String: ")))
(shell (or shell (default-value 'py-shell-name))))
(with-temp-buffer
(insert strg)
(py-execute-region (point-min) (point-max) shell t switch fast))))
(defun py--insert-execute-directory (directory &optional orig done)
(let ((orig (or orig (point)))
(done done))
(if done (goto-char done) (goto-char (point-min)))
(cond ((re-search-forward "^from __future__ import " nil t 1)
(py-forward-statement)
(setq done (point))
(py--insert-execute-directory directory orig done))
((re-search-forward py-encoding-string-re nil t 1)
(setq done (point))
(py--insert-execute-directory directory orig done))
((re-search-forward py-shebang-regexp nil t 1)
(setq done (point))
(py--insert-execute-directory directory orig done))
(t (forward-line 1)
(unless ;; (empty-line-p)
(eq 9 (char-after)) (newline))
(insert (concat "import os; os.chdir(\"" directory "\")\n"))))))
(defun py--fix-if-name-main-permission (strg)
"Remove \"if __name__ == '__main__ '\" from code to execute.
See `py-if-name-main-permission-p'"
(let ((strg (if py-if-name-main-permission-p strg
(replace-regexp-in-string
"if[( ]*__name__[) ]*==[( ]*['\"]\\{1,3\\}__main__['\"]\\{1,3\\}[) ]*:"
;; space after __main__, i.e. will not be executed
"if __name__ == '__main__ ':" strg))))
strg))
;; `py-execute-line' calls void function, lp:1492054, lp:1519859
(or (functionp 'indent-rigidly-left)
(defun indent-rigidly--pop-undo ()
(and (memq last-command '(indent-rigidly-left indent-rigidly-right
indent-rigidly-left-to-tab-stop
indent-rigidly-right-to-tab-stop))
(consp buffer-undo-list)
(eq (car buffer-undo-list) nil)
(pop buffer-undo-list)))
(defun indent-rigidly-left (beg end)
"Indent all lines between BEG and END leftward by one space."
(interactive "r")
(indent-rigidly--pop-undo)
(indent-rigidly
beg end
(if (eq (current-bidi-paragraph-direction) 'right-to-left) 1 -1))))
(defun py--fix-start (strg)
"Internal use by py-execute... functions.
Avoid empty lines at the beginning. "
;; (when py-debug-p (message "py--fix-start:"))
(with-temp-buffer
(python-mode)
(let (erg)
(insert strg)
(goto-char 1)
(when (< 0 (setq erg (skip-chars-forward " \t\r\n\f" (line-end-position))))
(dotimes (_ erg)
(indent-rigidly-left (point-min) (point-max))))
(unless (py--beginning-of-statement-p)
(py-forward-statement))
(while (not (eq (current-indentation) 0))
(py-shift-left py-indent-offset))
(goto-char (point-max))
(unless (empty-line-p)
(newline))
(buffer-substring-no-properties 1 (point-max)))))
(defun py-fetch-py-master-file ()
"Lookup if a `py-master-file' is specified.
See also doku of variable `py-master-file' "
(interactive)
(save-excursion
(save-restriction
(widen)
(goto-char (point-min))
(when (re-search-forward "^ *# Local Variables:" nil (quote move) 1)
(when
(re-search-forward (concat "^\\( *# py-master-file: *\\)\"\\([^ \t]+\\)\" *$") nil t 1)
(setq py-master-file (match-string-no-properties 2))))))
(when (called-interactively-p 'any) (message "%s" py-master-file)))
(defun py-execute-import-or-reload (&optional shell)
"Import the current buffer's file in a Python interpreter.
If the file has already been imported, then do reload instead to get
the latest version.
If the file's name does not end in \".py\", then do execfile instead.
If the current buffer is not visiting a file, do `py-execute-buffer'
instead.
If the file local variable `py-master-file' is non-nil, import or
reload the named file instead of the buffer's file. The file may be
saved based on the value of `py-execute-import-or-reload-save-p'.
See also `\\[py-execute-region]'.
This may be preferable to `\\[py-execute-buffer]' because:
- Definitions stay in their module rather than appearing at top
level, where they would clutter the global namespace and not affect
uses of qualified names (MODULE.NAME).
- The Python debugger gets line number information about the functions."
(interactive)
;; Check file local variable py-master-file
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer)))
(let ((py-shell-name (or shell (py-choose-shell)))
(file (py--buffer-filename-remote-maybe (current-buffer))))
(if file
(let ((proc (or
(ignore-errors (get-process (file-name-directory shell)))
(get-buffer-process (py-shell nil py-dedicated-process-p shell (or shell (default-value 'py-shell-name)))))))
;; Maybe save some buffers
(save-some-buffers (not py-ask-about-save) nil)
(py--execute-file-base proc file
(if (string-match "\\.py$" file)
(let ((m (py--qualified-module-name (expand-file-name file))))
(if (string-match "python2" py-shell-name)
(format "import sys\nif sys.modules.has_key('%s'):\n reload(%s)\nelse:\n import %s\n" m m m)
(format "import sys,imp\nif'%s' in sys.modules:\n imp.reload(%s)\nelse:\n import %s\n" m m m)))
;; (format "execfile(r'%s')\n" file)
(py-which-execute-file-command file))))
(py-execute-buffer))))
(defun py--qualified-module-name (file)
"Find the qualified module name for filename FILE.
Basically, this goes down the directory tree as long as there are __init__.py files there."
(let ((rec #'(lambda (d f)
(let* ((dir (file-name-directory d))
(initpy (concat dir "__init__.py")))
(if (file-exists-p initpy)
(let ((d2 (directory-file-name d)))
(funcall rec (file-name-directory d2)
(concat (file-name-nondirectory d2) "." f)))
f)))))
(funcall rec (file-name-directory file)
(file-name-sans-extension (file-name-nondirectory file)))))
;; Fixme: Try to define the function or class within the relevant
;; module, not just at top level.
(defun py-execute-defun ()
"Send the current defun (class or method) to the Python process."
(interactive)
(save-excursion (py-execute-region (progn (beginning-of-defun) (point))
(progn (end-of-defun) (point)))))
(defun py-process-file (filename &optional output-buffer error-buffer)
"Process \"python filename\".
Optional OUTPUT-BUFFER and ERROR-BUFFER might be given. "
(interactive "fDatei:")
(let ((coding-system-for-read 'utf-8)
(coding-system-for-write 'utf-8)
(output-buffer (or output-buffer (make-temp-name "py-process-file-output")))
(pcmd (py-choose-shell)))
(unless (buffer-live-p output-buffer)
(set-buffer (get-buffer-create output-buffer)))
(shell-command (concat pcmd " " filename) output-buffer error-buffer)
(when (called-interactively-p 'any) (switch-to-buffer output-buffer))))
(defvar py-last-exeption-buffer nil
"Internal use only - when `py-up-exception' is called in
source-buffer, this will deliver the exception-buffer again. ")
(defun py-remove-overlays-at-point ()
"Remove overlays as set when `py-highlight-error-source-p' is non-nil. "
(interactive "*")
(delete-overlay (car (overlays-at (point)))))
(defun py-mouseto-exception (event)
"Jump to the code which caused the Python exception at EVENT.
EVENT is usually a mouse click."
(interactive "e")
(cond
((fboundp 'event-point)
;; XEmacs
(let* ((point (event-point event))
(buffer (event-buffer event))
(e (and point buffer (extent-at point buffer 'py-exc-info)))
(info (and e (extent-property e 'py-exc-info))))
(message "Event point: %d, info: %s" point info)
(and info
(py--jump-to-exception (car info) nil (cdr info)))))))
(defun py-goto-exception (&optional file line)
"Go to the line indicated by the traceback."
(interactive)
(let ((file file)
(line line))
(unless (and file line)
(save-excursion
(beginning-of-line)
(if (looking-at py-traceback-line-re)
(setq file (substring-no-properties (match-string 1))
line (string-to-number (match-string 2))))))
(if (not file)
(error "Not on a traceback line"))
(find-file file)
(goto-char (point-min))
(forward-line (1- line))))
(defun py--find-next-exception (start buffer searchdir errwhere)
"Find the next Python exception and jump to the code that caused it.
START is the buffer position in BUFFER from which to begin searching
for an exception. SEARCHDIR is a function, either
`re-search-backward' or `re-search-forward' indicating the direction
to search. ERRWHERE is used in an error message if the limit (top or
bottom) of the trackback stack is encountered."
(let (file line)
(save-excursion
(with-current-buffer buffer
(goto-char (py--point start))
(if (funcall searchdir py-traceback-line-re nil t)
(setq file (match-string 1)
line (string-to-number (match-string 2))))))
(if (and file line)
(py-goto-exception file line)
(error "%s of traceback" errwhere))))
(defun py-down-exception (&optional bottom)
"Go to the next line down in the traceback.
With \\[univeral-argument] (programmatically, optional argument
BOTTOM), jump to the bottom (innermost) exception in the exception
stack."
(interactive "P")
(let* ((proc (get-process "Python"))
(buffer (if proc "*Python*" py-output-buffer)))
(if bottom
(py--find-next-exception 'eob buffer 're-search-backward "Bottom")
(py--find-next-exception 'eol buffer 're-search-forward "Bottom"))))
(defun py-up-exception (&optional top)
"Go to the previous line up in the traceback.
With \\[universal-argument] (programmatically, optional argument TOP)
jump to the top (outermost) exception in the exception stack."
(interactive "P")
(let* ((proc (get-process "Python"))
(buffer (if proc "*Python*" py-output-buffer)))
(if top
(py--find-next-exception 'bob buffer 're-search-forward "Top")
(py--find-next-exception 'bol buffer 're-search-backward "Top"))))
;; ;
;; obsolete by py--fetch-result
;; followed by py--fetch-error
;; still used by py--execute-ge24.3
(defun py--postprocess-intern (&optional origline exception-buffer)
"Highlight exceptions found in BUF.
If an exception occurred return error-string, otherwise return nil. BUF must exist.
Indicate LINE if code wasn't run from a file, thus remember line of source buffer "
(let* ((pmx (copy-marker (point-max)))
estring ecode erg)
;; (switch-to-buffer (current-buffer))
(goto-char pmx)
(sit-for 0.1 t)
(save-excursion
(unless (looking-back py-pdbtrack-input-prompt (line-beginning-position))
(forward-line -1)
(end-of-line)
(when (or (re-search-backward py-shell-prompt-regexp nil t 1)
(re-search-backward (concat py-ipython-input-prompt-re "\\|" py-ipython-output-prompt-re) nil t 1))
(save-excursion
(when (re-search-forward "File \"\\(.+\\)\", line \\([0-9]+\\)\\(.*\\)$" nil t)
(setq erg (copy-marker (point)))
(delete-region (progn (beginning-of-line)
(save-match-data
(when (looking-at
;; all prompt-regexp known
py-fast-filter-re)
(goto-char (match-end 0))))
(skip-chars-forward " \t\r\n\f")(point)) (line-end-position))
(insert (concat " File " (buffer-name exception-buffer) ", line "
(prin1-to-string origline)))))
;; these are let-bound as `tempbuf'
(and (boundp 'tempbuf)
;; (message "%s" tempbuf)
(search-forward (buffer-name tempbuf) nil t)
(delete-region (line-beginning-position) (1+ (line-end-position))))
;; if no buffer-file exists, signal "Buffer", not "File(when
(when erg
(goto-char erg)
;; (forward-char -1)
;; (skip-chars-backward "^\t\r\n\f")
;; (skip-chars-forward " \t")
(save-match-data
(and (not (py--buffer-filename-remote-maybe
(or
(get-buffer exception-buffer)
(get-buffer (file-name-nondirectory exception-buffer)))))
(string-match "^[ \t]*File" (buffer-substring-no-properties (point) (line-end-position)))
(looking-at "[ \t]*File")
(replace-match " Buffer")))
(push origline py-error)
(push (buffer-name exception-buffer) py-error)
(forward-line 1)
(when (looking-at "[ \t]*\\([^\t\n\r\f]+\\)[ \t]*$")
(setq estring (match-string-no-properties 1))
(setq ecode (replace-regexp-in-string "[ \n\t\f\r^]+" " " estring))
(push 'py-error ecode))))))
py-error))
(defun py--find-next-exception-prepare (direction start)
"Setup exception regexps depending from kind of Python shell. "
(let* ((name (get-process (substring (buffer-name (current-buffer)) 1 -1)))
(buffer (cond (name (buffer-name (current-buffer)))
((buffer-live-p (get-buffer py-output-buffer))
py-output-buffer)
(py-last-exeption-buffer (buffer-name py-last-exeption-buffer))
(t (error "Don't see exeption buffer")))))
(when buffer (set-buffer (get-buffer buffer)))
(if (eq direction 'up)
(if (string= start "TOP")
(py--find-next-exception 'bob buffer 're-search-forward "Top")
(py--find-next-exception 'bol buffer 're-search-backward "Top"))
(if (string= start "BOTTOM")
(py--find-next-exception 'eob buffer 're-search-backward "Bottom")
(py--find-next-exception 'eol buffer 're-search-forward "Bottom")))))
(defalias 'ipython-send-and-indent 'py-execute-line-ipython)
(defalias 'py-execute-region-in-shell 'py-execute-region)
(defalias 'py-ipython-shell-command-on-region 'py-execute-region-ipython)
(defalias 'py-shell-command-on-region 'py-execute-region)
(defalias 'py-send-region-ipython 'py-execute-region-ipython)
;; python-components-send
(defun py-output-buffer-filter (&optional beg end)
"Clear output buffer from py-shell-input prompt etc. "
(interactive "*")
(let ((beg (cond (beg)
((use-region-p)
(region-beginning))
(t (point-min))))
(end (cond (end (copy-marker end))
((use-region-p)
(copy-marker (region-end)))
(t (copy-marker (point-max))))))
(goto-char beg)
(while (re-search-forward (concat "\\(" py-shell-input-prompt-1-regexp "\\|" py-shell-input-prompt-2-regexp "\\|" "^In \\[[0-9]+\\]: *" "\\)") end (quote move) 1)
(replace-match ""))
(goto-char beg)))
(defun py-output-filter (strg)
"Clear output buffer from py-shell-input prompt etc. "
(interactive "*")
(let (erg)
(while
(not (equal erg (setq erg (replace-regexp-in-string
(concat "\\(\n\\|" py-shell-input-prompt-1-regexp "\\|"
py-shell-input-prompt-2-regexp "\\|" "^In \\[[0-9]+\\]: *" "\\)") "" strg))))
(sit-for 0.1 t))
erg))
(defun py-send-string (strg &optional process)
"Evaluate STRING in Python process."
(interactive "sPython command: ")
(let* ((proc (or process (get-buffer-process (py-shell))))
(buffer (process-buffer proc)))
(with-current-buffer buffer
(goto-char (point-max))
(unless (string-match "\\`" strg)
(comint-send-string proc "\n"))
(comint-send-string proc strg)
(goto-char (point-max))
(unless (string-match "\n\\'" strg)
;; Make sure the text is properly LF-terminated.
(comint-send-string proc "\n"))
;; (when py-debug-p (message "%s" (current-buffer)))
(goto-char (point-max)))))
;; python-components-shell-complete
(defalias 'py-script-complete 'py-shell-complete)
(defalias 'py-python2-shell-complete 'py-shell-complete)
(defalias 'py-python3-shell-complete 'py-shell-complete)
(defun py--shell-completion-get-completions (input process completion-code)
"Retrieve available completions for INPUT using PROCESS.
Argument COMPLETION-CODE is the python code used to get
completions on the current context."
(let ((erg
(py--send-string-return-output
(format completion-code input) process)))
(sit-for 0.2 t)
(when (and erg (> (length erg) 2))
(setq erg (split-string erg "^'\\|^\"\\|;\\|'$\\|\"$" t)))
erg))
;; post-command-hook
;; caused insert-file-contents error lp:1293172
(defun py--after-change-function (end)
"Restore window-confiuration after completion. "
(when
(and (or
(eq this-command 'completion-at-point)
(eq this-command 'choose-completion)
(eq this-command 'choose-completion)
(eq this-command 'py-shell-complete)
(and (or
(eq last-command 'completion-at-point)
(eq last-command 'choose-completion)
(eq last-command 'choose-completion)
(eq last-command 'py-shell-complete))
(eq this-command 'self-insert-command))))
(set-window-configuration
py-last-window-configuration))
(goto-char end))
(defalias 'ipython-complete 'py-shell-complete)
(defun py--try-completion-intern (input completion)
(let (erg)
(when (and (stringp (setq erg (try-completion input completion)))
(looking-back input (line-beginning-position))
(not (string= input erg)))
(delete-region (match-beginning 0) (match-end 0))
(insert erg))
erg))
(defun py--try-completion (input completion)
"Repeat `try-completion' as long as matches are found. "
(let (erg newlist)
(setq erg (py--try-completion-intern input completion))
(when erg
(dolist (elt completion)
(unless (string= erg elt)
(push elt newlist)))
(if (< 1 (length newlist))
(with-output-to-temp-buffer py-python-completions
(display-completion-list
(all-completions input (or newlist completion))))
(when newlist (py--try-completion erg newlist)))
(skip-chars-forward "^ \t\r\n\f")
;; (move-marker orig (point))
nil)))
(defun py--shell-insert-completion-maybe (completion input)
(cond ((eq completion t)
(and py-verbose-p (message "py--shell-do-completion-at-point %s" "`t' is returned, not completion. Might be a bug."))
nil)
((or (null completion)
(and completion (stringp completion)
(or
(string-match "\\`''\\'" completion)
(string= "" completion))))
(and py-verbose-p (message "py--shell-do-completion-at-point %s" "Don't see a completion"))
nil)
((and completion
(or (and (listp completion)
(string= input (car completion)))
(and (stringp completion)
(string= input completion))))
nil)
((and completion (stringp completion)(not (string= input completion)))
(progn (delete-char (- (length input)))
(insert completion)
;; (move-marker orig (point))
;; minibuffer.el expects a list, a bug IMO
nil))
(t (py--try-completion input completion)))
nil)
(defun py--shell-do-completion-at-point (process imports input exception-buffer code)
"Do completion at point for PROCESS."
;; (py--send-string-no-output py-shell-completion-setup-code process)
(when imports
(py--send-string-no-output imports process))
;; (py--delay-process-dependent process)
(sit-for 0.1 t)
(let* ((completion
(py--shell-completion-get-completions
input process code)))
(set-buffer exception-buffer)
;; (py--delay-process-dependent process)
;; (sit-for 1 t)
(py--shell-insert-completion-maybe completion input)))
(defun py--complete-base (shell word imports exception-buffer)
(let* ((shell (or shell (py-choose-shell)))
(proc (or
;; completing inside a shell
(get-buffer-process exception-buffer)
(and (comint-check-proc shell)
(get-process shell))
(prog1
(get-buffer-process (py-shell nil nil shell))
(sit-for py-new-shell-delay))))
(code (if (string-match "[Ii][Pp]ython*" shell)
(py-set-ipython-completion-command-string shell)
py-shell-module-completion-code)))
(py--shell-do-completion-at-point proc imports word exception-buffer code)))
(defun py--complete-prepare (&optional shell beg end word fast-complete)
(let* ((exception-buffer (current-buffer))
(pos (copy-marker (point)))
(pps (parse-partial-sexp (or (ignore-errors (overlay-end comint-last-prompt-overlay))(line-beginning-position)) (point)))
(in-string (when (nth 3 pps) (nth 8 pps)))
(beg
(save-excursion
(or beg
(and in-string
;; possible completion of filenames
(progn
(goto-char in-string)
(and
(save-excursion
(skip-chars-backward "^ \t\r\n\f")(looking-at "open")))
(skip-chars-forward "\"'")(point)))
(progn (and (eq (char-before) ?\()(forward-char -1))
(skip-chars-backward "a-zA-Z0-9_.'") (point)))))
(end (or end (point)))
;;
(word (or word (buffer-substring-no-properties beg end)))
(ausdruck (and (string-match "^/" word)(setq word (substring-no-properties word 1))(concat "\"" word "*\"")))
;; when in string, assume looking for filename
(filenames (and in-string ausdruck
(list (replace-regexp-in-string "\n" "" (shell-command-to-string (concat "find / -maxdepth 1 -name " ausdruck))))))
(imports (py-find-imports))
py-fontify-shell-buffer-p erg)
(cond (fast-complete (py--fast-complete-base shell pos word imports exception-buffer))
((and in-string filenames)
(when (setq erg (try-completion (concat "/" word) filenames))
(delete-region beg end)
(insert erg)))
(t (py--complete-base shell word imports exception-buffer)))
nil))
(defun py-shell-complete (&optional shell beg end word)
"Complete word before point, if any. "
(interactive)
(save-excursion
(and (buffer-live-p (get-buffer "*Python Completions*"))
(py-kill-buffer-unconditional "*Python Completions*")))
(setq py-last-window-configuration
(current-window-configuration))
(py--complete-prepare shell beg end word nil))
(defun py-indent-or-complete ()
"Complete or indent depending on the context.
If cursor is at end of a symbol, try to complete
Otherwise call `py-indent-line'
If `(use-region-p)' returns `t', indent region.
Use `C-q TAB' to insert a literally TAB-character
In python-mode `py-complete-function' is called,
in (I)Python shell-modes `py-shell-complete'"
(interactive "*")
(cond ((use-region-p)
(py-indent-region (region-beginning) (region-end)))
((or (bolp)
(member (char-before)(list 9 10 12 13 32 ?: ?\) ?\] ?\}))
(not (looking-at "[ \t]*$")))
;; (not (eolp)))
(py-indent-line))
((eq major-mode 'python-mode)
(if (string-match "ipython" (py-choose-shell))
(py-shell-complete)
(funcall py-complete-function)))
((comint-check-proc (current-buffer))
(py-shell-complete (process-name (get-buffer-process (current-buffer)))))
(t
(funcall py-complete-function))))
;; python-components-pdb
;; pdbtrack constants
(defconst py-pdbtrack-stack-entry-regexp
(concat ".*\\("py-shell-input-prompt-1-regexp">\\|>\\) *\\(.*\\)(\\([0-9]+\\))\\([?a-zA-Z0-9_<>()]+\\)()")
"Regular expression pdbtrack uses to find a stack trace entry.")
(defconst py-pdbtrack-marker-regexp-file-group 2
"Group position in gud-pydb-marker-regexp that matches the file name.")
(defconst py-pdbtrack-marker-regexp-line-group 3
"Group position in gud-pydb-marker-regexp that matches the line number.")
(defconst py-pdbtrack-marker-regexp-funcname-group 4
"Group position in gud-pydb-marker-regexp that matches the function name.")
(defconst py-pdbtrack-track-range 10000
"Max number of characters from end of buffer to search for stack entry.")
(defvar py-pdbtrack-is-tracking-p nil)
(defun py--pdbtrack-overlay-arrow (activation)
"Activate or de arrow at beginning-of-line in current buffer."
;; This was derived/simplified from edebug-overlay-arrow
(cond (activation
(setq overlay-arrow-position (make-marker))
(setq overlay-arrow-string "=>")
(set-marker overlay-arrow-position (line-beginning-position) (current-buffer))
(setq py-pdbtrack-is-tracking-p t))
(overlay-arrow-position
(setq overlay-arrow-position nil)
(setq py-pdbtrack-is-tracking-p nil))))
(defun py--pdbtrack-track-stack-file (text)
"Show the file indicated by the pdb stack entry line, in a separate window.
Activity is disabled if the buffer-local variable
`py-pdbtrack-do-tracking-p' is nil.
We depend on the pdb input prompt matching `py-pdbtrack-input-prompt'
at the beginning of the line.
If the traceback target file path is invalid, we look for the most
recently visited python-mode buffer which either has the name of the
current function \(or class) or which defines the function \(or
class). This is to provide for remote scripts, eg, Zope's 'Script
\(Python)' - put a _copy_ of the script in a buffer named for the
script, and set to python-mode, and pdbtrack will find it.)"
;; Instead of trying to piece things together from partial text
;; (which can be almost useless depending on Emacs version), we
;; monitor to the point where we have the next pdb prompt, and then
;; check all text from comint-last-input-end to process-mark.
;;
;; Also, we're very conservative about clearing the overlay arrow,
;; to minimize residue. This means, for instance, that executing
;; other pdb commands wipe out the highlight. You can always do a
;; 'where' (aka 'w') command to reveal the overlay arrow.
(let* ((origbuf (current-buffer))
(currproc (get-buffer-process origbuf)))
(if (not (and currproc py-pdbtrack-do-tracking-p))
(py--pdbtrack-overlay-arrow nil)
(let* ((procmark (process-mark currproc))
(block (buffer-substring (max comint-last-input-end
(- procmark
py-pdbtrack-track-range))
procmark))
target target_fname target_lineno target_buffer)
(if (not (string-match (concat py-pdbtrack-input-prompt "$") block))
(py--pdbtrack-overlay-arrow nil)
(setq target (py--pdbtrack-get-source-buffer block))
(if (stringp target)
(message "pdbtrack: %s" target)
(setq target_lineno (car target))
(setq target_buffer (cadr target))
(setq target_fname
(py--buffer-filename-remote-maybe target_buffer))
(switch-to-buffer-other-window target_buffer)
(goto-char (point-min))
(forward-line (1- target_lineno))
(message "pdbtrack: line %s, file %s" target_lineno target_fname)
(py--pdbtrack-overlay-arrow t)
(pop-to-buffer origbuf t)))))))
(defun py--pdbtrack-map-filename (filename)
(let
((replacement-val (assoc-default
filename py-pdbtrack-filename-mapping
(lambda (mapkey path)
(string-match
(concat "^" (regexp-quote mapkey))
path)))
))
(if (not (eq replacement-val nil))
(replace-match replacement-val 't 't filename)
filename)))
(defun py--pdbtrack-get-source-buffer (block)
"Return line number and buffer of code indicated by block's traceback text.
We look first to visit the file indicated in the trace.
Failing that, we look for the most recently visited python-mode buffer
with the same name or having the named function.
If we're unable find the source code we return a string describing the
problem as best as we can determine."
(if (and (not (string-match py-pdbtrack-stack-entry-regexp block))
;; pydb integration still to be done
;; (not (string-match py-pydbtrack-stack-entry-regexp block))
)
"Traceback cue not found"
(let* ((filename (match-string
py-pdbtrack-marker-regexp-file-group block))
(lineno (string-to-number (match-string
py-pdbtrack-marker-regexp-line-group
block)))
(funcname (match-string py-pdbtrack-marker-regexp-funcname-group
block))
funcbuffer)
(cond ((file-exists-p filename)
(list lineno (find-file-noselect filename)))
((file-exists-p (py--pdbtrack-map-filename filename))
(list lineno (find-file-noselect (py--pdbtrack-map-filename filename))))
((setq funcbuffer (py--pdbtrack-grub-for-buffer funcname lineno))
(if (string-match "/Script (Python)$" filename)
;; Add in number of lines for leading '##' comments:
(setq lineno
(+ lineno
(save-excursion
(with-current-buffer funcbuffer
(count-lines
(point-min)
(max (point-min)
(string-match "^\\([^#]\\|#[^#]\\|#$\\)"
(buffer-substring (point-min)
(point-max))))))))))
(list lineno funcbuffer))
((= (elt filename 0) ?\<)
(format "(Non-file source: '%s')" filename))
(t (format "Not found: %s(), %s" funcname filename))))))
(defun py--pdbtrack-grub-for-buffer (funcname lineno)
"Find most recent buffer itself named or having function funcname.
We walk the buffer-list history for python-mode buffers that are
named for funcname or define a function funcname."
(let ((buffers (buffer-list))
buf
got)
(while (and buffers (not got))
(setq buf (car buffers)
buffers (cdr buffers))
(if (and (save-excursion
(with-current-buffer buf
(string= major-mode "python-mode")))
(or (string-match funcname (buffer-name buf))
(string-match (concat "^\\s-*\\(def\\|class\\)\\s-+"
funcname "\\s-*(")
(save-excursion
(with-current-buffer buf
(buffer-substring (point-min)
(point-max)))))))
(setq got buf)))
got))
;; pdbtrack functions
(defun py-pdbtrack-toggle-stack-tracking (arg)
"Set variable `py-pdbtrack-do-tracking-p'. "
(interactive "P")
;; (if (not (get-buffer-process (current-buffer)))
;; (error "No process associated with buffer '%s'" (current-buffer)))
;; missing or 0 is toggle, >0 turn on, <0 turn off
(cond ((not arg)
(setq py-pdbtrack-do-tracking-p (not py-pdbtrack-do-tracking-p)))
((zerop (prefix-numeric-value arg))
(setq py-pdbtrack-do-tracking-p nil))
((> (prefix-numeric-value arg) 0)
(setq py-pdbtrack-do-tracking-p t)))
(if py-pdbtrack-do-tracking-p
(progn
(add-hook 'comint-output-filter-functions 'py--pdbtrack-track-stack-file t)
(remove-hook 'comint-output-filter-functions 'python-pdbtrack-track-stack-file t))
(remove-hook 'comint-output-filter-functions 'py--pdbtrack-track-stack-file t)
)
(message "%sabled Python's pdbtrack"
(if py-pdbtrack-do-tracking-p "En" "Dis")))
(defun turn-on-pdbtrack ()
(interactive)
(py-pdbtrack-toggle-stack-tracking 1))
(defun turn-off-pdbtrack ()
(interactive)
(py-pdbtrack-toggle-stack-tracking 0))
(defun py-execute-statement-pdb ()
"Execute statement running pdb. "
(interactive)
(let ((py-python-command-args "-i -m pdb"))
(py-execute-statement)))
(defun py-execute-region-pdb (beg end)
(interactive "r")
(let ((py-python-command-args "-i -m pdb")))
(py-execute-region beg end))
(defun py-pdb-execute-statement ()
(interactive)
(let ((stm (progn (py-statement) (car kill-ring))))
(py-execute-string (concat "import pdb;pdb.run('" stm "')"))))
(defun py-pdb-help ()
"Print generic pdb.help() message "
(interactive)
(py-execute-string "import pdb;pdb.help()"))
(defun py-pdb-break (&optional line file condition)
(interactive)
(py-execute-string (concat "import pdb;pdb.break('" stm "')")))
(defun py--pdb-versioned ()
"Guess existing pdb version from py-shell-name
Return \"pdb[VERSION]\" if executable found, just \"pdb\" otherwise"
(interactive)
(let ((erg (when (string-match "[23]" py-shell-name)
;; versions-part
(substring py-shell-name (string-match "[23]" py-shell-name)))))
(if erg
(cond ((executable-find (concat "pdb" erg))
(concat "pdb" erg))
((and (string-match "\\." erg)
(executable-find (concat "pdb" (substring erg 0 (string-match "\\." erg)))))
(concat "pdb" (substring erg 0 (string-match "\\." erg)))))
"pdb")))
(defun py-pdb (command-line)
"Run pdb on program FILE in buffer `*gud-FILE*'.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
At GNU Linux systems required pdb version should be detected by `py--pdb-version', at Windows configure `py-python-ms-pdb-command'
lp:963253"
(interactive
(progn
(require 'gud)
(list (gud-query-cmdline
(if (or (eq system-type 'ms-dos)(eq system-type 'windows-nt))
(car (read-from-string py-python-ms-pdb-command))
;; sys.version_info[0]
;; (car (read-from-string (py--pdb-version)))
'pdb)
(py--buffer-filename-remote-maybe)))))
(pdb command-line))
(defun py--pdb-current-executable ()
"When py-pdb-executable is set, return it.
Otherwise return resuslt from `executable-find' "
(or py-pdb-executable
(executable-find "pdb")))
(defun py-update-gud-pdb-history ()
"If pdb is called at a Python buffer, put it's file name at the head of `gud-pdb-history'. "
(interactive)
(let* (;; PATH/TO/pdb
(first (cond ((and gud-pdb-history (ignore-errors (car gud-pdb-history)))
(replace-regexp-in-string "^\\([^ ]+\\) +.+$" "\\1" (car gud-pdb-history)))
(py-pdb-executable
py-pdb-executable)
((or (eq system-type 'ms-dos)(eq system-type 'windows-nt))
;; lp:963253
"c:/python27/python\ -i\ c:/python27/Lib/pdb.py")
(t
(py--pdb-current-executable))))
;; file to debug
(second (cond ((not (ignore-errors
(py--buffer-filename-remote-maybe)))
(error "%s" "Buffer must be saved first."))
((py--buffer-filename-remote-maybe))
(t (and gud-pdb-history (stringp (car gud-pdb-history)) (replace-regexp-in-string "^\\([^ ]+\\) +\\(.+\\)$" "\\2" (car gud-pdb-history))))))
(erg (and first second (concat first " " second))))
(when erg
(push erg gud-pdb-history))))
(defadvice pdb (before gud-query-cmdline activate)
"Provide a better default command line when called interactively."
(interactive
(list (gud-query-cmdline py-pdb-path
;; (file-name-nondirectory buffer-file-name)
(file-name-nondirectory (py--buffer-filename-remote-maybe))
))))
;; python-components-help
(defvar py-eldoc-string-code
"__PYDOC_get_help('''%s''')\n"
"Python code used to get a string with the documentation of an object.")
(defalias 'py-eldoc 'py-eldoc-function)
;; Info-look functionality.
(require 'info-look)
(eval-when-compile (require 'info))
(defun py-info-lookup-symbol ()
(interactive)
"Calls `info-lookup-symbol'.
Sends help if stuff is missing. "
(if (functionp 'pydoc-info-add-help)
(call-interactively 'info-lookup-symbol)
(message "pydoc-info-add-help not found. Please check INSTALL-INFO-FILES")))
(info-lookup-add-help
:mode 'python-mode
:regexp "[[:alnum:]_]+"
:doc-spec
'(("(python)Index" nil "")))
(defun python-after-info-look ()
"Set up info-look for Python.
Tries to take account of versioned Python Info files, e.g. Debian's
python2.5-ref.info.gz.
Used with `eval-after-load'."
(let* ((version (let ((s (shell-command-to-string (concat py-python-command
" -V"))))
(string-match "^Python \\([0-9]+\\.[0-9]+\\>\\)" s)
(match-string 1 s)))
;; Whether info files have a Python version suffix, e.g. in Debian.
(versioned
(with-temp-buffer
(Info-mode)
;; First look for Info files corresponding to the version
;; of the interpreter we're running.
(condition-case ()
;; Don't use `info' because it would pop-up a *info* buffer.
(progn
(Info-goto-node (format "(python%s-lib)Miscellaneous Index"
version))
t)
(error
;; Otherwise see if we actually have an un-versioned one.
(condition-case ()
(progn
(Info-goto-node
(format "(python-lib)Miscellaneous Index" version))
nil)
(error
;; Otherwise look for any versioned Info file.
(condition-case ()
(let (found)
(dolist (dir (or Info-directory-list
Info-default-directory-list))
(unless found
(let ((file (car (file-expand-wildcards
(expand-file-name "python*-lib*"
dir)))))
(if (and file
(string-match
"\\\\)-"
file))
(setq version (match-string 1 file)
found t)))))
found)
(error)))))))))
(info-lookup-maybe-add-help
:mode 'python-mode
:regexp "[[:alnum:]_]+"
:doc-spec
;; Fixme: Can this reasonably be made specific to indices with
;; different rules? Is the order of indices optimal?
;; (Miscellaneous in -ref first prefers lookup of keywords, for
;; instance.)
(if versioned
;; The empty prefix just gets us highlighted terms.
`((,(concat "(python" version "-ref)Miscellaneous Index"))
(,(concat "(python" version "-ref)Module Index"))
(,(concat "(python" version "-ref)Function-Method-Variable Index"))
(,(concat "(python" version "-ref)Class-Exception-Object Index"))
(,(concat "(python" version "-lib)Module Index"))
(,(concat "(python" version "-lib)Class-Exception-Object Index"))
(,(concat "(python" version "-lib)Function-Method-Variable Index"))
(,(concat "(python" version "-lib)Miscellaneous Index")))
'(("(python-ref)Miscellaneous Index")
("(python-ref)Module Index")
("(python-ref)Function-Method-Variable Index")
("(python-ref)Class-Exception-Object Index")
("(python-lib)Module Index")
("(python-lib)Class-Exception-Object Index")
("(python-lib)Function-Method-Variable Index")
("(python-lib)Miscellaneous Index"))))))
;; (if (featurep 'info-look)
;; (python-after-info-look))
;; (eval-after-load "info-look" '(python-after-info-look))
;; ;
(defun py--warn-tmp-files-left ()
"Detect and warn about file of form \"py11046IoE\" in py-temp-directory. "
(let ((erg1 (file-readable-p (concat py-temp-directory (char-to-string py-separator-char) (car (directory-files py-temp-directory nil "py[[:alnum:]]+$"))))))
(when (and py-verbose-p erg1)
(message "py--warn-tmp-files-left: %s ?" (concat py-temp-directory (char-to-string py-separator-char) (car (directory-files py-temp-directory nil "py[[:alnum:]]*$")))))))
(defun py-fetch-docu ()
"Lookup in current buffer for the doku for the symbol at point.
Useful for newly defined symbol, not known to python yet. "
(interactive)
(let* ((symb (prin1-to-string (symbol-at-point)))
erg)
(save-restriction
(widen)
(goto-char (point-min))
(when (re-search-forward (concat py-def-or-class-re " *" symb) nil (quote move) 1)
(forward-line 1)
(when (looking-at "[ \t]*\"\"\"\\|[ \t]*'''\\|[ \t]*'[^]+\\|[ \t]*\"[^\"]+")
(goto-char (match-end 0))
(setq erg (buffer-substring-no-properties (match-beginning 0) (re-search-forward "\"\"\"\\|'''" nil 'move)))
(when erg
(set-buffer (get-buffer-create "*Python-Help*"))
(erase-buffer)
(when (called-interactively-p 'any) (switch-to-buffer (current-buffer)))
(insert erg)))))))
(defun py-info-current-defun (&optional include-type)
"Return name of surrounding function with Python compatible dotted expression syntax.
Optional argument INCLUDE-TYPE indicates to include the type of the defun.
This function is compatible to be used as
`add-log-current-defun-function' since it returns nil if point is
not inside a defun."
(interactive)
(let ((names '())
(min-indent)
(first-run t))
(save-restriction
(widen)
(save-excursion
(goto-char (line-end-position))
(forward-comment -9999)
(setq min-indent (current-indentation))
(while (py-beginning-of-def-or-class)
(when (or (< (current-indentation) min-indent)
first-run)
(setq first-run nil)
(setq min-indent (current-indentation))
(looking-at py-def-or-class-re)
(setq names (cons
(if (not include-type)
(match-string-no-properties 1)
(mapconcat 'identity
(split-string
(match-string-no-properties 0)) " "))
names))))))
(when names
(mapconcat (lambda (strg) strg) names "."))))
(defalias 'py-describe-symbol 'py-help-at-point)
(defalias 'py-eldoc-function 'py-help-at-point)
(defun py--help-at-point-intern (orig)
(let* ((beg (point))
(end (progn (skip-chars-forward "a-zA-Z0-9_." (line-end-position))(point)))
(sym (buffer-substring-no-properties beg end))
(origfile (py--buffer-filename-remote-maybe))
(temp (md5 (buffer-name)))
(file (concat (py--normalize-directory py-temp-directory) temp "-py-help-at-point.py"))
(cmd (py-find-imports))
;; if symbol is defined in current buffer, go to
(erg (progn (goto-char (point-min))
(when
(re-search-forward (concat "^[ \t]*def " sym "(") nil t 1)
(forward-char -2)
(point)))))
(if erg
(progn (push-mark orig)(push-mark (point))
(when (and (called-interactively-p 'any) py-verbose-p) (message "Jump to previous position with %s" "C-u C- C-u C-")))
(goto-char orig))
;; (when cmd
;; (setq cmd (mapconcat
;; (lambda (arg) (concat "try: " arg "\nexcept: pass\n"))
;; (split-string cmd ";" t)
;; "")))
(setq cmd (concat cmd "\nimport pydoc\n"
))
(when (not py-remove-cwd-from-path)
(setq cmd (concat cmd "import sys\n"
"sys.path.insert(0, '"
(file-name-directory origfile) "')\n")))
(setq cmd (concat cmd "pydoc.help('" sym "')\n"))
(with-temp-buffer
(insert cmd)
(write-file file))
(py-process-file file "*Python-Help*")
(when (file-readable-p file)
(unless py-debug-p (delete-file file)))))
(defun py-help-at-point ()
"Print help on symbol at point.
If symbol is defined in current buffer, jump to it's definition"
(interactive)
(let ((orig (point)))
;; avoid repeated call at identic pos
(unless (eq orig (ignore-errors py-last-position))
(setq py-last-position orig))
(unless (member (get-buffer-window "*Python-Help*")(window-list))
(window-configuration-to-register py-windows-config-register))
(and (looking-back "(" (line-beginning-position))(not (looking-at "\\sw")) (forward-char -1))
(if (or (not (face-at-point)) (eq (face-at-point) 'font-lock-string-face)(eq (face-at-point) 'font-lock-comment-face)(eq (face-at-point) 'default))
(progn
(py-restore-window-configuration)
(goto-char orig))
(if (or (< 0 (abs (skip-chars-backward "a-zA-Z0-9_." (line-beginning-position))))(looking-at "\\sw"))
(py--help-at-point-intern orig)
(py-restore-window-configuration)))))
;; Documentation functions
;; dump the long form of the mode blurb; does the usual doc escapes,
;; plus lines of the form ^[vc]:name\$ to suck variable & command docs
;; out of the right places, along with the keys they're on & current
;; values
(defun py--dump-help-string (str)
(with-output-to-temp-buffer "*Help*"
(let ((locals (buffer-local-variables))
funckind funcname func funcdoc
(start 0) mstart end
keys)
(while (string-match "^%\\([vc]\\):\\(.+\\)\n" str start)
(setq mstart (match-beginning 0) end (match-end 0)
funckind (substring str (match-beginning 1) (match-end 1))
funcname (substring str (match-beginning 2) (match-end 2))
func (intern funcname))
(princ (substitute-command-keys (substring str start mstart)))
(cond
((equal funckind "c") ; command
(setq funcdoc (documentation func)
keys (concat
"Key(s): "
(mapconcat 'key-description
(where-is-internal func python-mode-map)
", "))))
((equal funckind "v") ; variable
(setq funcdoc (documentation-property func 'variable-documentation)
keys (if (assq func locals)
(concat
"Local/Global values: "
(prin1-to-string (symbol-value func))
" / "
(prin1-to-string (default-value func)))
(concat
"Value: "
(prin1-to-string (symbol-value func))))))
(t ; unexpected
(error "Error in py--dump-help-string, tag `%s'" funckind)))
(princ (format "\n-> %s:\t%s\t%s\n\n"
(if (equal funckind "c") "Command" "Variable")
funcname keys))
(princ funcdoc)
(terpri)
(setq start end))
(princ (substitute-command-keys (substring str start)))
;; (and comint-vars-p (py-report-comint-variable-setting))
)
(if (featurep 'xemacs) (print-help-return-message)
(help-print-return-message))))
(defun py-describe-mode ()
"Dump long form of `python-mode' docs."
(interactive)
(py--dump-help-string "Major mode for editing Python files.
Knows about Python indentation, tokens, comments and continuation lines.
Paragraphs are separated by blank lines only.
Major sections below begin with the string `@'; specific function and
variable docs begin with `->'.
@EXECUTING PYTHON CODE
\\[py-execute-import-or-reload]\timports or reloads the file in the Python interpreter
\\[py-execute-buffer]\tsends the entire buffer to the Python interpreter
\\[py-execute-region]\tsends the current region
\\[py-execute-def-or-class]\tsends the current function or class definition
\\[py-execute-string]\tsends an arbitrary string
\\[py-shell]\tstarts a Python interpreter window; this will be used by
\tsubsequent Python execution commands
%c:py-execute-import-or-reload
%c:py-execute-buffer
%c:py-execute-region
%c:py-execute-def-or-class
%c:py-execute-string
%c:py-shell
@VARIABLES
py-install-directory\twherefrom `python-mode' looks for extensions
py-indent-offset\tindentation increment
py-block-comment-prefix\tcomment string used by comment-region
py-shell-name\tshell command to invoke Python interpreter
py-temp-directory\tdirectory used for temp files (if needed)
py-beep-if-tab-change\tring the bell if tab-width is changed
%v:py-install-directory
%v:py-indent-offset
%v:py-block-comment-prefix
%v:py-shell-name
%v:py-temp-directory
%v:py-beep-if-tab-change
@KINDS OF LINES
Each physical line in the file is either a `continuation line' (the
preceding line ends with a backslash that's not part of a comment, or
the paren/bracket/brace nesting level at the start of the line is
non-zero, or both) or an `initial line' (everything else).
An initial line is in turn a `blank line' (contains nothing except
possibly blanks or tabs), a `comment line' (leftmost non-blank
character is `#'), or a `code line' (everything else).
Comment Lines
Although all comment lines are treated alike by Python, Python mode
recognizes two kinds that act differently with respect to indentation.
An `indenting comment line' is a comment line with a blank, tab or
nothing after the initial `#'. The indentation commands (see below)
treat these exactly as if they were code lines: a line following an
indenting comment line will be indented like the comment line. All
other comment lines (those with a non-whitespace character immediately
following the initial `#') are `non-indenting comment lines', and
their indentation is ignored by the indentation commands.
Indenting comment lines are by far the usual case, and should be used
whenever possible. Non-indenting comment lines are useful in cases
like these:
\ta = b # a very wordy single-line comment that ends up being
\t #... continued onto another line
\tif a == b:
##\t\tprint 'panic!' # old code we've `commented out'
\t\treturn a
Since the `#...' and `##' comment lines have a non-whitespace
character following the initial `#', Python mode ignores them when
computing the proper indentation for the next line.
Continuation Lines and Statements
The `python-mode' commands generally work on statements instead of on
individual lines, where a `statement' is a comment or blank line, or a
code line and all of its following continuation lines (if any)
considered as a single logical unit. The commands in this mode
generally (when it makes sense) automatically move to the start of the
statement containing point, even if point happens to be in the middle
of some continuation line.
@INDENTATION
Primarily for entering new code:
\t\\[indent-for-tab-command]\t indent line appropriately
\t\\[py-newline-and-indent]\t insert newline, then indent
\t\\[py-electric-backspace]\t reduce indentation, or delete single character
Primarily for reindenting existing code:
\t\\[py-guess-indent-offset]\t guess py-indent-offset from file content; change locally
\t\\[universal-argument] \\[py-guess-indent-offset]\t ditto, but change globally
\t\\[py-indent-region]\t reindent region to match its context
\t\\[py-shift-left]\t shift line or region left by py-indent-offset
\t\\[py-shift-right]\t shift line or region right by py-indent-offset
Unlike most programming languages, Python uses indentation, and only
indentation, to specify block structure. Hence the indentation supplied
automatically by `python-mode' is just an educated guess: only you know
the block structure you intend, so only you can supply correct
indentation.
The \\[indent-for-tab-command] and \\[py-newline-and-indent] keys try to suggest plausible indentation, based on
the indentation of preceding statements. E.g., assuming
py-indent-offset is 4, after you enter
\tif a > 0: \\[py-newline-and-indent]
the cursor will be moved to the position of the `_' (_ is not a
character in the file, it's just used here to indicate the location of
the cursor):
\tif a > 0:
\t _
If you then enter `c = d' \\[py-newline-and-indent], the cursor will move
to
\tif a > 0:
\t c = d
\t _
`python-mode' cannot know whether that's what you intended, or whether
\tif a > 0:
\t c = d
\t_
was your intent. In general, `python-mode' either reproduces the
indentation of the (closest code or indenting-comment) preceding
statement, or adds an extra py-indent-offset blanks if the preceding
statement has `:' as its last significant (non-whitespace and non-
comment) character. If the suggested indentation is too much, use
\\[py-electric-backspace] to reduce it.
Continuation lines are given extra indentation. If you don't like the
suggested indentation, change it to something you do like, and Python-
mode will strive to indent later lines of the statement in the same way.
If a line is a continuation line by virtue of being in an unclosed
paren/bracket/brace structure (`list', for short), the suggested
indentation depends on whether the current line contains the first item
in the list. If it does, it's indented py-indent-offset columns beyond
the indentation of the line containing the open bracket. If you don't
like that, change it by hand. The remaining items in the list will mimic
whatever indentation you give to the first item.
If a line is a continuation line because the line preceding it ends with
a backslash, the third and following lines of the statement inherit their
indentation from the line preceding them. The indentation of the second
line in the statement depends on the form of the first (base) line: if
the base line is an assignment statement with anything more interesting
than the backslash following the leftmost assigning `=', the second line
is indented two columns beyond that `='. Else it's indented to two
columns beyond the leftmost solid chunk of non-whitespace characters on
the base line.
Warning: indent-region should not normally be used! It calls \\[indent-for-tab-command]
repeatedly, and as explained above, \\[indent-for-tab-command] can't guess the block
structure you intend.
%c:indent-for-tab-command
%c:py-newline-and-indent
%c:py-electric-backspace
The next function may be handy when editing code you didn't write:
%c:py-guess-indent-offset
The remaining `indent' functions apply to a region of Python code. They
assume the block structure (equals indentation, in Python) of the region
is correct, and alter the indentation in various ways while preserving
the block structure:
%c:py-indent-region
%c:py-shift-left
%c:py-shift-right
@MARKING & MANIPULATING REGIONS OF CODE
\\[py-mark-block]\t mark block of lines
\\[py-mark-def-or-class]\t mark smallest enclosing def
\\[universal-argument] \\[py-mark-def-or-class]\t mark smallest enclosing class
\\[comment-region]\t comment out region of code
\\[universal-argument] \\[comment-region]\t uncomment region of code
%c:py-mark-block
%c:py-mark-def-or-class
%c:comment-region
@MOVING POINT
\\[py-previous-statement]\t move to statement preceding point
\\[py-next-statement]\t move to statement following point
\\[py-goto-block-up]\t move up to start of current block
\\[py-beginning-of-def-or-class]\t move to start of def
\\[universal-argument] \\[py-beginning-of-def-or-class]\t move to start of class
\\[py-end-of-def-or-class]\t move to end of def
\\[universal-argument] \\[py-end-of-def-or-class]\t move to end of class
The first two move to one statement beyond the statement that contains
point. A numeric prefix argument tells them to move that many
statements instead. Blank lines, comment lines, and continuation lines
do not count as `statements' for these commands. So, e.g., you can go
to the first code statement in a file by entering
\t\\[beginning-of-buffer]\t to move to the top of the file
\t\\[py-next-statement]\t to skip over initial comments and blank lines
Or do `\\[py-previous-statement]' with a huge prefix argument.
%c:py-previous-statement
%c:py-next-statement
%c:py-goto-block-up
%c:py-beginning-of-def-or-class
%c:py-end-of-def-or-class
@LITTLE-KNOWN EMACS COMMANDS PARTICULARLY USEFUL IN PYTHON MODE
`\\[indent-new-comment-line]' is handy for entering a multi-line comment.
`\\[set-selective-display]' with a `small' prefix arg is ideally suited for viewing the
overall class and def structure of a module.
`\\[back-to-indentation]' moves point to a line's first non-blank character.
`\\[indent-relative]' is handy for creating odd indentation.
@OTHER EMACS HINTS
If you don't like the default value of a variable, change its value to
whatever you do like by putting a `setq' line in your .emacs file.
E.g., to set the indentation increment to 4, put this line in your
.emacs:
\t(setq py-indent-offset 4)
To see the value of a variable, do `\\[describe-variable]' and enter the variable
name at the prompt.
When entering a key sequence like `C-c C-n', it is not necessary to
release the CONTROL key after doing the `C-c' part -- it suffices to
press the CONTROL key, press and release `c' (while still holding down
CONTROL), press and release `n' (while still holding down CONTROL), &
then release CONTROL.
Entering Python mode calls with no arguments the value of the variable
`python-mode-hook', if that value exists and is not nil; for backward
compatibility it also tries `py-mode-hook'; see the `Hooks' section of
the Elisp manual for details.
Obscure: When python-mode is first loaded, it looks for all bindings
to newline-and-indent in the global keymap, and shadows them with
local bindings to py-newline-and-indent."))
;; (require 'info-look)
;; The info-look package does not always provide this function (it
;; appears this is the case with XEmacs 21.1)
(when (fboundp 'info-lookup-maybe-add-help)
(info-lookup-maybe-add-help
:mode 'python-mode
:regexp "[a-zA-Z0-9_]+"
:doc-spec '(("(python-lib)Module Index")
("(python-lib)Class-Exception-Object Index")
("(python-lib)Function-Method-Variable Index")
("(python-lib)Miscellaneous Index"))))
(defun py--find-definition-in-source (sourcefile symbol)
(called-interactively-p 'any) (message "sourcefile: %s" sourcefile)
(when (find-file sourcefile)
;; (if (stringp py-separator-char)
;; py-separator-char
;; (char-to-string py-separator-char))
(goto-char (point-min))
(when
(or (re-search-forward (concat py-def-or-class-re symbol) nil t 1)
(progn
;; maybe a variable definition?
(goto-char (point-min))
(re-search-forward (concat "^.+ " symbol) nil t 1)))
(push-mark)
(goto-char (match-beginning 0))
(exchange-point-and-mark))))
;; Find function stuff, lifted from python.el
(defalias 'py-find-function 'py-find-definition)
(defun py--find-definition-question-type (symbol imports)
(let (erg)
(cond ((setq erg (py--send-string-return-output (concat "import inspect;inspect.isbuiltin(\"" symbol "\")"))))
(t (setq erg (py--send-string-return-output (concat imports "import inspect;inspect.getmodule(\"" symbol "\")")))))
erg))
(defun py-find-definition (&optional symbol)
"Find source of definition of SYMBOL.
Interactively, prompt for SYMBOL."
(interactive)
;; (set-register 98888888 (list (current-window-configuration) (point-marker)))
(let* ((last-window-configuration
(current-window-configuration))
(py-exception-buffer (current-buffer))
(imports (py-find-imports))
(symbol (or symbol (with-syntax-table py-dotted-expression-syntax-table
(current-word))))
(enable-recursive-minibuffers t)
(symbol
(if (called-interactively-p 'any)
(read-string (if symbol
(format "Find location of (default %s): " symbol)
"Find location of: ")
nil nil symbol)
symbol))
(local (or
(py--until-found (concat "class " symbol) imenu--index-alist)
(py--until-found symbol imenu--index-alist)))
erg sourcefile)
;; ismethod(), isclass(), isfunction() or isbuiltin()
;; ismethod isclass isfunction isbuiltin)
(if local
(if (numberp local)
(progn
(goto-char local)
(search-forward symbol (line-end-position) nil 1)
(push-mark)
(setq erg (buffer-substring-no-properties (line-beginning-position) (match-end 0)))
(goto-char (match-beginning 0))
(exchange-point-and-mark))
(error "%s" "local not a number"))
(setq erg (py--find-definition-question-type symbol imports))
(cond ((string-match "SyntaxError" erg)
(setq erg (substring-no-properties erg (match-beginning 0)))
(set-window-configuration last-window-configuration)
;; (jump-to-register 98888888)
(message "Can't get source: %s" erg))
((and erg (string-match "builtin" erg))
(progn
(set-window-configuration last-window-configuration)
;; (jump-to-register 98888888)
(message "%s" erg)))
((and erg (setq erg (replace-regexp-in-string "'" "" (py--send-string-return-output "import os;os.getcwd()")))
(setq sourcefile (replace-regexp-in-string "'" "" (py--send-string-return-output (concat "inspect.getsourcefile(" symbol ")")))))
(message "%s" sourcefile)
(py--find-definition-in-source sourcefile symbol)
(display-buffer py-exception-buffer))))
erg))
(defun py-find-imports ()
"Find top-level imports.
Returns imports "
(interactive)
(let (imports erg)
(save-excursion
(if (eq major-mode 'comint-mode)
(progn
(re-search-backward comint-prompt-regexp nil t 1)
(goto-char (match-end 0))
(while (re-search-forward
"import *[A-Za-z_][A-Za-z_0-9].*\\|^from +[A-Za-z_][A-Za-z_0-9.]+ +import .*" nil t)
(setq imports
(concat
imports
(replace-regexp-in-string
"[\\]\r?\n?\s*" ""
(buffer-substring-no-properties (match-beginning 0) (point))) ";")))
(when (ignore-errors (string-match ";" imports))
(setq imports (split-string imports ";" t))
(dolist (ele imports)
(and (string-match "import" ele)
(if erg
(setq erg (concat erg ";" ele))
(setq erg ele)))
(setq imports erg))))
(goto-char (point-min))
(while (re-search-forward
"^import *[A-Za-z_][A-Za-z_0-9].*\\|^from +[A-Za-z_][A-Za-z_0-9.]+ +import .*" nil t)
(unless (py--end-of-statement-p)
(py-forward-statement))
(setq imports
(concat
imports
(replace-regexp-in-string
"[\\]\r*\n*\s*" ""
(buffer-substring-no-properties (match-beginning 0) (point))) ";")))))
;; (and imports
;; (setq imports (replace-regexp-in-string ";$" "" imports)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" imports))
imports))
(defun py-update-imports ()
"Returns imports.
Imports done are displayed in message buffer. "
(interactive)
(save-excursion
(let ((py-exception-buffer (current-buffer))
(orig (point))
(erg (py-find-imports)))
;; (mapc 'py-execute-string (split-string (car (read-from-string (py-find-imports))) "\n" t)))
;; (setq erg (car (read-from-string python-imports)))
(goto-char orig)
(when (called-interactively-p 'any)
(switch-to-buffer (current-buffer))
(message "%s" erg))
erg)))
;; Code-Checker
;; pep8
(defalias 'pep8 'py-pep8-run)
(defun py-pep8-run (command)
"*Run pep8, check formatting - default on the file currently visited."
(interactive
(let ((default
(if (py--buffer-filename-remote-maybe)
(format "%s %s %s" py-pep8-command
(mapconcat 'identity py-pep8-command-args " ")
(py--buffer-filename-remote-maybe))
(format "%s %s" py-pep8-command
(mapconcat 'identity py-pep8-command-args " "))))
(last (when py-pep8-history
(let* ((lastcmd (car py-pep8-history))
(cmd (cdr (reverse (split-string lastcmd))))
(newcmd (reverse (cons (py--buffer-filename-remote-maybe) cmd))))
(mapconcat 'identity newcmd " ")))))
(list
(if (fboundp 'read-shell-command)
(read-shell-command "Run pep8 like this: "
(if last
last
default)
'py-pep8-history)
(read-string "Run pep8 like this: "
(if last
last
default)
'py-pep8-history)))))
(save-some-buffers (not py-ask-about-save) nil)
(if (fboundp 'compilation-start)
;; Emacs.
(compilation-start command)
;; XEmacs.
(when (featurep 'xemacs)
(compile-internal command "No more errors"))))
(defun py-pep8-help ()
"Display pep8 command line help messages. "
(interactive)
(set-buffer (get-buffer-create "*pep8-Help*"))
(erase-buffer)
(shell-command "pep8 --help" "*pep8-Help*"))
;; Pylint
(defalias 'pylint 'py-pylint-run)
(defun py-pylint-run (command)
"Run pylint (default on the file currently visited).
For help see M-x pylint-help resp. M-x pylint-long-help.
Home-page: http://www.logilab.org/project/pylint "
(interactive
(let ((default (format "%s %s %s" py-pylint-command
(mapconcat 'identity py-pylint-command-args " ")
(py--buffer-filename-remote-maybe)))
(last (and py-pylint-history (car py-pylint-history))))
(list (funcall (if (fboundp 'read-shell-command)
'read-shell-command 'read-string)
"Run pylint like this: "
(or default last)
'py-pylint-history))))
(save-some-buffers (not py-ask-about-save))
(set-buffer (get-buffer-create "*Pylint*"))
(erase-buffer)
(unless (file-readable-p (car (cddr (split-string command))))
(message "Warning: %s" "pylint needs a file"))
(shell-command command "*Pylint*"))
(defalias 'pylint-help 'py-pylint-help)
(defun py-pylint-help ()
"Display Pylint command line help messages.
Let's have this until more Emacs-like help is prepared "
(interactive)
(set-buffer (get-buffer-create "*Pylint-Help*"))
(erase-buffer)
(shell-command "pylint --long-help" "*Pylint-Help*"))
(defalias 'pylint-doku 'py-pylint-doku)
(defun py-pylint-doku ()
"Display Pylint Documentation.
Calls `pylint --full-documentation'"
(interactive)
(set-buffer (get-buffer-create "*Pylint-Documentation*"))
(erase-buffer)
(shell-command "pylint --full-documentation" "*Pylint-Documentation*"))
;; Pyflakes
(defalias 'pyflakes 'py-pyflakes-run)
(defun py-pyflakes-run (command)
"*Run pyflakes (default on the file currently visited).
For help see M-x pyflakes-help resp. M-x pyflakes-long-help.
Home-page: http://www.logilab.org/project/pyflakes "
(interactive
(let ((default
(if (py--buffer-filename-remote-maybe)
(format "%s %s %s" py-pyflakes-command
(mapconcat 'identity py-pyflakes-command-args " ")
(py--buffer-filename-remote-maybe))
(format "%s %s" py-pyflakes-command
(mapconcat 'identity py-pyflakes-command-args " "))))
(last (when py-pyflakes-history
(let* ((lastcmd (car py-pyflakes-history))
(cmd (cdr (reverse (split-string lastcmd))))
(newcmd (reverse (cons (py--buffer-filename-remote-maybe) cmd))))
(mapconcat 'identity newcmd " ")))))
(list
(if (fboundp 'read-shell-command)
(read-shell-command "Run pyflakes like this: "
(if last
last
default)
'py-pyflakes-history)
(read-string "Run pyflakes like this: "
(if last
last
default)
'py-pyflakes-history)))))
(save-some-buffers (not py-ask-about-save) nil)
(if (fboundp 'compilation-start)
;; Emacs.
(compilation-start command)
;; XEmacs.
(when (featurep 'xemacs)
(compile-internal command "No more errors"))))
(defalias 'pyflakes-help 'py-pyflakes-help)
(defun py-pyflakes-help ()
"Display Pyflakes command line help messages.
Let's have this until more Emacs-like help is prepared "
(interactive)
;; (set-buffer (get-buffer-create "*Pyflakes-Help*"))
;; (erase-buffer)
(with-help-window "*Pyflakes-Help*"
(with-current-buffer standard-output
(insert " pyflakes [file-or-directory ...]
Pyflakes is a simple program which checks Python
source files for errors. It is similar to
PyChecker in scope, but differs in that it does
not execute the modules to check them. This is
both safer and faster, although it does not
perform as many checks. Unlike PyLint, Pyflakes
checks only for logical errors in programs; it
does not perform any checks on style.
All commandline arguments are checked, which
have to be either regular files or directories.
If a directory is given, every .py file within
will be checked.
When no commandline arguments are given, data
will be read from standard input.
The exit status is 0 when no warnings or errors
are found. When errors are found the exit status
is 2. When warnings (but no errors) are found
the exit status is 1.
Extracted from http://manpages.ubuntu.com/manpages/natty/man1/pyflakes.1.html"))))
;; Pyflakes-pep8
(defalias 'pyflakespep8 'py-pyflakespep8-run)
(defun py-pyflakespep8-run (command)
"*Run pyflakespep8, check formatting (default on the file currently visited).
"
(interactive
(let ((default
(if (py--buffer-filename-remote-maybe)
(format "%s %s %s" py-pyflakespep8-command
(mapconcat 'identity py-pyflakespep8-command-args " ")
(py--buffer-filename-remote-maybe))
(format "%s %s" py-pyflakespep8-command
(mapconcat 'identity py-pyflakespep8-command-args " "))))
(last (when py-pyflakespep8-history
(let* ((lastcmd (car py-pyflakespep8-history))
(cmd (cdr (reverse (split-string lastcmd))))
(newcmd (reverse (cons (py--buffer-filename-remote-maybe) cmd))))
(mapconcat 'identity newcmd " ")))))
(list
(if (fboundp 'read-shell-command)
(read-shell-command "Run pyflakespep8 like this: "
(if last
last
default)
'py-pyflakespep8-history)
(read-string "Run pyflakespep8 like this: "
(if last
last
default)
'py-pyflakespep8-history)))))
(save-some-buffers (not py-ask-about-save) nil)
(if (fboundp 'compilation-start)
;; Emacs.
(compilation-start command)
;; XEmacs.
(when (featurep 'xemacs)
(compile-internal command "No more errors"))))
(defun py-pyflakespep8-help ()
"Display pyflakespep8 command line help messages. "
(interactive)
(set-buffer (get-buffer-create "*pyflakespep8-Help*"))
(erase-buffer)
(shell-command "pyflakespep8 --help" "*pyflakespep8-Help*"))
;; Pychecker
;; hack for GNU Emacs
;; (unless (fboundp 'read-shell-command)
;; (defalias 'read-shell-command 'read-string))
(defun py-pychecker-run (command)
"*Run pychecker (default on the file currently visited)."
(interactive
(let ((default
(if (py--buffer-filename-remote-maybe)
(format "%s %s %s" py-pychecker-command
py-pychecker-command-args
(py--buffer-filename-remote-maybe))
(format "%s %s" py-pychecker-command py-pychecker-command-args)))
(last (when py-pychecker-history
(let* ((lastcmd (car py-pychecker-history))
(cmd (cdr (reverse (split-string lastcmd))))
(newcmd (reverse (cons (py--buffer-filename-remote-maybe) cmd))))
(mapconcat 'identity newcmd " ")))))
(list
(if (fboundp 'read-shell-command)
(read-shell-command "Run pychecker like this: "
(if last
last
default)
'py-pychecker-history)
(read-string "Run pychecker like this: "
(if last
last
default)
'py-pychecker-history)))))
(save-some-buffers (not py-ask-about-save) nil)
(if (fboundp 'compilation-start)
;; Emacs.
(compilation-start command)
;; XEmacs.
(when (featurep 'xemacs)
(compile-internal command "No more errors"))))
;; After `sgml-validate-command'.
(defun py-check-command (command)
"Check a Python file (default current buffer's file).
Runs COMMAND, a shell command, as if by `compile'.
See `py-check-command' for the default."
(interactive
(list (read-string "Checker command: "
(concat py-check-command " "
(let ((name (py--buffer-filename-remote-maybe)))
(if name
(file-name-nondirectory name)))))))
(require 'compile) ;To define compilation-* variables.
(save-some-buffers (not compilation-ask-about-save) nil)
(let ((compilation-error-regexp-alist
(cons '("(\\([^,]+\\), line \\([0-9]+\\))" 1 2)
compilation-error-regexp-alist)))
(compilation-start command)))
;; flake8
(defalias 'flake8 'py-flake8-run)
(defun py-flake8-run (command)
"Flake8 is a wrapper around these tools:
- PyFlakes
- pep8
- Ned Batchelder's McCabe script
It also adds features:
- files that contain this line are skipped::
# flake8: noqa
- lines that contain a ``# noqa`` comment at the end will not issue warnings.
- a Git and a Mercurial hook.
- a McCabe complexity checker.
- extendable through ``flake8.extension`` entry points."
(interactive
(let* ((py-flake8-command
(if (string= "" py-flake8-command)
(or (executable-find "flake8")
(error "Don't see \"flake8\" on your system.
Consider \"pip install flake8\" resp. visit \"pypi.python.org\""))
py-flake8-command))
(default
(if (py--buffer-filename-remote-maybe)
(format "%s %s %s" py-flake8-command
py-flake8-command-args
(py--buffer-filename-remote-maybe))
(format "%s %s" py-flake8-command
py-flake8-command-args)))
(last
(when py-flake8-history
(let* ((lastcmd (car py-flake8-history))
(cmd (cdr (reverse (split-string lastcmd))))
(newcmd (reverse (cons (py--buffer-filename-remote-maybe) cmd))))
(mapconcat 'identity newcmd " ")))))
(list
(if (fboundp 'read-shell-command)
(read-shell-command "Run flake8 like this: "
;; (if last
;; last
default
'py-flake8-history1)
(read-string "Run flake8 like this: "
(if last
last
default)
'py-flake8-history)))))
(save-some-buffers (not py-ask-about-save) nil)
(if (fboundp 'compilation-start)
;; Emacs.
(compilation-start command)
;; XEmacs.
(when (featurep 'xemacs)
(compile-internal command "No more errors"))))
(defun py-flake8-help ()
"Display flake8 command line help messages. "
(interactive)
(set-buffer (get-buffer-create "*flake8-Help*"))
(erase-buffer)
(shell-command "flake8 --help" "*flake8-Help*"))
;; from string-strip.el --- Strip CHARS from STRING
(defvar py-chars-before " \t\n\r\f"
"Used by `py--string-strip'")
(defvar py-chars-after " \t\n\r\f"
"Used by `py--string-strip'")
;; (setq strip-chars-before "[ \t\r\n]*")
(defun py--string-strip (str &optional chars-before chars-after)
"Return a copy of STR, CHARS removed.
`CHARS-BEFORE' and `CHARS-AFTER' default is \"[ \t\r\n]*\",
i.e. spaces, tabs, carriage returns, newlines and newpages. "
(let ((s-c-b (or chars-before
py-chars-before))
(s-c-a (or chars-after
py-chars-after))
(erg str))
(setq erg (replace-regexp-in-string s-c-b "" erg))
(setq erg (replace-regexp-in-string s-c-a "" erg))
erg))
(defun py-nesting-level (&optional pps)
"Accepts the output of `parse-partial-sexp'. "
(interactive)
(let* ((pps (or (ignore-errors (nth 0 pps))
(if (featurep 'xemacs)
(parse-partial-sexp (point-min) (point))
(parse-partial-sexp (point-min) (point)))))
(erg (nth 0 pps)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
;; ffap
(defun py-ffap-module-path (module)
"Function for `ffap-alist' to return path for MODULE."
(let ((process (or
(and (eq major-mode 'py-shell-mode)
(get-buffer-process (current-buffer)))
(py-shell-get-process))))
(if (not process)
nil
(let ((module-file
(py--send-string-no-output
(format py-ffap-string-code module) process)))
(when module-file
(substring-no-properties module-file 1 -1))))))
(eval-after-load "ffap"
'(progn
(push '(python-mode . py-ffap-module-path) ffap-alist)
(push '(py-shell-mode . py-ffap-module-path) ffap-alist)))
;; Flymake
(defun py-toggle-flymake-intern (name command)
;; (clear-flymake-allowed-file-name-masks)
(unless (string-match "pyflakespep8" name)
(unless (executable-find name)
(when py-verbose-p (message "Don't see %s. Use `easy_install' %s? " name name))))
(if (py--buffer-filename-remote-maybe)
(let* ((temp-file (flymake-init-create-temp-buffer-copy
'flymake-create-temp-inplace))
(local-file (file-relative-name
temp-file
(file-name-directory (py--buffer-filename-remote-maybe)))))
(push (car (read-from-string (concat "(\"\\.py\\'\" flymake-" name ")"))) flymake-allowed-file-name-masks)
(list command (list local-file)))
(message "%s" "flymake needs a `file-name'. Please save before calling.")))
(defun py-flycheck-mode (&optional arg)
"Toggle `flycheck-mode'.
With negative argument switch off flycheck-mode
See menu \"Tools/Syntax Checking\""
(interactive "p")
(setq arg (or arg (if flycheck-mode 0 1)))
(if (featurep 'flycheck)
(if (< arg 0)
;; switch off
(flycheck-mode 0)
(when (and py-verbose-p (called-interactively-p 'any)) (message "flycheck-mode: %s" flycheck-mode))
(flycheck-mode 1)
(when (and py-verbose-p (called-interactively-p 'any)) (message "flycheck-mode: %s" flycheck-mode)))
(error "Can't find flycheck - see README.org")))
(defun pylint-flymake-mode ()
"Toggle `pylint' `flymake-mode'. "
(interactive)
(if flymake-mode
;; switch off
(flymake-mode 0)
(py-toggle-flymake-intern "pylint" "pylint")
(flymake-mode 1)))
(defun pyflakes-flymake-mode ()
"Toggle `pyflakes' `flymake-mode'. "
(interactive)
(if flymake-mode
;; switch off
(flymake-mode)
(py-toggle-flymake-intern "pyflakes" "pyflakes")
(flymake-mode)))
(defun pychecker-flymake-mode ()
"Toggle `pychecker' `flymake-mode'. "
(interactive)
(if flymake-mode
;; switch off
(flymake-mode)
(py-toggle-flymake-intern "pychecker" "pychecker")
(flymake-mode)))
(defun pep8-flymake-mode ()
"Toggle `pep8' `flymake-mode'. "
(interactive)
(if flymake-mode
;; switch off
(flymake-mode)
(py-toggle-flymake-intern "pep8" "pep8")
(flymake-mode)))
(defun pyflakespep8-flymake-mode ()
"Toggle `pyflakespep8' `flymake-mode'.
Joint call to pyflakes and pep8 as proposed by
Keegan Carruthers-Smith"
(interactive)
(if flymake-mode
;; switch off
(flymake-mode)
(py-toggle-flymake-intern "pyflakespep8" "pyflakespep8")
(flymake-mode)))
;; ;
(defun variables-state (&optional buffer directory-in directory-out)
"Diplays state of python-mode variables in an org-mode buffer.
Reads variables from python-mode.el as current buffer.
Variables which would produce a large output are left out:
- syntax-tables
- python-mode-map
Maybe call M-x describe-variable RET to query its value. "
(interactive)
(variables-prepare "state"))
(defun variables-base-state (exception-buffer orgname reSTname directory-in directory-out)
(save-restriction
(let ((suffix (file-name-nondirectory (py--buffer-filename-remote-maybe)))
variableslist)
;; (widen)
(goto-char (point-min))
;; (eval-buffer)
(while (and (not (eobp))(re-search-forward "^(defvar [[:alpha:]]\\|^(defcustom [[:alpha:]]\\|^(defconst [[:alpha:]]" nil t 1))
(let* ((name (symbol-at-point))
(state
(unless
(or (eq name 'py-menu)
(eq name 'python-mode-map)
(string-match "syntax-table" (prin1-to-string name)))
(prin1-to-string (symbol-value name)))))
(if state
(push (cons (prin1-to-string name) state) variableslist)
(message "don't see a state for %s" (prin1-to-string name))))
(forward-line 1))
(setq variableslist (nreverse variableslist))
;; (with-temp-buffer
(set-buffer (get-buffer-create "State-of-Python-mode-variables.org"))
(erase-buffer)
;; org
(insert "State of python-mode variables\n\n")
(switch-to-buffer (current-buffer))
(dolist (ele variableslist)
(if (string-match "^;;; " (car ele))
(unless (or (string-match "^;;; Constants\\|^;;; Commentary\\|^;;; Code\\|^;;; Macro definitions\\|^;;; Customization" (car ele)))
(insert (concat (replace-regexp-in-string "^;;; " "* " (car ele)) "\n")))
(insert (concat "\n** "(car ele) "\n"))
(insert (concat " " (cdr ele) "\n\n")))
;; (richten)
(sit-for 0.01))
(sit-for 0.01)
(org-mode))))
;; python-components-extensions
(defun py-indent-forward-line (&optional arg)
"Indent and move one line forward to next indentation.
Returns column of line reached.
If `py-kill-empty-line' is non-nil, delete an empty line.
When closing a form, use py-close-block et al, which will move and indent likewise.
With \\[universal argument] just indent.
"
(interactive "*P")
(let ((orig (point))
erg)
(unless (eobp)
(if (and (py--in-comment-p)(not py-indent-comments))
(forward-line 1)
(py-indent-line-outmost)
(unless (eq 4 (prefix-numeric-value arg))
(if (eobp) (newline)
(progn (forward-line 1))
(when (and py-kill-empty-line (empty-line-p) (not (looking-at "[ \t]*\n[[:alpha:]]")) (not (eobp)))
(delete-region (line-beginning-position) (line-end-position)))))))
(back-to-indentation)
(when (or (eq 4 (prefix-numeric-value arg)) (< orig (point))) (setq erg (current-column)))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-dedent-forward-line (&optional arg)
"Dedent line and move one line forward. "
(interactive "*p")
(py-dedent arg)
(if (eobp)
(newline)
(forward-line 1))
(end-of-line))
(defun py-dedent (&optional arg)
"Dedent line according to `py-indent-offset'.
With arg, do it that many times.
If point is between indent levels, dedent to next level.
Return indentation reached, if dedent done, nil otherwise.
Affected by `py-dedent-keep-relative-column'. "
(interactive "*p")
(or arg (setq arg 1))
(let ((orig (copy-marker (point)))
erg)
(dotimes (_ arg)
(let* ((cui (current-indentation))
(remain (% cui py-indent-offset))
(indent (* py-indent-offset (/ cui py-indent-offset))))
(beginning-of-line)
(fixup-whitespace)
(if (< 0 remain)
(indent-to-column indent)
(indent-to-column (- cui py-indent-offset)))))
(when (< (point) orig)
(setq erg (current-column)))
(when py-dedent-keep-relative-column (goto-char orig))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-class-at-point ()
"Return class definition as string.
With interactive call, send it to the message buffer too. "
(interactive)
(save-excursion
(let* ((beg (py-backward-class))
(end (py-forward-class))
(res (when (and (numberp beg)(numberp end)(< beg end)) (buffer-substring-no-properties beg end))))
(when (called-interactively-p 'any) (message "%s" res))
res)))
(defun py-function-at-point ()
"Return functions definition as string.
With interactive call, send it to the message buffer too. "
(interactive)
(save-excursion
(let* ((beg (py-backward-function))
(end (py-forward-function))
(res (when (and (numberp beg)(numberp end)(< beg end)) (buffer-substring-no-properties beg end))))
(when (called-interactively-p 'any) (message "%s" res))
res)))
(defun py-backward-function ()
"Jump to the beginning of defun. Returns point. "
(interactive "p")
(let ((pos (py-backward-def-or-class)))
(when (called-interactively-p 'any) (message "%s" pos))
pos))
(defun py-forward-function ()
"Jump to the end of function. "
(interactive "p")
(let ((pos (py-forward-def-or-class)))
(when (called-interactively-p 'any) (message "%s" pos))
pos))
;; Functions for marking regions
(defun py-line-at-point ()
"Return line as string.
With interactive call, send it to the message buffer too. "
(interactive)
(let* ((beg (line-beginning-position))
(end (line-end-position))
(res (when (and (numberp beg)(numberp end)(< beg end)) (buffer-substring-no-properties beg end))))
(when (called-interactively-p 'any) (message "%s" res))
res))
(defun py-match-paren-mode (&optional arg)
"py-match-paren-mode nil oder t"
(interactive "P")
(if (or arg (not py-match-paren-mode))
(progn
(setq py-match-paren-mode t)
(setq py-match-paren-mode nil))))
(defun py--match-end-finish (cui)
(let (skipped)
(unless (eq (current-column) cui)
(when (< (current-column) cui)
(setq skipped (skip-chars-forward " \t" (line-end-position)))
(setq cui (- cui skipped))
;; may current-column greater as needed indent?
(if (< 0 cui)
(progn
(unless (empty-line-p) (split-line))
(indent-to cui))
(forward-char cui))
(unless (eq (char-before) 32)(insert 32)(forward-char -1))))))
(defun py--match-paren-forward ()
(setq py--match-paren-forward-p t)
(let ((cui (current-indentation)))
(cond
((py--beginning-of-top-level-p)
(py-forward-top-level-bol)
(py--match-end-finish cui))
((py--beginning-of-class-p)
(py-forward-class-bol)
(py--match-end-finish cui))
((py--beginning-of-def-p)
(py-forward-def-bol)
(py--match-end-finish cui))
((py--beginning-of-if-block-p)
(py-forward-if-block-bol)
(py--match-end-finish cui))
((py--beginning-of-try-block-p)
(py-forward-try-block-bol)
(py--match-end-finish cui))
((py--beginning-of-for-block-p)
(py-forward-for-block-bol)
(py--match-end-finish cui))
((py--beginning-of-block-p)
(py-forward-block-bol)
(py--match-end-finish cui))
((py--beginning-of-clause-p)
(py-forward-clause-bol)
(py--match-end-finish cui))
((py--beginning-of-statement-p)
(py-forward-statement-bol)
(py--match-end-finish cui))
(t (py-forward-statement)
(py--match-end-finish cui)))))
(defun py--match-paren-backward ()
(setq py--match-paren-forward-p nil)
(let* ((cui (current-indentation))
(cuc (current-column))
(cui (min cuc cui)))
(if (eq 0 cui)
(py-backward-top-level)
(when (empty-line-p) (delete-region (line-beginning-position) (point)))
(py-backward-statement)
(unless (< (current-column) cuc)
(while (and (not (bobp))
(< cui (current-column))
(py-backward-statement)))))))
(defun py--match-paren-blocks ()
(cond
((and (looking-back "^[ \t]*" (line-beginning-position))(if (eq last-command 'py-match-paren)(not py--match-paren-forward-p)t)
;; (looking-at py-extended-block-or-clause-re)
(looking-at "[[:alpha:]_]"))
;; from beginning of top-level, block, clause, statement
(py--match-paren-forward))
(t
(py--match-paren-backward))))
(defun py-match-paren ()
"If at a beginning, jump to end and vice versa.
When called from within, go to the start.
Matches lists, but also block, statement, string and comment. "
(interactive)
(let ((pps (parse-partial-sexp (point-min) (point))))
(cond
;; if inside string, go to beginning
((nth 3 pps)
(goto-char (nth 8 pps)))
;; if inside comment, go to beginning
((nth 4 pps)
(py-backward-comment))
;; at comment start, go to end of commented section
((and
;; unless comment starts where jumped to some end
(not py--match-paren-forward-p)
(eq 11 (car-safe (syntax-after (point)))))
(py-forward-comment))
;; at string start, go to end
((or (eq 15 (car-safe (syntax-after (point))))
(eq 7 (car (syntax-after (point)))))
(goto-char (scan-sexps (point) 1))
(forward-char -1))
;; open paren
((eq 4 (car (syntax-after (point))))
(goto-char (scan-sexps (point) 1))
(forward-char -1))
((eq 5 (car (syntax-after (point))))
(goto-char (scan-sexps (1+ (point)) -1)))
((nth 1 pps)
(goto-char (nth 1 pps)))
(t
;; Python specific blocks
(py--match-paren-blocks)))))
(unless (boundp 'empty-line-p-chars)
(defvar empty-line-p-chars "^[ \t\f\r]*$"))
(unless (functionp 'in-string-p)
(defun in-string-p (&optional pos)
(interactive)
(let* ((orig (or pos (point)))
(erg
(save-excursion
(save-restriction
(widen)
(beginning-of-defun)
(numberp
(progn
(if (featurep 'xemacs)
(nth 3 (parse-partial-sexp (point) orig)
(nth 3 (parse-partial-sexp (point-min) (point)))))))))))
(when (called-interactively-p 'any) (message "%s" erg))
erg)))
(defun py-documentation (w)
"Launch PyDOC on the Word at Point"
(interactive
(list (let* ((word (thing-at-point 'word))
(input (read-string
(format "pydoc entry%s: "
(if (not word) "" (format " (default %s)" word))))))
(if (string= input "")
(if (not word) (error "No pydoc args given")
word) ;sinon word
input)))) ;sinon input
(shell-command (concat py-shell-name " -c \"from pydoc import help;help(\'" w "\')\"") "*PYDOCS*")
(view-buffer-other-window "*PYDOCS*" t 'kill-buffer-and-window))
(defun eva ()
"Put \"eval(...)\" forms around strings at point. "
(interactive "*")
(skip-chars-forward " \t\r\n\f")
(let* ((bounds (ar-bounds-of-word-atpt))
(beg (car bounds))
(end (cdr bounds)))
(goto-char end)
(insert ")")
(goto-char beg)
(insert "eval(")))
(defun pst-here ()
"Kill previous \"pdb.set_trace()\" and insert it at point. "
(interactive "*")
(let ((orig (copy-marker (point))))
(search-backward "pdb.set_trace()")
(replace-match "")
(when (empty-line-p)
(delete-region (line-beginning-position) (line-end-position)))
(goto-char orig)
(insert "pdb.set_trace()")))
(defalias 'durck 'py-printform-insert)
(defalias 'druck 'py-printform-insert)
(defun py-printform-insert (&optional arg strg)
"Inserts a print statement out of current `(car kill-ring)' by default, inserts STRING if delivered.
With optional \\[universal-argument] print as string"
(interactive "*P")
(let* ((name (py--string-strip (or strg (car kill-ring))))
;; guess if doublequotes or parentheses are needed
(numbered (not (eq 4 (prefix-numeric-value arg))))
(form (cond ((or (eq major-mode 'python-mode)(eq major-mode 'py-shell-mode))
(if numbered
(concat "print(\"" name ": %s \" % (" name "))")
(concat "print(\"" name ": %s \" % \"" name "\")"))))))
(insert form)))
(defun py-line-to-printform-python2 ()
"Transforms the item on current in a print statement. "
(interactive "*")
(let* ((name (thing-at-point 'word))
(form (cond ((or (eq major-mode 'python-mode)(eq major-mode 'py-shell-mode))
(concat "print(\"" name ": %s \" % " name ")")))))
(delete-region (line-beginning-position) (line-end-position))
(insert form))
(forward-line 1)
(back-to-indentation))
(defun py-boolswitch ()
"Edit the assignment of a boolean variable, revert them.
I.e. switch it from \"True\" to \"False\" and vice versa"
(interactive "*")
(save-excursion
(unless (py--end-of-statement-p)
(py-forward-statement))
(backward-word)
(cond ((looking-at "True")
(replace-match "False"))
((looking-at "False")
(replace-match "True"))
(t (message "%s" "Can't see \"True or False\" here")))))
(when (featurep 'thing-at-point-utils)
(defun py-beginning-of-list (&optional iact orig limit done last)
"Go to beginning of any parentized, braced or bracketed expression in statement. "
(interactive "p")
(save-restriction
(let ((orig (or orig (point)))
(done done)
(limit (or limit (re-search-backward "^[a-zA-Z]" nil t 1)))
(last last))
(unless (or done (not limit)) (narrow-to-region limit (point-max)))
(setq done t)
(goto-char orig)
(let* ((pt (car-safe (ar-in-parentized-p-atpt)))
(br (car-safe (ar-in-braced-p-atpt)))
(bk (car-safe (ar-in-bracketed-p-atpt)))
(erg (car (sort (delq nil (list pt br bk)) '<))))
(if erg
(progn
(goto-char (1- erg))
(setq last erg)
(py-beginning-of-list iact (1- erg) limit done last))
(when last
(goto-char last))
(when iact (message "%s" last))
last)))))
(defun py-end-of-list (&optional iact orig limit done last)
"Go to end of any parentized, braced or bracketed expression in statement. "
(interactive "p")
(save-restriction
(let ((orig (or orig (point)))
(done done)
(limit (or limit (re-search-backward "^[a-zA-Z]" nil t 1)))
(last last))
(unless (or done (not limit)) (narrow-to-region limit (point-max)))
(setq done t)
(goto-char orig)
(let* ((pt (car-safe (ar-in-parentized-p-atpt)))
(br (car-safe (ar-in-braced-p-atpt)))
(bk (car-safe (ar-in-bracketed-p-atpt)))
(erg (car (sort (delq nil (list pt br bk)) '<))))
(if erg
(progn
(goto-char (1- erg))
(setq last erg)
(py-end-of-list iact (1- erg) limit done last))
(when last
(goto-char last)
(match-paren)
(setq last (1+ (point)))
(when iact (message "%s" last))
last)))))))
;; python-components-imenu
;; Imenu definitions
(defvar py-imenu-class-regexp
(concat ; <>
"\\(" ;
"^[ \t]*" ; newline and maybe whitespace
"\\(class[ \t]+[a-zA-Z0-9_]+\\)" ; class name
; possibly multiple superclasses
"\\([ \t]*\\((\\([a-zA-Z0-9_,. \t\n]\\)*)\\)?\\)"
"[ \t]*:" ; and the final :
"\\)" ; >>classes<<
)
"Regexp for Python classes for use with the Imenu package."
)
(defvar py-imenu-method-regexp
(concat ; <>
"\\(" ;
"^[ \t]*" ; new line and maybe whitespace
"\\(def[ \t]+" ; function definitions start with def
"\\([a-zA-Z0-9_]+\\)" ; name is here
; function arguments...
;; "[ \t]*(\\([-+/a-zA-Z0-9_=,\* \t\n.()\"'#]*\\))"
"[ \t]*(\\([^:#]*\\))"
"\\)" ; end of def
"[ \t]*:" ; and then the :
"\\)" ; >>methods and functions<<
)
"Regexp for Python methods/functions for use with the Imenu package."
)
(defvar py-imenu-method-no-arg-parens '(2 8)
"Indices into groups of the Python regexp for use with Imenu.
Using these values will result in smaller Imenu lists, as arguments to
functions are not listed.
See the variable `py-imenu-show-method-args-p' for more
information.")
(defvar py-imenu-method-arg-parens '(2 7)
"Indices into groups of the Python regexp for use with imenu.
Using these values will result in large Imenu lists, as arguments to
functions are listed.
See the variable `py-imenu-show-method-args-p' for more
information.")
;; Note that in this format, this variable can still be used with the
;; imenu--generic-function. Otherwise, there is no real reason to have
;; it.
(defvar py-imenu-generic-expression
(cons
(concat
py-imenu-class-regexp
"\\|" ; or...
py-imenu-method-regexp
)
py-imenu-method-no-arg-parens)
"Generic Python expression which may be used directly with Imenu.
Used by setting the variable `imenu-generic-expression' to this value.
Also, see the function \\[py--imenu-create-index] for a better
alternative for finding the index.")
;; These next two variables are used when searching for the Python
;; class/definitions. Just saving some time in accessing the
;; generic-python-expression, really.
;; (set (make-local-variable 'imenu-generic-expression) 'py-imenu-generic-regexp)
(defvar py-imenu-generic-regexp nil)
(defvar py-imenu-generic-parens nil)
(defun py-switch-imenu-index-function ()
"Switch between series 5. index machine `py--imenu-create-index' and `py--imenu-create-index-new', which also lists modules variables "
(interactive)
(if (eq major-mode 'python-mode)
(progn
(if (eq py--imenu-create-index-function 'py--imenu-create-index-new)
(set (make-local-variable 'py--imenu-create-index-function) 'py--imenu-create-index)
(set (make-local-variable 'py--imenu-create-index-function) 'py--imenu-create-index-new))
(when py-verbose-p (message "imenu-create-index-function: %s" (prin1-to-string py--imenu-create-index-function)))
(funcall imenu-create-index-function))
(error "%s" "Only available in buffers set to python-mode")))
(defun py--imenu-create-index ()
"Python interface function for the Imenu package.
Finds all Python classes and functions/methods. Calls function
\\[py--imenu-create-index-engine]. See that function for the details
of how this works."
(setq py-imenu-generic-regexp (car py-imenu-generic-expression)
py-imenu-generic-parens (if py-imenu-show-method-args-p
py-imenu-method-arg-parens
py-imenu-method-no-arg-parens))
(goto-char (point-min))
;; Warning: When the buffer has no classes or functions, this will
;; return nil, which seems proper according to the Imenu API, but
;; causes an error in the XEmacs port of Imenu. Sigh.
(setq index-alist (cdr (py--imenu-create-index-engine nil))))
(defun py--imenu-create-index-engine (&optional start-indent)
"Function for finding Imenu definitions in Python.
Finds all definitions (classes, methods, or functions) in a Python
file for the Imenu package.
Returns a possibly nested alist of the form
(INDEX-NAME . INDEX-POSITION)
The second element of the alist may be an alist, producing a nested
list as in
(INDEX-NAME . INDEX-ALIST)
This function should not be called directly, as it calls itself
recursively and requires some setup. Rather this is the engine for
the function \\[py--imenu-create-index-function].
It works recursively by looking for all definitions at the current
indention level. When it finds one, it adds it to the alist. If it
finds a definition at a greater indentation level, it removes the
previous definition from the alist. In its place it adds all
definitions found at the next indentation level. When it finds a
definition that is less indented then the current level, it returns
the alist it has created thus far.
The optional argument START-INDENT indicates the starting indentation
at which to continue looking for Python classes, methods, or
functions. If this is not supplied, the function uses the indentation
of the first definition found."
(let (index-alist
sub-method-alist
looking-p
def-name prev-name
cur-indent def-pos
(class-paren (first py-imenu-generic-parens))
(def-paren (second py-imenu-generic-parens)))
(setq looking-p
(re-search-forward py-imenu-generic-regexp (point-max) t))
(while looking-p
(save-excursion
;; used to set def-name to this value but generic-extract-name
;; is new to imenu-1.14. this way it still works with
;; imenu-1.11
;;(imenu--generic-extract-name py-imenu-generic-parens))
(let ((cur-paren (if (match-beginning class-paren)
class-paren def-paren)))
(setq def-name
(buffer-substring-no-properties (match-beginning cur-paren)
(match-end cur-paren))))
(save-match-data
(py-beginning-of-def-or-class))
(beginning-of-line)
(setq cur-indent (current-indentation)))
;; HACK: want to go to the next correct definition location. We
;; explicitly list them here but it would be better to have them
;; in a list.
(setq def-pos
(or (match-beginning class-paren)
(match-beginning def-paren)))
;; if we don't have a starting indent level, take this one
(or start-indent
(setq start-indent cur-indent))
;; if we don't have class name yet, take this one
(or prev-name
(setq prev-name def-name))
;; what level is the next definition on? must be same, deeper
;; or shallower indentation
(cond
;; Skip code in comments and strings
((py--in-literal))
;; at the same indent level, add it to the list...
((= start-indent cur-indent)
(push (cons def-name def-pos) index-alist))
;; deeper indented expression, recurse
((< start-indent cur-indent)
;; the point is currently on the expression we're supposed to
;; start on, so go back to the last expression. The recursive
;; call will find this place again and add it to the correct
;; list
(re-search-backward py-imenu-generic-regexp (point-min) 'move)
(setq sub-method-alist (py--imenu-create-index-engine cur-indent))
(if sub-method-alist
;; we put the last element on the index-alist on the start
;; of the submethod alist so the user can still get to it.
(let* ((save-elmt (pop index-alist))
(classname (and (string-match "^class " (car save-elmt))(replace-regexp-in-string "^class " "" (car save-elmt)))))
(if (and classname (not (string-match "^class " (caar sub-method-alist))))
(setcar (car sub-method-alist) (concat classname "." (caar sub-method-alist))))
(push (cons prev-name
(cons save-elmt sub-method-alist))
index-alist))))
(t
(setq looking-p nil)
(re-search-backward py-imenu-generic-regexp (point-min) t)))
;; end-cond
(setq prev-name def-name)
(and looking-p
(setq looking-p
(re-search-forward py-imenu-generic-regexp
(point-max) 'move))))
(nreverse index-alist)))
(defun py--imenu-create-index-new (&optional beg end)
(interactive)
"`imenu-create-index-function' for Python. "
(set (make-local-variable 'imenu-max-items) py-imenu-max-items)
(let ((orig (point))
(beg (or beg (point-min)))
(end (or end (point-max)))
index-alist vars thisend sublist classname pos name)
(goto-char beg)
(while (and (re-search-forward "^[ \t]*\\(def\\|class\\)[ \t]+\\(\\sw+\\)" end t 1)(not (nth 8 (parse-partial-sexp (point-min) (point)))))
(if (save-match-data (string= "class" (match-string-no-properties 1)))
(progn
(setq pos (match-beginning 0)
name (match-string-no-properties 2)
classname (concat "class " name)
thisend (save-match-data (py--end-of-def-or-class-position))
sublist '())
(while (and (re-search-forward "^[ \t]*\\(def\\|class\\)[ \t]+\\(\\sw+\\)" (or thisend end) t 1)(not (nth 8 (parse-partial-sexp (point-min) (point)))))
(let* ((pos (match-beginning 0))
(name (match-string-no-properties 2)))
(push (cons (concat " " name) pos) sublist)))
(if classname
(progn
(setq sublist (nreverse sublist))
(push (cons classname pos) sublist)
(push (cons classname sublist) index-alist))
(push sublist index-alist)))
(let ((pos (match-beginning 0))
(name (match-string-no-properties 2)))
(push (cons name pos) index-alist))))
;; Look for module variables.
(goto-char (point-min))
(while (re-search-forward "^\\(\\sw+\\)[ \t]*=" end t)
(unless (nth 8 (parse-partial-sexp (point-min) (point)))
(let ((pos (match-beginning 1))
(name (match-string-no-properties 1)))
(push (cons name pos) vars))))
(setq index-alist (nreverse index-alist))
(when vars
(push (cons "Module variables"
(nreverse vars))
index-alist))
(goto-char orig)
index-alist))
;; python-components-named-shells
;;;###autoload
(defun ipython (&optional argprompt buffer fast exception-buffer split switch)
"Start an IPython interpreter.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "ipython" buffer fast exception-buffer split switch))
;;;###autoload
(defun ipython2.7 (&optional argprompt buffer fast exception-buffer split switch)
"Start an IPython2.7 interpreter.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "ipython2.7" buffer fast exception-buffer split switch))
;;;###autoload
(defun ipython3 (&optional argprompt buffer fast exception-buffer split switch)
"Start an IPython3 interpreter.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "ipython3" buffer fast exception-buffer split switch))
;;;###autoload
(defun jython (&optional argprompt buffer fast exception-buffer split switch)
"Start an Jython interpreter.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "jython" buffer fast exception-buffer split switch))
;;;###autoload
(defun python (&optional argprompt buffer fast exception-buffer split switch)
"Start an Python interpreter.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "python" buffer fast exception-buffer split switch))
;;;###autoload
(defun python2 (&optional argprompt buffer fast exception-buffer split switch)
"Start an Python2 interpreter.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "python2" buffer fast exception-buffer split switch))
;;;###autoload
(defun python3 (&optional argprompt buffer fast exception-buffer split switch)
"Start an Python3 interpreter.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "python3" buffer fast exception-buffer split switch))
;; dedicated
(defun ipython-dedicated (&optional argprompt buffer fast exception-buffer split switch)
"Start an unique IPython interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "ipython" buffer fast exception-buffer split switch))
(defun ipython2.7-dedicated (&optional argprompt buffer fast exception-buffer split switch)
"Start an unique IPython2.7 interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "ipython2.7" buffer fast exception-buffer split switch))
(defun ipython3-dedicated (&optional argprompt buffer fast exception-buffer split switch)
"Start an unique IPython3 interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "ipython3" buffer fast exception-buffer split switch))
(defun jython-dedicated (&optional argprompt buffer fast exception-buffer split switch)
"Start an unique Jython interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "jython" buffer fast exception-buffer split switch))
(defun python-dedicated (&optional argprompt buffer fast exception-buffer split switch)
"Start an unique Python interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "python" buffer fast exception-buffer split switch))
(defun python2-dedicated (&optional argprompt buffer fast exception-buffer split switch)
"Start an unique Python2 interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "python2" buffer fast exception-buffer split switch))
(defun python3-dedicated (&optional argprompt buffer fast exception-buffer split switch)
"Start an unique Python3 interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "python3" buffer fast exception-buffer split switch))
;; switch
(defun ipython-switch (&optional argprompt buffer fast exception-buffer split)
"Switch to IPython interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "ipython" buffer fast exception-buffer split t))
(defun ipython2.7-switch (&optional argprompt buffer fast exception-buffer split)
"Switch to IPython2.7 interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "ipython2.7" buffer fast exception-buffer split t))
(defun ipython3-switch (&optional argprompt buffer fast exception-buffer split)
"Switch to IPython3 interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "ipython3" buffer fast exception-buffer split t))
(defun jython-switch (&optional argprompt buffer fast exception-buffer split)
"Switch to Jython interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "jython" buffer fast exception-buffer split t))
(defun python-switch (&optional argprompt buffer fast exception-buffer split)
"Switch to Python interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "python" buffer fast exception-buffer split t))
(defun python2-switch (&optional argprompt buffer fast exception-buffer split)
"Switch to Python2 interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "python2" buffer fast exception-buffer split t))
(defun python3-switch (&optional argprompt buffer fast exception-buffer split)
"Switch to Python3 interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "python3" buffer fast exception-buffer split t))
;; no-switch
(defun ipython-no-switch (&optional argprompt buffer fast exception-buffer split)
"Open an IPython interpreter in another window, but do not switch to it.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "ipython" buffer fast exception-buffer split))
(defun ipython2.7-no-switch (&optional argprompt buffer fast exception-buffer split)
"Open an IPython2.7 interpreter in another window, but do not switch to it.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "ipython2.7" buffer fast exception-buffer split))
(defun ipython3-no-switch (&optional argprompt buffer fast exception-buffer split)
"Open an IPython3 interpreter in another window, but do not switch to it.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "ipython3" buffer fast exception-buffer split))
(defun jython-no-switch (&optional argprompt buffer fast exception-buffer split)
"Open an Jython interpreter in another window, but do not switch to it.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "jython" buffer fast exception-buffer split))
(defun python-no-switch (&optional argprompt buffer fast exception-buffer split)
"Open an Python interpreter in another window, but do not switch to it.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "python" buffer fast exception-buffer split))
(defun python2-no-switch (&optional argprompt buffer fast exception-buffer split)
"Open an Python2 interpreter in another window, but do not switch to it.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "python2" buffer fast exception-buffer split))
(defun python3-no-switch (&optional argprompt buffer fast exception-buffer split)
"Open an Python3 interpreter in another window, but do not switch to it.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt nil "python3" buffer fast exception-buffer split))
;; dedicated switch
(defalias 'ipython-dedicated-switch 'ipython-switch-dedicated)
(defun ipython-switch-dedicated (&optional argprompt buffer fast exception-buffer split)
"Switch to an unique IPython interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "ipython" buffer fast exception-buffer split t))
(defalias 'ipython2.7-dedicated-switch 'ipython2.7-switch-dedicated)
(defun ipython2.7-switch-dedicated (&optional argprompt buffer fast exception-buffer split)
"Switch to an unique IPython2.7 interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "ipython2.7" buffer fast exception-buffer split t))
(defalias 'ipython3-dedicated-switch 'ipython3-switch-dedicated)
(defun ipython3-switch-dedicated (&optional argprompt buffer fast exception-buffer split)
"Switch to an unique IPython3 interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "ipython3" buffer fast exception-buffer split t))
(defalias 'jython-dedicated-switch 'jython-switch-dedicated)
(defun jython-switch-dedicated (&optional argprompt buffer fast exception-buffer split)
"Switch to an unique Jython interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "jython" buffer fast exception-buffer split t))
(defalias 'python-dedicated-switch 'python-switch-dedicated)
(defun python-switch-dedicated (&optional argprompt buffer fast exception-buffer split)
"Switch to an unique Python interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "python" buffer fast exception-buffer split t))
(defalias 'python2-dedicated-switch 'python2-switch-dedicated)
(defun python2-switch-dedicated (&optional argprompt buffer fast exception-buffer split)
"Switch to an unique Python2 interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "python2" buffer fast exception-buffer split t))
(defalias 'python3-dedicated-switch 'python3-switch-dedicated)
(defun python3-switch-dedicated (&optional argprompt buffer fast exception-buffer split)
"Switch to an unique Python3 interpreter in another window.
Optional \\[universal-argument] prompts for path to the interpreter. "
(interactive "p")
(py-shell argprompt t "python3" buffer fast exception-buffer split t))
;; python-components-electric
(defun py-electric-colon (arg)
"Insert a colon and indent accordingly.
If a numeric argument ARG is provided, that many colons are inserted
non-electrically.
Electric behavior is inhibited inside a string or
comment or by universal prefix C-u.
Switched by `py-electric-colon-active-p', default is nil
See also `py-electric-colon-greedy-p' "
(interactive "*P")
(cond ((not py-electric-colon-active-p)
(self-insert-command (prefix-numeric-value arg)))
((and py-electric-colon-bobl-only (save-excursion (py-backward-statement) (not (py--beginning-of-block-p))))
(self-insert-command (prefix-numeric-value arg)))
((eq 4 (prefix-numeric-value arg))
(self-insert-command 1))
(t (insert ":")
(unless (py-in-string-or-comment-p)
(let ((orig (copy-marker (point)))
(indent (py-compute-indentation)))
(unless (or (eq (current-indentation) indent)
(and py-electric-colon-greedy-p
(eq indent (save-excursion (py-backward-statement)(current-indentation))))
(and (py--top-level-form-p)(< (current-indentation) indent)))
(beginning-of-line)
(delete-horizontal-space)
(indent-to indent))
(goto-char orig))
(when py-electric-colon-newline-and-indent-p
(py-newline-and-indent))))))
(defun py-electric-close (arg)
"Close completion buffer when it's sure, it's no longer needed, i.e. when inserting a space.
Works around a bug in `choose-completion'. "
(interactive "*P")
(cond ((not py-electric-close-active-p)
(self-insert-command (prefix-numeric-value arg)))
((eq 4 (prefix-numeric-value arg))
(self-insert-command 1))
(t (if (called-interactively-p 'any) (self-insert-command (prefix-numeric-value arg))
;; used from dont-indent-code-unnecessarily-lp-1048778-test
(insert " ")))))
(defun py-electric-comment (arg)
"Insert a comment. If starting a comment, indent accordingly.
If a numeric argument ARG is provided, that many \"#\" are inserted
non-electrically.
With \\[universal-argument] \"#\" electric behavior is inhibited inside a string or comment."
(interactive "*P")
(if (and py-indent-comments py-electric-comment-p)
(if (ignore-errors (eq 4 (car-safe arg)))
(insert "#")
(when (and (eq last-command 'py-electric-comment) (looking-back " " (line-beginning-position)))
(forward-char -1))
(if (called-interactively-p 'any) (self-insert-command (prefix-numeric-value arg))
(insert "#"))
(let ((orig (copy-marker (point)))
(indent (py-compute-indentation)))
(unless
(eq (current-indentation) indent)
(goto-char orig)
(beginning-of-line)
(delete-horizontal-space)
(indent-to indent)
(goto-char orig))
(when py-electric-comment-add-space-p
(unless (looking-at "[ \t]")
(insert " "))))
(setq last-command this-command))
(self-insert-command (prefix-numeric-value arg))))
;; Electric deletion
(defun py-empty-out-list-backward ()
"Deletes all elements from list before point. "
(interactive "*")
(and (member (char-before) (list ?\) ?\] ?\}))
(let ((orig (point))
(thischar (char-before))
pps cn)
(forward-char -1)
(setq pps (parse-partial-sexp (point-min) (point)))
(if (and (not (nth 8 pps)) (nth 1 pps))
(progn
(goto-char (nth 1 pps))
(forward-char 1))
(cond ((or (eq thischar 41)(eq thischar ?\)))
(setq cn "("))
((or (eq thischar 125) (eq thischar ?\}))
(setq cn "{"))
((or (eq thischar 93)(eq thischar ?\]))
(setq cn "[")))
(skip-chars-backward (concat "^" cn)))
(delete-region (point) orig)
(insert-char thischar 1)
(forward-char -1))))
(defun py-electric-backspace (&optional arg)
"Delete preceding character or level of indentation.
When `delete-active-region' and (use-region-p), delete region.
Unless at indentation:
With `py-electric-kill-backward-p' delete whitespace before point.
With `py-electric-kill-backward-p' at end of a list, empty that list.
Returns column reached. "
(interactive "p*")
(or arg (setq arg 1))
(let (erg)
(cond ((and (use-region-p)
;; Emacs23 doesn't know that var
(boundp 'delete-active-region) delete-active-region)
(backward-delete-char-untabify arg))
;; (delete-region (region-beginning) (region-end)))
((looking-back "^[ \t]+" (line-beginning-position))
(let* ((remains (% (current-column) py-indent-offset)))
(if (< 0 remains)
(delete-char (- remains))
(indent-line-to (- (current-indentation) py-indent-offset)))))
((and py-electric-kill-backward-p (member (char-before) (list ?\) ?\] ?\})))
(py-empty-out-list-backward))
((and py-electric-kill-backward-p (< 0 (setq erg (abs (skip-chars-backward " \t\r\n\f")))))
(delete-region (point) (+ erg (point))))
(t (delete-char (- 1))))
(setq erg (current-column))
(when (and (called-interactively-p 'any) py-verbose-p) (message "%s" erg))
erg))
(defun py-electric-delete (&optional arg)
"Delete following character or levels of whitespace.
When `delete-active-region' and (use-region-p), delete region "
(interactive "*p")
(let ((orig (point)))
(cond ((and (use-region-p)
;; Emacs23 doesn't know that var
(boundp 'delete-active-region) delete-active-region)
(delete-region (region-beginning) (region-end)))
((save-excursion (and (< (current-column)(current-indentation)) (<= py-indent-offset (skip-chars-forward " \t"))))
(goto-char orig)
(delete-char py-indent-offset))
((< 0 (skip-chars-forward " \t"))
(delete-region orig (point)))
(t (delete-char (or arg 1))))))
(defun py-electric-yank (&optional arg)
"Perform command `yank' followed by an `indent-according-to-mode' "
(interactive "P")
(cond (py-electric-yank-active-p
(yank arg)
;; (py-indent-line)
)
(t (yank arg))))
;; required for pending-del and delsel modes
(put 'py-electric-colon 'delete-selection t) ;delsel
(put 'py-electric-colon 'pending-delete t) ;pending-del
(put 'py-electric-backspace 'delete-selection 'supersede) ;delsel
(put 'py-electric-backspace 'pending-delete 'supersede) ;pending-del
(put 'py-electric-delete 'delete-selection 'supersede) ;delsel
(put 'py-electric-delete 'pending-delete 'supersede) ;pending-del
;; python-components-virtualenv
(defvar virtualenv-workon-home nil)
(defvar virtualenv-name nil)
(defvar virtualenv-old-path nil)
(defvar virtualenv-old-exec-path nil)
(if (getenv "WORKON_HOME")
(setq virtualenv-workon-home (getenv "WORKON_HOME"))
(setq virtualenv-workon-home "~/.virtualenvs"))
(setq virtualenv-name nil)
;;TODO: Move to a generic UTILITY or TOOL package
(defun virtualenv-filter (predicate sequence)
"Apply to each element of SEQUENCE the PREDICATE, if FUNCTION
returns non-nil append the element to the return value of
virtualenv-filter: a list"
(let ((retlist '()))
(dolist (element sequence)
(when (funcall predicate element)
(push element retlist)))
(nreverse retlist)))
(defun virtualenv-append-path (dir var)
"Append DIR to a path-like varibale VAR, for example:
(virtualenv-append-path /usr/bin:/bin /home/test/bin) -> /home/test/bin:/usr/bin:/bin"
(concat (expand-file-name dir)
path-separator
var))
(defun virtualenv-add-to-path (dir)
"Add the specified path element to the Emacs PATH"
(setenv "PATH"
(virtualenv-append-path dir
(getenv "PATH"))))
(defun virtualenv-current ()
"Barfs the current activated virtualenv"
(interactive)
(message virtualenv-name))
(defun virtualenv-activate (dir)
"Activate the virtualenv located in DIR"
(interactive "DVirtualenv Directory: ")
;; Eventually deactivate previous virtualenv
(when virtualenv-name
(virtualenv-deactivate))
(let ((cmd (concat "source " dir "/bin/activate\n")))
(comint-send-string (get-process (get-buffer-process "*shell*")) cmd)
;; Storing old variables
(setq virtualenv-old-path (getenv "PATH"))
(setq virtualenv-old-exec-path exec-path)
(setenv "VIRTUAL_ENV" dir)
(virtualenv-add-to-path (concat (py--normalize-directory dir) "bin"))
(push (concat (py--normalize-directory dir) "bin") exec-path)
(setq virtualenv-name dir)))
(defun virtualenv-deactivate ()
"Deactivate the current virtual enviroment"
(interactive)
;; Restoring old variables
(setenv "PATH" virtualenv-old-path)
(setq exec-path virtualenv-old-exec-path)
(message (concat "Virtualenv '" virtualenv-name "' deactivated."))
(setq virtualenv-name nil))
(defun virtualenv-p (dir)
"Check if a directory is a virtualenv"
(file-exists-p (concat dir "/bin/activate")))
(defun virtualenv-workon-complete ()
"return available completions for virtualenv-workon"
(let
;;Varlist
((filelist (directory-files virtualenv-workon-home t)))
;; Get only the basename from the list of the virtual environments
;; paths
(mapcar 'file-name-nondirectory
;; Filter the directories and then the virtual environments
(virtualenv-filter 'virtualenv-p
(virtualenv-filter 'file-directory-p filelist)))))
(defun virtualenv-workon (name)
"Issue a virtualenvwrapper-like virtualenv-workon command"
(interactive (list (completing-read "Virtualenv: " (virtualenv-workon-complete))))
(if (getenv "WORKON_HOME")
(virtualenv-activate (concat (py--normalize-directory (getenv "WORKON_HOME")) name))
(virtualenv-activate (concat (py--normalize-directory virtualenv-workon-home) name))))
;; python-components-booleans-beginning-forms
(defun py--beginning-of-comment-p (&optional pps)
"Returns position, if cursor is at the beginning of a `comment', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-comment-re)
(point))))
(defun py--beginning-of-line-p (&optional pps)
"Returns position, if cursor is at the beginning of a `line', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-line-re)
(point))))
(defun py--beginning-of-paragraph-p (&optional pps)
"Returns position, if cursor is at the beginning of a `paragraph', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-paragraph-re)
(point))))
(defun py--beginning-of-expression-p (&optional pps)
"Returns position, if cursor is at the beginning of a `expression', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-expression-re)
(point))))
(defun py--beginning-of-partial-expression-p (&optional pps)
"Returns position, if cursor is at the beginning of a `partial-expression', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-partial-expression-re)
(point))))
(defun py--beginning-of-section-p (&optional pps)
"Returns position, if cursor is at the beginning of a `section', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-section-re)
(point))))
(defun py--beginning-of-top-level-p (&optional pps)
"Returns position, if cursor is at the beginning of a `top-level', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-top-level-re)
(point))))
(defun py--beginning-of-block-p (&optional pps)
"Returns position, if cursor is at the beginning of a `block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-block-or-clause-p (&optional pps)
"Returns position, if cursor is at the beginning of a `block-or-clause', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-block-or-clause-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-class-p (&optional pps)
"Returns position, if cursor is at the beginning of a `class', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-class-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-clause-p (&optional pps)
"Returns position, if cursor is at the beginning of a `clause', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-clause-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-def-p (&optional pps)
"Returns position, if cursor is at the beginning of a `def', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-def-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-def-or-class-p (&optional pps)
"Returns position, if cursor is at the beginning of a `def-or-class', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-def-or-class-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-elif-block-p (&optional pps)
"Returns position, if cursor is at the beginning of a `elif-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-elif-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-else-block-p (&optional pps)
"Returns position, if cursor is at the beginning of a `else-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-else-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-except-block-p (&optional pps)
"Returns position, if cursor is at the beginning of a `except-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-except-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-for-block-p (&optional pps)
"Returns position, if cursor is at the beginning of a `for-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-for-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-if-block-p (&optional pps)
"Returns position, if cursor is at the beginning of a `if-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-if-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-indent-p (&optional pps)
"Returns position, if cursor is at the beginning of a `indent', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-indent-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-minor-block-p (&optional pps)
"Returns position, if cursor is at the beginning of a `minor-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-minor-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-statement-p (&optional pps)
"Returns position, if cursor is at the beginning of a `statement', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-statement-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-try-block-p (&optional pps)
"Returns position, if cursor is at the beginning of a `try-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-try-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(eq (current-column)(current-indentation))
(point))))
(defun py--beginning-of-block-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-block-or-clause-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `block-or-clause', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-block-or-clause-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-class-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `class', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-class-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-clause-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `clause', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-clause-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-def-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `def', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-def-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-def-or-class-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `def-or-class', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-def-or-class-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-elif-block-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `elif-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-elif-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-else-block-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `else-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-else-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-except-block-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `except-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-except-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-for-block-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `for-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-for-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-if-block-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `if-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-if-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-indent-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `indent', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-indent-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-minor-block-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `minor-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-minor-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-statement-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `statement', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-statement-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
(defun py--beginning-of-try-block-bol-p (&optional pps)
"Returns position, if cursor is at the beginning of a `try-block', nil otherwise. "
(let ((pps (or pps (parse-partial-sexp (point-min) (point)))))
(and (bolp)
(not (or (nth 8 pps)(nth 1 pps)))
(looking-at py-try-block-re)
(looking-back "[^ \t]*" (line-beginning-position))
(point))))
;; python-components-booleans-end-forms
(defun py--end-of-comment-p ()
"Returns position, if cursor is at the end of a comment, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-comment)
(py-forward-comment)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-line-p ()
"Returns position, if cursor is at the end of a line, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-line)
(py-forward-line)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-paragraph-p ()
"Returns position, if cursor is at the end of a paragraph, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-paragraph)
(py-forward-paragraph)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-expression-p ()
"Returns position, if cursor is at the end of a expression, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-expression)
(py-forward-expression)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-partial-expression-p ()
"Returns position, if cursor is at the end of a partial-expression, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-partial-expression)
(py-forward-partial-expression)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-section-p ()
"Returns position, if cursor is at the end of a section, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-section)
(py-forward-section)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-top-level-p ()
"Returns position, if cursor is at the end of a top-level, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-top-level)
(py-forward-top-level)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-block-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-block-bol)
(py-forward-block-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-block-or-clause-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a block-or-clause, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-block-or-clause-bol)
(py-forward-block-or-clause-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-class-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a class, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-class-bol)
(py-forward-class-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-clause-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a clause, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-clause-bol)
(py-forward-clause-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-def-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a def, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-def-bol)
(py-forward-def-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-def-or-class-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a def-or-class, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-def-or-class-bol)
(py-forward-def-or-class-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-elif-block-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a elif-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-elif-block-bol)
(py-forward-elif-block-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-else-block-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a else-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-else-block-bol)
(py-forward-else-block-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-except-block-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a except-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-except-block-bol)
(py-forward-except-block-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-for-block-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a for-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-for-block-bol)
(py-forward-for-block-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-if-block-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a if-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-if-block-bol)
(py-forward-if-block-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-indent-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a indent, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-indent-bol)
(py-forward-indent-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-minor-block-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a minor-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-minor-block-bol)
(py-forward-minor-block-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-statement-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a statement, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-statement-bol)
(py-forward-statement-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-try-block-bol-p ()
"Returns position, if cursor is at beginning-of-line at the end of a try-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-try-block-bol)
(py-forward-try-block-bol)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-block-p ()
"Returns position, if cursor is at the end of a block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-block)
(py-forward-block)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-block-or-clause-p ()
"Returns position, if cursor is at the end of a block-or-clause, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-block-or-clause)
(py-forward-block-or-clause)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-class-p ()
"Returns position, if cursor is at the end of a class, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-class)
(py-forward-class)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-clause-p ()
"Returns position, if cursor is at the end of a clause, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-clause)
(py-forward-clause)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-def-p ()
"Returns position, if cursor is at the end of a def, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-def)
(py-forward-def)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-def-or-class-p ()
"Returns position, if cursor is at the end of a def-or-class, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-def-or-class)
(py-forward-def-or-class)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-elif-block-p ()
"Returns position, if cursor is at the end of a elif-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-elif-block)
(py-forward-elif-block)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-else-block-p ()
"Returns position, if cursor is at the end of a else-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-else-block)
(py-forward-else-block)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-except-block-p ()
"Returns position, if cursor is at the end of a except-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-except-block)
(py-forward-except-block)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-for-block-p ()
"Returns position, if cursor is at the end of a for-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-for-block)
(py-forward-for-block)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-if-block-p ()
"Returns position, if cursor is at the end of a if-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-if-block)
(py-forward-if-block)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-indent-p ()
"Returns position, if cursor is at the end of a indent, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-indent)
(py-forward-indent)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-minor-block-p ()
"Returns position, if cursor is at the end of a minor-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-minor-block)
(py-forward-minor-block)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-statement-p ()
"Returns position, if cursor is at the end of a statement, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-statement)
(py-forward-statement)
(when (eq orig (point))
(setq erg orig))
erg)))
(defun py--end-of-try-block-p ()
"Returns position, if cursor is at the end of a try-block, nil otherwise. "
(let ((orig (point))
erg)
(save-excursion
(py-backward-try-block)
(py-forward-try-block)
(when (eq orig (point))
(setq erg orig))
erg)))
;; python-components-beginning-position-forms
(defun py--beginning-of-block-position ()
"Returns beginning of block position. "
(save-excursion
(let ((erg (or (py--beginning-of-block-p)
(py-backward-block))))
erg)))
(defun py--beginning-of-block-or-clause-position ()
"Returns beginning of block-or-clause position. "
(save-excursion
(let ((erg (or (py--beginning-of-block-or-clause-p)
(py-backward-block-or-clause))))
erg)))
(defun py--beginning-of-class-position ()
"Returns beginning of class position. "
(save-excursion
(let ((erg (or (py--beginning-of-class-p)
(py-backward-class))))
erg)))
(defun py--beginning-of-clause-position ()
"Returns beginning of clause position. "
(save-excursion
(let ((erg (or (py--beginning-of-clause-p)
(py-backward-clause))))
erg)))
(defun py--beginning-of-comment-position ()
"Returns beginning of comment position. "
(save-excursion
(let ((erg (or (py--beginning-of-comment-p)
(py-backward-comment))))
erg)))
(defun py--beginning-of-def-position ()
"Returns beginning of def position. "
(save-excursion
(let ((erg (or (py--beginning-of-def-p)
(py-backward-def))))
erg)))
(defun py--beginning-of-def-or-class-position ()
"Returns beginning of def-or-class position. "
(save-excursion
(let ((erg (or (py--beginning-of-def-or-class-p)
(py-backward-def-or-class))))
erg)))
(defun py--beginning-of-expression-position ()
"Returns beginning of expression position. "
(save-excursion
(let ((erg (or (py--beginning-of-expression-p)
(py-backward-expression))))
erg)))
(defun py--beginning-of-except-block-position ()
"Returns beginning of except-block position. "
(save-excursion
(let ((erg (or (py--beginning-of-except-block-p)
(py-backward-except-block))))
erg)))
(defun py--beginning-of-if-block-position ()
"Returns beginning of if-block position. "
(save-excursion
(let ((erg (or (py--beginning-of-if-block-p)
(py-backward-if-block))))
erg)))
(defun py--beginning-of-indent-position ()
"Returns beginning of indent position. "
(save-excursion
(let ((erg (or (py--beginning-of-indent-p)
(py-backward-indent))))
erg)))
(defun py--beginning-of-line-position ()
"Returns beginning of line position. "
(save-excursion
(let ((erg (or (py--beginning-of-line-p)
(py-backward-line))))
erg)))
(defun py--beginning-of-minor-block-position ()
"Returns beginning of minor-block position. "
(save-excursion
(let ((erg (or (py--beginning-of-minor-block-p)
(py-backward-minor-block))))
erg)))
(defun py--beginning-of-partial-expression-position ()
"Returns beginning of partial-expression position. "
(save-excursion
(let ((erg (or (py--beginning-of-partial-expression-p)
(py-backward-partial-expression))))
erg)))
(defun py--beginning-of-paragraph-position ()
"Returns beginning of paragraph position. "
(save-excursion
(let ((erg (or (py--beginning-of-paragraph-p)
(py-backward-paragraph))))
erg)))
(defun py--beginning-of-section-position ()
"Returns beginning of section position. "
(save-excursion
(let ((erg (or (py--beginning-of-section-p)
(py-backward-section))))
erg)))
(defun py--beginning-of-statement-position ()
"Returns beginning of statement position. "
(save-excursion
(let ((erg (or (py--beginning-of-statement-p)
(py-backward-statement))))
erg)))
(defun py--beginning-of-top-level-position ()
"Returns beginning of top-level position. "
(save-excursion
(let ((erg (or (py--beginning-of-top-level-p)
(py-backward-top-level))))
erg)))
(defun py--beginning-of-try-block-position ()
"Returns beginning of try-block position. "
(save-excursion
(let ((erg (or (py--beginning-of-try-block-p)
(py-backward-try-block))))
erg)))
(defun py--beginning-of-block-position-bol ()
"Returns beginning of block position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-block-bol-p)
(py-backward-block-bol))))
erg)))
(defun py--beginning-of-block-or-clause-position-bol ()
"Returns beginning of block-or-clause position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-block-or-clause-bol-p)
(py-backward-block-or-clause-bol))))
erg)))
(defun py--beginning-of-class-position-bol ()
"Returns beginning of class position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-class-bol-p)
(py-backward-class-bol))))
erg)))
(defun py--beginning-of-clause-position-bol ()
"Returns beginning of clause position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-clause-bol-p)
(py-backward-clause-bol))))
erg)))
(defun py--beginning-of-def-position-bol ()
"Returns beginning of def position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-def-bol-p)
(py-backward-def-bol))))
erg)))
(defun py--beginning-of-def-or-class-position-bol ()
"Returns beginning of def-or-class position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-def-or-class-bol-p)
(py-backward-def-or-class-bol))))
erg)))
(defun py--beginning-of-elif-block-position-bol ()
"Returns beginning of elif-block position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-elif-block-bol-p)
(py-backward-elif-block-bol))))
erg)))
(defun py--beginning-of-else-block-position-bol ()
"Returns beginning of else-block position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-else-block-bol-p)
(py-backward-else-block-bol))))
erg)))
(defun py--beginning-of-except-block-position-bol ()
"Returns beginning of except-block position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-except-block-bol-p)
(py-backward-except-block-bol))))
erg)))
(defun py--beginning-of-for-block-position-bol ()
"Returns beginning of for-block position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-for-block-bol-p)
(py-backward-for-block-bol))))
erg)))
(defun py--beginning-of-if-block-position-bol ()
"Returns beginning of if-block position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-if-block-bol-p)
(py-backward-if-block-bol))))
erg)))
(defun py--beginning-of-indent-position-bol ()
"Returns beginning of indent position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-indent-bol-p)
(py-backward-indent-bol))))
erg)))
(defun py--beginning-of-minor-block-position-bol ()
"Returns beginning of minor-block position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-minor-block-bol-p)
(py-backward-minor-block-bol))))
erg)))
(defun py--beginning-of-statement-position-bol ()
"Returns beginning of statement position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-statement-bol-p)
(py-backward-statement-bol))))
erg)))
(defun py--beginning-of-try-block-position-bol ()
"Returns beginning of try-block position at beginning-of-line. "
(save-excursion
(let ((erg (or (py--beginning-of-try-block-bol-p)
(py-backward-try-block-bol))))
erg)))
;; python-components-end-position-forms
(defun py--end-of-block-position ()
"Returns end of block position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-block))))
erg)))
(defun py--end-of-block-or-clause-position ()
"Returns end of block-or-clause position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-block-or-clause))))
erg)))
(defun py--end-of-class-position ()
"Returns end of class position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-class))))
erg)))
(defun py--end-of-clause-position ()
"Returns end of clause position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-clause))))
erg)))
(defun py--end-of-comment-position ()
"Returns end of comment position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-comment))))
erg)))
(defun py--end-of-def-position ()
"Returns end of def position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-def))))
erg)))
(defun py--end-of-def-or-class-position ()
"Returns end of def-or-class position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-def-or-class))))
erg)))
(defun py--end-of-expression-position ()
"Returns end of expression position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-expression))))
erg)))
(defun py--end-of-except-block-position ()
"Returns end of except-block position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-except-block))))
erg)))
(defun py--end-of-if-block-position ()
"Returns end of if-block position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-if-block))))
erg)))
(defun py--end-of-indent-position ()
"Returns end of indent position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-indent))))
erg)))
(defun py--end-of-line-position ()
"Returns end of line position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-line))))
erg)))
(defun py--end-of-minor-block-position ()
"Returns end of minor-block position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-minor-block))))
erg)))
(defun py--end-of-partial-expression-position ()
"Returns end of partial-expression position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-partial-expression))))
erg)))
(defun py--end-of-paragraph-position ()
"Returns end of paragraph position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-paragraph))))
erg)))
(defun py--end-of-section-position ()
"Returns end of section position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-section))))
erg)))
(defun py--end-of-statement-position ()
"Returns end of statement position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-statement))))
erg)))
(defun py--end-of-top-level-position ()
"Returns end of top-level position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-top-level))))
erg)))
(defun py--end-of-try-block-position ()
"Returns end of try-block position. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-try-block))))
erg)))
(defun py--end-of-block-position-bol ()
"Returns end of block position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-block-bol))))
erg)))
(defun py--end-of-block-or-clause-position-bol ()
"Returns end of block-or-clause position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-block-or-clause-bol))))
erg)))
(defun py--end-of-class-position-bol ()
"Returns end of class position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-class-bol))))
erg)))
(defun py--end-of-clause-position-bol ()
"Returns end of clause position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-clause-bol))))
erg)))
(defun py--end-of-def-position-bol ()
"Returns end of def position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-def-bol))))
erg)))
(defun py--end-of-def-or-class-position-bol ()
"Returns end of def-or-class position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-def-or-class-bol))))
erg)))
(defun py--end-of-elif-block-position-bol ()
"Returns end of elif-block position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-elif-block-bol))))
erg)))
(defun py--end-of-else-block-position-bol ()
"Returns end of else-block position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-else-block-bol))))
erg)))
(defun py--end-of-except-block-position-bol ()
"Returns end of except-block position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-except-block-bol))))
erg)))
(defun py--end-of-for-block-position-bol ()
"Returns end of for-block position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-for-block-bol))))
erg)))
(defun py--end-of-if-block-position-bol ()
"Returns end of if-block position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-if-block-bol))))
erg)))
(defun py--end-of-indent-position-bol ()
"Returns end of indent position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-indent-bol))))
erg)))
(defun py--end-of-minor-block-position-bol ()
"Returns end of minor-block position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-minor-block-bol))))
erg)))
(defun py--end-of-statement-position-bol ()
"Returns end of statement position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-statement-bol))))
erg)))
(defun py--end-of-try-block-position-bol ()
"Returns end of try-block position at beginning-of-line. "
(save-excursion
(let ((erg (progn
(when (looking-at "[ \\t\\r\\n\\f]*$")
(skip-chars-backward " \t\r\n\f")
(forward-char -1))
(py-forward-try-block-bol))))
erg)))
;; python-components-up-down
(defun py-up-statement ()
"Go to the beginning of next statement upwards in buffer.
Return position if statement found, nil otherwise. "
(interactive)
(let (erg)
(if (py--beginning-of-statement-p)
(setq erg (py-backward-statement))
(setq erg (and (py-backward-statement) (py-backward-statement))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-down-statement ()
"Go to the beginning of next statement downwards in buffer.
Return position if statement found, nil otherwise. "
(interactive)
(let* ((orig (point))
erg)
(cond ((py--end-of-statement-p)
(setq erg (and (py-forward-statement) (py-backward-statement))))
((setq erg (< orig (progn (py-forward-statement) (py-backward-statement))))
(point))
(t (setq erg (and (py-forward-statement) (py-forward-statement)(py-backward-statement)))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-up-base (regexp &optional indent orig decorator bol repeat)
"Go to the beginning of next form upwards in buffer.
Return position if form found, nil otherwise.
REGEXP is a quoted symbol "
(unless (bobp)
(let* ((orig (or orig (point)))
(repeat (or (and repeat (1+ repeat)) 999))
erg name command)
(if (< py-max-specpdl-size repeat)
(error "`py-up-base' reached loops max.")
(if indent
(progn
(while (and (re-search-backward (symbol-value regexp) nil 'move 1)
(or (nth 8 (parse-partial-sexp (point-min) (point)))
(<= indent (current-indentation))))))
(unless (py--beginning-of-statement-p)
(py-backward-statement))
(if (looking-at (symbol-value regexp))
(py-up-base regexp (current-indentation) orig decorator bol repeat)
(setq name (symbol-name regexp))
(setq command (intern-soft (concat "py-backward-" (substring name (string-match "minor\\|block\\|def\\|class" name) (string-match "-re" name)))))
(funcall command)
(py-up-base regexp (current-indentation) orig decorator bol repeat)))
(when bol (beginning-of-line))
(and (looking-at (symbol-value regexp)) (< (point) orig) (setq erg (point)))
(when py-verbose-p (message "%s" erg))
erg))))
(defun py-down-base (regexp &optional orig indent decorator bol)
"Go to the beginning of next form below in buffer.
Return position if form found, nil otherwise.
Expects a quoted symbol 'REGEXP"
(unless (eobp)
(let* ((name (substring (symbol-name regexp) 3 -3))
(p-command (car (read-from-string (concat "py--beginning-of-" name "-p"))))
(backward-command (car (read-from-string (concat "py-backward-" name))))
(up-command (car (read-from-string (concat "py-up-" name))))
;; (down-command (car (read-from-string (concat "py-down-" name))))
(forward-command (car (read-from-string (concat "py-forward-" name))))
erg done start)
(if (funcall p-command)
(setq indent (current-indentation))
(save-excursion
(cond
((and indent decorator bol)
(funcall backward-command indent decorator bol))
((and indent decorator)
(funcall backward-command indent decorator))
(t (funcall backward-command indent)))
(setq indent (current-indentation))
(setq start (point))))
;; (setq done (funcall forward-command indent decorator bol))
(while (and (not done)
(py-down-statement)
(<= indent (current-indentation))
(when (looking-at (symbol-value regexp))
(setq done (point)))))
(when done
(when bol (beginning-of-line))
(setq erg (point)))
(unless done
(goto-char orig)
(or
(if
(and
(funcall up-command)
;; up should not result to backward
(not (eq (point) start))
(funcall forward-command decorator bol)
(< orig (point))
(setq erg (point)))
(when bol (setq erg (py--beginning-of-line-form erg)))
(goto-char (point-max)))))
(when py-verbose-p (message "%s" erg))
erg)))
(defalias 'py-block-up 'py-up-block)
(defun py-up-block (&optional indent decorator bol)
"Go to the beginning of next block upwards in buffer.
Return position if block found, nil otherwise. "
(interactive)
(py-up-base 'py-extended-block-or-clause-re indent (point) decorator bol))
(defalias 'py-class-up 'py-up-class)
(defun py-up-class (&optional indent decorator bol)
"Go to the beginning of next class upwards in buffer.
Return position if class found, nil otherwise. "
(interactive)
(py-up-base 'py-class-re indent (point) decorator bol))
(defalias 'py-def-up 'py-up-def)
(defun py-up-def (&optional indent decorator bol)
"Go to the beginning of next def upwards in buffer.
Return position if def found, nil otherwise. "
(interactive)
(py-up-base 'py-def-re indent (point) decorator bol))
(defalias 'py-def-or-class-up 'py-up-def-or-class)
(defun py-up-def-or-class (&optional indent decorator bol)
"Go to the beginning of next def-or-class upwards in buffer.
Return position if def-or-class found, nil otherwise. "
(interactive)
(py-up-base 'py-def-or-class-re indent (point) decorator bol))
(defalias 'py-minor-block-up 'py-up-minor-block)
(defun py-up-minor-block (&optional indent decorator bol)
"Go to the beginning of next minor-block upwards in buffer.
Return position if minor-block found, nil otherwise. "
(interactive)
(py-up-base 'py-extended-block-or-clause-re indent (point) decorator bol))
(defalias 'py-block-down 'py-down-block)
(defun py-down-block (&optional orig indent decorator bol)
"Go to the beginning of next block below in buffer.
Return position if block found, nil otherwise. "
(interactive)
(py-down-base 'py-block-re (or orig (point)) indent decorator bol))
(defalias 'py-class-down 'py-down-class)
(defun py-down-class (&optional orig indent decorator bol)
"Go to the beginning of next class below in buffer.
Return position if class found, nil otherwise. "
(interactive)
(py-down-base 'py-class-re (or orig (point)) indent decorator bol))
(defalias 'py-def-down 'py-down-def)
(defun py-down-def (&optional orig indent decorator bol)
"Go to the beginning of next def below in buffer.
Return position if def found, nil otherwise. "
(interactive)
(py-down-base 'py-def-re (or orig (point)) indent decorator bol))
(defalias 'py-def-or-class-down 'py-down-def-or-class)
(defun py-down-def-or-class (&optional orig indent decorator bol)
"Go to the beginning of next def-or-class below in buffer.
Return position if def-or-class found, nil otherwise. "
(interactive)
(py-down-base 'py-def-or-class-re (or orig (point)) indent decorator bol))
(defalias 'py-minor-block-down 'py-down-minor-block)
(defun py-down-minor-block (&optional orig indent decorator bol)
"Go to the beginning of next minor-block below in buffer.
Return position if minor-block found, nil otherwise. "
(interactive)
(py-down-base 'py-minor-block-re (or orig (point)) indent decorator bol))
(defun py-up-block-bol (&optional indent decorator)
"Go to the beginning of next block upwards in buffer.
Go to beginning of line.
Return position if block found, nil otherwise. "
(interactive)
(py-up-base 'py-block-re indent (point) decorator t))
(defun py-up-class-bol (&optional indent decorator)
"Go to the beginning of next class upwards in buffer.
Go to beginning of line.
Return position if class found, nil otherwise. "
(interactive)
(py-up-base 'py-class-re indent (point) decorator t))
(defun py-up-def-bol (&optional indent decorator)
"Go to the beginning of next def upwards in buffer.
Go to beginning of line.
Return position if def found, nil otherwise. "
(interactive)
(py-up-base 'py-def-re indent (point) decorator t))
(defun py-up-def-or-class-bol (&optional indent decorator)
"Go to the beginning of next def-or-class upwards in buffer.
Go to beginning of line.
Return position if def-or-class found, nil otherwise. "
(interactive)
(py-up-base 'py-def-or-class-re indent (point) decorator t))
(defun py-up-minor-block-bol (&optional indent decorator)
"Go to the beginning of next minor-block upwards in buffer.
Go to beginning of line.
Return position if minor-block found, nil otherwise. "
(interactive)
(py-up-base 'py-minor-block-re indent (point) decorator t))
(defun py-down-block-bol (&optional orig indent decorator bol)
"Go to the beginning of next block below in buffer.
Go to beginning of line
Return position if block found, nil otherwise "
(interactive)
(py-down-base 'py-block-re (or orig (point)) indent decorator (or bol t)))
(defun py-down-class-bol (&optional orig indent decorator bol)
"Go to the beginning of next class below in buffer.
Go to beginning of line
Return position if class found, nil otherwise "
(interactive)
(py-down-base 'py-class-re (or orig (point)) indent decorator (or bol t)))
(defun py-down-def-bol (&optional orig indent decorator bol)
"Go to the beginning of next def below in buffer.
Go to beginning of line
Return position if def found, nil otherwise "
(interactive)
(py-down-base 'py-def-re (or orig (point)) indent decorator (or bol t)))
(defun py-down-def-or-class-bol (&optional orig indent decorator bol)
"Go to the beginning of next def-or-class below in buffer.
Go to beginning of line
Return position if def-or-class found, nil otherwise "
(interactive)
(py-down-base 'py-def-or-class-re (or orig (point)) indent decorator (or bol t)))
(defun py-down-minor-block-bol (&optional orig indent decorator bol)
"Go to the beginning of next minor-block below in buffer.
Go to beginning of line
Return position if minor-block found, nil otherwise "
(interactive)
(py-down-base 'py-minor-block-re (or orig (point)) indent decorator (or bol t)))
;; python-components-up-down.el ends here
;; python-components-exec-forms
;; Execute forms at point
(defun py-execute-try-block ()
"Send try-block at point to Python default interpreter. "
(interactive)
(let ((beg (prog1
(or (py--beginning-of-try-block-p)
(save-excursion
(py-backward-try-block)))))
(end (save-excursion
(py-forward-try-block))))
(py-execute-region beg end)))
(defun py-execute-if-block ()
"Send if-block at point to Python default interpreter. "
(interactive)
(let ((beg (prog1
(or (py--beginning-of-if-block-p)
(save-excursion
(py-backward-if-block)))))
(end (save-excursion
(py-forward-if-block))))
(py-execute-region beg end)))
(defun py-execute-for-block ()
"Send for-block at point to Python default interpreter. "
(interactive)
(let ((beg (prog1
(or (py--beginning-of-for-block-p)
(save-excursion
(py-backward-for-block)))))
(end (save-excursion
(py-forward-for-block))))
(py-execute-region beg end)))
;; python-extended-executes
(defun py-execute-block (&optional shell dedicated fast split switch proc wholebuf)
"Send block at point to interpreter. "
(interactive)
(py--execute-prepare 'block shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-switch (&optional shell dedicated fast split proc wholebuf)
"Send block at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send block at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-dedicated (&optional shell fast split switch proc wholebuf)
"Send block at point to unique interpreter. "
(interactive)
(py--execute-prepare 'block shell t switch nil fast proc wholebuf split))
(defun py-execute-block-dedicated-switch (&optional shell fast split proc wholebuf)
"Send block at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block shell t 'switch nil fast proc wholebuf split))
(defun py-execute-block-ipython (&optional dedicated fast split switch proc wholebuf)
"Send block at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'block 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send block at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'block 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-block-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send block at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-block-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send block at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'block 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send block at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'block 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-block-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send block at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-block-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send block at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'block 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send block at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'block 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-block-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send block at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-block-jython (&optional dedicated fast split switch proc wholebuf)
"Send block at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'block 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-jython-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-jython-dedicated (&optional fast split switch proc wholebuf)
"Send block at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'block 'jython t switch nil fast proc wholebuf split))
(defun py-execute-block-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send block at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-block-python (&optional dedicated fast split switch proc wholebuf)
"Send block at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'block 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-python-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'block 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'block 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-python-dedicated (&optional fast split switch proc wholebuf)
"Send block at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'block 'python t switch nil fast proc wholebuf split))
(defun py-execute-block-python-dedicated-switch (&optional fast split proc wholebuf)
"Send block at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'block 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-block-python2 (&optional dedicated fast split switch proc wholebuf)
"Send block at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'block 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-python2-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-python2-dedicated (&optional fast split switch proc wholebuf)
"Send block at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'block 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-block-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send block at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-block-python3 (&optional dedicated fast split switch proc wholebuf)
"Send block at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'block 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-python3-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send block at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-python3-dedicated (&optional fast split switch proc wholebuf)
"Send block at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'block 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-block-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send block at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause (&optional shell dedicated fast split switch proc wholebuf)
"Send block-or-clause at point to interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-switch (&optional shell dedicated fast split proc wholebuf)
"Send block-or-clause at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block-or-clause shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send block-or-clause at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block-or-clause shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-dedicated (&optional shell fast split switch proc wholebuf)
"Send block-or-clause at point to unique interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause shell t switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-dedicated-switch (&optional shell fast split proc wholebuf)
"Send block-or-clause at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block-or-clause shell t 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython (&optional dedicated fast split switch proc wholebuf)
"Send block-or-clause at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send block-or-clause at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send block-or-clause at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send block-or-clause at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send block-or-clause at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send block-or-clause at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send block-or-clause at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send block-or-clause at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send block-or-clause at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block-or-clause 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-jython (&optional dedicated fast split switch proc wholebuf)
"Send block-or-clause at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-jython-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block-or-clause 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block-or-clause 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-jython-dedicated (&optional fast split switch proc wholebuf)
"Send block-or-clause at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause 'jython t switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send block-or-clause at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block-or-clause 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python (&optional dedicated fast split switch proc wholebuf)
"Send block-or-clause at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'block-or-clause 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'block-or-clause 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'block-or-clause 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python-dedicated (&optional fast split switch proc wholebuf)
"Send block-or-clause at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'block-or-clause 'python t switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python-dedicated-switch (&optional fast split proc wholebuf)
"Send block-or-clause at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'block-or-clause 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python2 (&optional dedicated fast split switch proc wholebuf)
"Send block-or-clause at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python2-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block-or-clause 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block-or-clause 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python2-dedicated (&optional fast split switch proc wholebuf)
"Send block-or-clause at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send block-or-clause at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block-or-clause 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python3 (&optional dedicated fast split switch proc wholebuf)
"Send block-or-clause at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python3-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'block-or-clause 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send block-or-clause at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'block-or-clause 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python3-dedicated (&optional fast split switch proc wholebuf)
"Send block-or-clause at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'block-or-clause 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-block-or-clause-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send block-or-clause at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'block-or-clause 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-buffer (&optional shell dedicated fast split switch proc wholebuf)
"Send buffer at point to interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer shell dedicated switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-switch (&optional shell dedicated fast split proc wholebuf)
"Send buffer at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer shell dedicated 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send buffer at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer shell dedicated 'no-switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-dedicated (&optional shell fast split switch proc wholebuf)
"Send buffer at point to unique interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer shell t switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-dedicated-switch (&optional shell fast split proc wholebuf)
"Send buffer at point to unique interpreter and switch to result. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer shell t 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython (&optional dedicated fast split switch proc wholebuf)
"Send buffer at point to IPython interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython dedicated switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython dedicated 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython dedicated 'no-switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send buffer at point to IPython unique interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython t switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send buffer at point to IPython unique interpreter and switch to result. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython t 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send buffer at point to IPython interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython2.7 dedicated switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython2.7 dedicated 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython2.7 dedicated 'no-switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send buffer at point to IPython unique interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython2.7 t switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send buffer at point to IPython unique interpreter and switch to result. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython2.7 t 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send buffer at point to IPython interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython3 dedicated switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython3 dedicated 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython3 dedicated 'no-switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send buffer at point to IPython unique interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython3 t switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send buffer at point to IPython unique interpreter and switch to result. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'ipython3 t 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-jython (&optional dedicated fast split switch proc wholebuf)
"Send buffer at point to Jython interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'jython dedicated switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-jython-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'jython dedicated 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'jython dedicated 'no-switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-jython-dedicated (&optional fast split switch proc wholebuf)
"Send buffer at point to Jython unique interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'jython t switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send buffer at point to Jython unique interpreter and switch to result. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'jython t 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python (&optional dedicated fast split switch proc wholebuf)
"Send buffer at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python dedicated switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python dedicated 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python dedicated 'no-switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python-dedicated (&optional fast split switch proc wholebuf)
"Send buffer at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python t switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python-dedicated-switch (&optional fast split proc wholebuf)
"Send buffer at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python t 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python2 (&optional dedicated fast split switch proc wholebuf)
"Send buffer at point to Python2 interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python2 dedicated switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python2-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python2 dedicated 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python2 dedicated 'no-switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python2-dedicated (&optional fast split switch proc wholebuf)
"Send buffer at point to Python2 unique interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python2 t switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send buffer at point to Python2 unique interpreter and switch to result. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python2 t 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python3 (&optional dedicated fast split switch proc wholebuf)
"Send buffer at point to Python3 interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python3 dedicated switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python3-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python3 dedicated 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send buffer at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python3 dedicated 'no-switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python3-dedicated (&optional fast split switch proc wholebuf)
"Send buffer at point to Python3 unique interpreter. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python3 t switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-buffer-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send buffer at point to Python3 unique interpreter and switch to result. "
(interactive)
(let ((py-master-file (or py-master-file (py-fetch-py-master-file))))
(when py-master-file
(let* ((filename (expand-file-name py-master-file))
(buffer (or (get-file-buffer filename)
(find-file-noselect filename))))
(set-buffer buffer))))
(py--execute-prepare 'buffer 'python3 t 'switch (point-min) (point-max) nil fast proc wholebuf split))
(defun py-execute-class (&optional shell dedicated fast split switch proc wholebuf)
"Send class at point to interpreter. "
(interactive)
(py--execute-prepare 'class shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-class-switch (&optional shell dedicated fast split proc wholebuf)
"Send class at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'class shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-class-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send class at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'class shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-class-dedicated (&optional shell fast split switch proc wholebuf)
"Send class at point to unique interpreter. "
(interactive)
(py--execute-prepare 'class shell t switch nil fast proc wholebuf split))
(defun py-execute-class-dedicated-switch (&optional shell fast split proc wholebuf)
"Send class at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'class shell t 'switch nil fast proc wholebuf split))
(defun py-execute-class-ipython (&optional dedicated fast split switch proc wholebuf)
"Send class at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'class 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-class-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'class 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-class-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'class 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-class-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send class at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'class 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-class-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send class at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'class 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-class-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send class at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'class 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-class-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'class 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-class-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'class 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-class-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send class at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'class 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-class-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send class at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'class 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-class-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send class at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'class 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-class-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'class 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-class-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'class 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-class-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send class at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'class 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-class-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send class at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'class 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-class-jython (&optional dedicated fast split switch proc wholebuf)
"Send class at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'class 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-class-jython-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'class 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-class-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'class 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-class-jython-dedicated (&optional fast split switch proc wholebuf)
"Send class at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'class 'jython t switch nil fast proc wholebuf split))
(defun py-execute-class-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send class at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'class 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-class-python (&optional dedicated fast split switch proc wholebuf)
"Send class at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'class 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-class-python-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'class 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-class-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'class 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-class-python-dedicated (&optional fast split switch proc wholebuf)
"Send class at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'class 'python t switch nil fast proc wholebuf split))
(defun py-execute-class-python-dedicated-switch (&optional fast split proc wholebuf)
"Send class at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'class 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-class-python2 (&optional dedicated fast split switch proc wholebuf)
"Send class at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'class 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-class-python2-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'class 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-class-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'class 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-class-python2-dedicated (&optional fast split switch proc wholebuf)
"Send class at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'class 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-class-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send class at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'class 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-class-python3 (&optional dedicated fast split switch proc wholebuf)
"Send class at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'class 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-class-python3-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'class 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-class-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send class at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'class 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-class-python3-dedicated (&optional fast split switch proc wholebuf)
"Send class at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'class 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-class-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send class at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'class 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-clause (&optional shell dedicated fast split switch proc wholebuf)
"Send clause at point to interpreter. "
(interactive)
(py--execute-prepare 'clause shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-clause-switch (&optional shell dedicated fast split proc wholebuf)
"Send clause at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'clause shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-clause-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send clause at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'clause shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-clause-dedicated (&optional shell fast split switch proc wholebuf)
"Send clause at point to unique interpreter. "
(interactive)
(py--execute-prepare 'clause shell t switch nil fast proc wholebuf split))
(defun py-execute-clause-dedicated-switch (&optional shell fast split proc wholebuf)
"Send clause at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'clause shell t 'switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython (&optional dedicated fast split switch proc wholebuf)
"Send clause at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'clause 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'clause 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'clause 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send clause at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'clause 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send clause at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'clause 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send clause at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'clause 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'clause 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'clause 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send clause at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'clause 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send clause at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'clause 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send clause at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'clause 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'clause 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'clause 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send clause at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'clause 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-clause-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send clause at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'clause 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-clause-jython (&optional dedicated fast split switch proc wholebuf)
"Send clause at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'clause 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-clause-jython-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'clause 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-clause-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'clause 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-clause-jython-dedicated (&optional fast split switch proc wholebuf)
"Send clause at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'clause 'jython t switch nil fast proc wholebuf split))
(defun py-execute-clause-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send clause at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'clause 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-clause-python (&optional dedicated fast split switch proc wholebuf)
"Send clause at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'clause 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-clause-python-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'clause 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-clause-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'clause 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-clause-python-dedicated (&optional fast split switch proc wholebuf)
"Send clause at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'clause 'python t switch nil fast proc wholebuf split))
(defun py-execute-clause-python-dedicated-switch (&optional fast split proc wholebuf)
"Send clause at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'clause 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-clause-python2 (&optional dedicated fast split switch proc wholebuf)
"Send clause at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'clause 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-clause-python2-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'clause 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-clause-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'clause 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-clause-python2-dedicated (&optional fast split switch proc wholebuf)
"Send clause at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'clause 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-clause-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send clause at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'clause 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-clause-python3 (&optional dedicated fast split switch proc wholebuf)
"Send clause at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'clause 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-clause-python3-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'clause 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-clause-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send clause at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'clause 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-clause-python3-dedicated (&optional fast split switch proc wholebuf)
"Send clause at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'clause 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-clause-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send clause at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'clause 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-def (&optional shell dedicated fast split switch proc wholebuf)
"Send def at point to interpreter. "
(interactive)
(py--execute-prepare 'def shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-switch (&optional shell dedicated fast split proc wholebuf)
"Send def at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send def at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-dedicated (&optional shell fast split switch proc wholebuf)
"Send def at point to unique interpreter. "
(interactive)
(py--execute-prepare 'def shell t switch nil fast proc wholebuf split))
(defun py-execute-def-dedicated-switch (&optional shell fast split proc wholebuf)
"Send def at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def shell t 'switch nil fast proc wholebuf split))
(defun py-execute-def-ipython (&optional dedicated fast split switch proc wholebuf)
"Send def at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'def 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send def at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'def 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-def-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send def at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-def-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send def at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'def 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send def at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'def 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-def-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send def at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-def-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send def at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'def 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send def at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'def 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-def-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send def at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-def-jython (&optional dedicated fast split switch proc wholebuf)
"Send def at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'def 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-jython-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-jython-dedicated (&optional fast split switch proc wholebuf)
"Send def at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'def 'jython t switch nil fast proc wholebuf split))
(defun py-execute-def-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send def at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-def-python (&optional dedicated fast split switch proc wholebuf)
"Send def at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'def 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-python-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'def 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'def 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-python-dedicated (&optional fast split switch proc wholebuf)
"Send def at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'def 'python t switch nil fast proc wholebuf split))
(defun py-execute-def-python-dedicated-switch (&optional fast split proc wholebuf)
"Send def at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'def 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-def-python2 (&optional dedicated fast split switch proc wholebuf)
"Send def at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'def 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-python2-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-python2-dedicated (&optional fast split switch proc wholebuf)
"Send def at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'def 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-def-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send def at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-def-python3 (&optional dedicated fast split switch proc wholebuf)
"Send def at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'def 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-python3-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send def at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-python3-dedicated (&optional fast split switch proc wholebuf)
"Send def at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'def 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-def-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send def at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class (&optional shell dedicated fast split switch proc wholebuf)
"Send def-or-class at point to interpreter. "
(interactive)
(py--execute-prepare 'def-or-class shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-switch (&optional shell dedicated fast split proc wholebuf)
"Send def-or-class at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def-or-class shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send def-or-class at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def-or-class shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-dedicated (&optional shell fast split switch proc wholebuf)
"Send def-or-class at point to unique interpreter. "
(interactive)
(py--execute-prepare 'def-or-class shell t switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-dedicated-switch (&optional shell fast split proc wholebuf)
"Send def-or-class at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def-or-class shell t 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython (&optional dedicated fast split switch proc wholebuf)
"Send def-or-class at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'def-or-class 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def-or-class 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def-or-class 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send def-or-class at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'def-or-class 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send def-or-class at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def-or-class 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send def-or-class at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'def-or-class 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def-or-class 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def-or-class 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send def-or-class at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'def-or-class 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send def-or-class at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def-or-class 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send def-or-class at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'def-or-class 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def-or-class 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def-or-class 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send def-or-class at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'def-or-class 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send def-or-class at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def-or-class 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-jython (&optional dedicated fast split switch proc wholebuf)
"Send def-or-class at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'def-or-class 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-jython-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def-or-class 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def-or-class 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-jython-dedicated (&optional fast split switch proc wholebuf)
"Send def-or-class at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'def-or-class 'jython t switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send def-or-class at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def-or-class 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python (&optional dedicated fast split switch proc wholebuf)
"Send def-or-class at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'def-or-class 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'def-or-class 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'def-or-class 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python-dedicated (&optional fast split switch proc wholebuf)
"Send def-or-class at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'def-or-class 'python t switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python-dedicated-switch (&optional fast split proc wholebuf)
"Send def-or-class at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'def-or-class 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python2 (&optional dedicated fast split switch proc wholebuf)
"Send def-or-class at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'def-or-class 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python2-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def-or-class 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def-or-class 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python2-dedicated (&optional fast split switch proc wholebuf)
"Send def-or-class at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'def-or-class 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send def-or-class at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def-or-class 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python3 (&optional dedicated fast split switch proc wholebuf)
"Send def-or-class at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'def-or-class 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python3-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'def-or-class 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send def-or-class at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'def-or-class 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python3-dedicated (&optional fast split switch proc wholebuf)
"Send def-or-class at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'def-or-class 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-def-or-class-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send def-or-class at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'def-or-class 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-expression (&optional shell dedicated fast split switch proc wholebuf)
"Send expression at point to interpreter. "
(interactive)
(py--execute-prepare 'expression shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-expression-switch (&optional shell dedicated fast split proc wholebuf)
"Send expression at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'expression shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-expression-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send expression at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'expression shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-expression-dedicated (&optional shell fast split switch proc wholebuf)
"Send expression at point to unique interpreter. "
(interactive)
(py--execute-prepare 'expression shell t switch nil fast proc wholebuf split))
(defun py-execute-expression-dedicated-switch (&optional shell fast split proc wholebuf)
"Send expression at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'expression shell t 'switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython (&optional dedicated fast split switch proc wholebuf)
"Send expression at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'expression 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'expression 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'expression 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send expression at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'expression 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send expression at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'expression 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send expression at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'expression 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'expression 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'expression 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send expression at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'expression 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send expression at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'expression 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send expression at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'expression 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'expression 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'expression 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send expression at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'expression 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-expression-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send expression at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'expression 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-expression-jython (&optional dedicated fast split switch proc wholebuf)
"Send expression at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'expression 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-expression-jython-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'expression 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-expression-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'expression 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-expression-jython-dedicated (&optional fast split switch proc wholebuf)
"Send expression at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'expression 'jython t switch nil fast proc wholebuf split))
(defun py-execute-expression-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send expression at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'expression 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-expression-python (&optional dedicated fast split switch proc wholebuf)
"Send expression at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'expression 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-expression-python-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'expression 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-expression-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'expression 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-expression-python-dedicated (&optional fast split switch proc wholebuf)
"Send expression at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'expression 'python t switch nil fast proc wholebuf split))
(defun py-execute-expression-python-dedicated-switch (&optional fast split proc wholebuf)
"Send expression at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'expression 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-expression-python2 (&optional dedicated fast split switch proc wholebuf)
"Send expression at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'expression 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-expression-python2-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'expression 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-expression-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'expression 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-expression-python2-dedicated (&optional fast split switch proc wholebuf)
"Send expression at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'expression 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-expression-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send expression at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'expression 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-expression-python3 (&optional dedicated fast split switch proc wholebuf)
"Send expression at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'expression 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-expression-python3-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'expression 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-expression-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send expression at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'expression 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-expression-python3-dedicated (&optional fast split switch proc wholebuf)
"Send expression at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'expression 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-expression-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send expression at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'expression 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-indent (&optional shell dedicated fast split switch proc wholebuf)
"Send indent at point to interpreter. "
(interactive)
(py--execute-prepare 'indent shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-indent-switch (&optional shell dedicated fast split proc wholebuf)
"Send indent at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'indent shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-indent-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send indent at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'indent shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-indent-dedicated (&optional shell fast split switch proc wholebuf)
"Send indent at point to unique interpreter. "
(interactive)
(py--execute-prepare 'indent shell t switch nil fast proc wholebuf split))
(defun py-execute-indent-dedicated-switch (&optional shell fast split proc wholebuf)
"Send indent at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'indent shell t 'switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython (&optional dedicated fast split switch proc wholebuf)
"Send indent at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'indent 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'indent 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'indent 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send indent at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'indent 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send indent at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'indent 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send indent at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'indent 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'indent 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'indent 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send indent at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'indent 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send indent at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'indent 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send indent at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'indent 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'indent 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'indent 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send indent at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'indent 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-indent-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send indent at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'indent 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-indent-jython (&optional dedicated fast split switch proc wholebuf)
"Send indent at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'indent 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-indent-jython-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'indent 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-indent-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'indent 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-indent-jython-dedicated (&optional fast split switch proc wholebuf)
"Send indent at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'indent 'jython t switch nil fast proc wholebuf split))
(defun py-execute-indent-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send indent at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'indent 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-indent-python (&optional dedicated fast split switch proc wholebuf)
"Send indent at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'indent 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-indent-python-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'indent 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-indent-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'indent 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-indent-python-dedicated (&optional fast split switch proc wholebuf)
"Send indent at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'indent 'python t switch nil fast proc wholebuf split))
(defun py-execute-indent-python-dedicated-switch (&optional fast split proc wholebuf)
"Send indent at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'indent 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-indent-python2 (&optional dedicated fast split switch proc wholebuf)
"Send indent at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'indent 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-indent-python2-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'indent 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-indent-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'indent 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-indent-python2-dedicated (&optional fast split switch proc wholebuf)
"Send indent at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'indent 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-indent-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send indent at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'indent 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-indent-python3 (&optional dedicated fast split switch proc wholebuf)
"Send indent at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'indent 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-indent-python3-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'indent 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-indent-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send indent at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'indent 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-indent-python3-dedicated (&optional fast split switch proc wholebuf)
"Send indent at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'indent 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-indent-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send indent at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'indent 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-line (&optional shell dedicated fast split switch proc wholebuf)
"Send line at point to interpreter. "
(interactive)
(py--execute-prepare 'line shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-line-switch (&optional shell dedicated fast split proc wholebuf)
"Send line at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'line shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-line-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send line at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'line shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-line-dedicated (&optional shell fast split switch proc wholebuf)
"Send line at point to unique interpreter. "
(interactive)
(py--execute-prepare 'line shell t switch nil fast proc wholebuf split))
(defun py-execute-line-dedicated-switch (&optional shell fast split proc wholebuf)
"Send line at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'line shell t 'switch nil fast proc wholebuf split))
(defun py-execute-line-ipython (&optional dedicated fast split switch proc wholebuf)
"Send line at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'line 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-line-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'line 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-line-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'line 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-line-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send line at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'line 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-line-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send line at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'line 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-line-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send line at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'line 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-line-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'line 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-line-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'line 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-line-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send line at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'line 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-line-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send line at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'line 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-line-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send line at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'line 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-line-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'line 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-line-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'line 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-line-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send line at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'line 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-line-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send line at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'line 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-line-jython (&optional dedicated fast split switch proc wholebuf)
"Send line at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'line 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-line-jython-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'line 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-line-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'line 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-line-jython-dedicated (&optional fast split switch proc wholebuf)
"Send line at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'line 'jython t switch nil fast proc wholebuf split))
(defun py-execute-line-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send line at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'line 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-line-python (&optional dedicated fast split switch proc wholebuf)
"Send line at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'line 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-line-python-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'line 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-line-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'line 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-line-python-dedicated (&optional fast split switch proc wholebuf)
"Send line at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'line 'python t switch nil fast proc wholebuf split))
(defun py-execute-line-python-dedicated-switch (&optional fast split proc wholebuf)
"Send line at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'line 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-line-python2 (&optional dedicated fast split switch proc wholebuf)
"Send line at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'line 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-line-python2-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'line 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-line-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'line 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-line-python2-dedicated (&optional fast split switch proc wholebuf)
"Send line at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'line 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-line-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send line at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'line 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-line-python3 (&optional dedicated fast split switch proc wholebuf)
"Send line at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'line 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-line-python3-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'line 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-line-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send line at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'line 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-line-python3-dedicated (&optional fast split switch proc wholebuf)
"Send line at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'line 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-line-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send line at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'line 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block (&optional shell dedicated fast split switch proc wholebuf)
"Send minor-block at point to interpreter. "
(interactive)
(py--execute-prepare 'minor-block shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-minor-block-switch (&optional shell dedicated fast split proc wholebuf)
"Send minor-block at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'minor-block shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send minor-block at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'minor-block shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-minor-block-dedicated (&optional shell fast split switch proc wholebuf)
"Send minor-block at point to unique interpreter. "
(interactive)
(py--execute-prepare 'minor-block shell t switch nil fast proc wholebuf split))
(defun py-execute-minor-block-dedicated-switch (&optional shell fast split proc wholebuf)
"Send minor-block at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'minor-block shell t 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython (&optional dedicated fast split switch proc wholebuf)
"Send minor-block at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'minor-block 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'minor-block 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'minor-block 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send minor-block at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'minor-block 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send minor-block at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'minor-block 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send minor-block at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'minor-block 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'minor-block 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'minor-block 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send minor-block at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'minor-block 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send minor-block at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'minor-block 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send minor-block at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'minor-block 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'minor-block 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'minor-block 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send minor-block at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'minor-block 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-minor-block-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send minor-block at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'minor-block 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-jython (&optional dedicated fast split switch proc wholebuf)
"Send minor-block at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'minor-block 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-minor-block-jython-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'minor-block 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'minor-block 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-minor-block-jython-dedicated (&optional fast split switch proc wholebuf)
"Send minor-block at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'minor-block 'jython t switch nil fast proc wholebuf split))
(defun py-execute-minor-block-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send minor-block at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'minor-block 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python (&optional dedicated fast split switch proc wholebuf)
"Send minor-block at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'minor-block 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'minor-block 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'minor-block 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python-dedicated (&optional fast split switch proc wholebuf)
"Send minor-block at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'minor-block 'python t switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python-dedicated-switch (&optional fast split proc wholebuf)
"Send minor-block at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'minor-block 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python2 (&optional dedicated fast split switch proc wholebuf)
"Send minor-block at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'minor-block 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python2-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'minor-block 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'minor-block 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python2-dedicated (&optional fast split switch proc wholebuf)
"Send minor-block at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'minor-block 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send minor-block at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'minor-block 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python3 (&optional dedicated fast split switch proc wholebuf)
"Send minor-block at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'minor-block 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python3-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'minor-block 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send minor-block at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'minor-block 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python3-dedicated (&optional fast split switch proc wholebuf)
"Send minor-block at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'minor-block 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-minor-block-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send minor-block at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'minor-block 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph (&optional shell dedicated fast split switch proc wholebuf)
"Send paragraph at point to interpreter. "
(interactive)
(py--execute-prepare 'paragraph shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-paragraph-switch (&optional shell dedicated fast split proc wholebuf)
"Send paragraph at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'paragraph shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send paragraph at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'paragraph shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-paragraph-dedicated (&optional shell fast split switch proc wholebuf)
"Send paragraph at point to unique interpreter. "
(interactive)
(py--execute-prepare 'paragraph shell t switch nil fast proc wholebuf split))
(defun py-execute-paragraph-dedicated-switch (&optional shell fast split proc wholebuf)
"Send paragraph at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'paragraph shell t 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython (&optional dedicated fast split switch proc wholebuf)
"Send paragraph at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'paragraph 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'paragraph 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'paragraph 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send paragraph at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'paragraph 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send paragraph at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'paragraph 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send paragraph at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'paragraph 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'paragraph 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'paragraph 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send paragraph at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'paragraph 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send paragraph at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'paragraph 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send paragraph at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'paragraph 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'paragraph 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'paragraph 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send paragraph at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'paragraph 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-paragraph-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send paragraph at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'paragraph 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-jython (&optional dedicated fast split switch proc wholebuf)
"Send paragraph at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'paragraph 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-paragraph-jython-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'paragraph 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'paragraph 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-paragraph-jython-dedicated (&optional fast split switch proc wholebuf)
"Send paragraph at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'paragraph 'jython t switch nil fast proc wholebuf split))
(defun py-execute-paragraph-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send paragraph at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'paragraph 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python (&optional dedicated fast split switch proc wholebuf)
"Send paragraph at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'paragraph 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'paragraph 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'paragraph 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python-dedicated (&optional fast split switch proc wholebuf)
"Send paragraph at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'paragraph 'python t switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python-dedicated-switch (&optional fast split proc wholebuf)
"Send paragraph at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'paragraph 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python2 (&optional dedicated fast split switch proc wholebuf)
"Send paragraph at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'paragraph 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python2-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'paragraph 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'paragraph 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python2-dedicated (&optional fast split switch proc wholebuf)
"Send paragraph at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'paragraph 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send paragraph at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'paragraph 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python3 (&optional dedicated fast split switch proc wholebuf)
"Send paragraph at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'paragraph 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python3-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'paragraph 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send paragraph at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'paragraph 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python3-dedicated (&optional fast split switch proc wholebuf)
"Send paragraph at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'paragraph 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-paragraph-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send paragraph at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'paragraph 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression (&optional shell dedicated fast split switch proc wholebuf)
"Send partial-expression at point to interpreter. "
(interactive)
(py--execute-prepare 'partial-expression shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-switch (&optional shell dedicated fast split proc wholebuf)
"Send partial-expression at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'partial-expression shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send partial-expression at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'partial-expression shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-dedicated (&optional shell fast split switch proc wholebuf)
"Send partial-expression at point to unique interpreter. "
(interactive)
(py--execute-prepare 'partial-expression shell t switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-dedicated-switch (&optional shell fast split proc wholebuf)
"Send partial-expression at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'partial-expression shell t 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython (&optional dedicated fast split switch proc wholebuf)
"Send partial-expression at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'partial-expression 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'partial-expression 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'partial-expression 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send partial-expression at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'partial-expression 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send partial-expression at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'partial-expression 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send partial-expression at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'partial-expression 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'partial-expression 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'partial-expression 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send partial-expression at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'partial-expression 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send partial-expression at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'partial-expression 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send partial-expression at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'partial-expression 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'partial-expression 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'partial-expression 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send partial-expression at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'partial-expression 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send partial-expression at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'partial-expression 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-jython (&optional dedicated fast split switch proc wholebuf)
"Send partial-expression at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'partial-expression 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-jython-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'partial-expression 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'partial-expression 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-jython-dedicated (&optional fast split switch proc wholebuf)
"Send partial-expression at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'partial-expression 'jython t switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send partial-expression at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'partial-expression 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python (&optional dedicated fast split switch proc wholebuf)
"Send partial-expression at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'partial-expression 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'partial-expression 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'partial-expression 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python-dedicated (&optional fast split switch proc wholebuf)
"Send partial-expression at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'partial-expression 'python t switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python-dedicated-switch (&optional fast split proc wholebuf)
"Send partial-expression at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'partial-expression 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python2 (&optional dedicated fast split switch proc wholebuf)
"Send partial-expression at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'partial-expression 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python2-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'partial-expression 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'partial-expression 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python2-dedicated (&optional fast split switch proc wholebuf)
"Send partial-expression at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'partial-expression 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send partial-expression at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'partial-expression 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python3 (&optional dedicated fast split switch proc wholebuf)
"Send partial-expression at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'partial-expression 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python3-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'partial-expression 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send partial-expression at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'partial-expression 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python3-dedicated (&optional fast split switch proc wholebuf)
"Send partial-expression at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'partial-expression 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-partial-expression-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send partial-expression at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'partial-expression 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-region (beg end &optional shell dedicated fast split switch proc wholebuf)
"Send region at point to interpreter. "
(interactive "r")
(py--execute-prepare 'region shell dedicated switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-switch (beg end &optional shell dedicated fast split proc wholebuf)
"Send region at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive "r")
(py--execute-prepare 'region shell dedicated 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-no-switch (beg end &optional shell dedicated fast split proc wholebuf)
"Send region at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive "r")
(py--execute-prepare 'region shell dedicated 'no-switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-dedicated (beg end &optional shell fast split switch proc wholebuf)
"Send region at point to unique interpreter. "
(interactive "r")
(py--execute-prepare 'region shell t switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-dedicated-switch (beg end &optional shell fast split proc wholebuf)
"Send region at point to unique interpreter and switch to result. "
(interactive "r")
(py--execute-prepare 'region shell t 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython (beg end &optional dedicated fast split switch proc wholebuf)
"Send region at point to IPython interpreter. "
(interactive "r")
(py--execute-prepare 'region 'ipython dedicated switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive "r")
(py--execute-prepare 'region 'ipython dedicated 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython-no-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive "r")
(py--execute-prepare 'region 'ipython dedicated 'no-switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython-dedicated (beg end &optional fast split switch proc wholebuf)
"Send region at point to IPython unique interpreter. "
(interactive "r")
(py--execute-prepare 'region 'ipython t switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython-dedicated-switch (beg end &optional fast split proc wholebuf)
"Send region at point to IPython unique interpreter and switch to result. "
(interactive "r")
(py--execute-prepare 'region 'ipython t 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython2.7 (beg end &optional dedicated fast split switch proc wholebuf)
"Send region at point to IPython interpreter. "
(interactive "r")
(py--execute-prepare 'region 'ipython2.7 dedicated switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython2.7-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive "r")
(py--execute-prepare 'region 'ipython2.7 dedicated 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython2.7-no-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive "r")
(py--execute-prepare 'region 'ipython2.7 dedicated 'no-switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython2.7-dedicated (beg end &optional fast split switch proc wholebuf)
"Send region at point to IPython unique interpreter. "
(interactive "r")
(py--execute-prepare 'region 'ipython2.7 t switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython2.7-dedicated-switch (beg end &optional fast split proc wholebuf)
"Send region at point to IPython unique interpreter and switch to result. "
(interactive "r")
(py--execute-prepare 'region 'ipython2.7 t 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython3 (beg end &optional dedicated fast split switch proc wholebuf)
"Send region at point to IPython interpreter. "
(interactive "r")
(py--execute-prepare 'region 'ipython3 dedicated switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython3-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive "r")
(py--execute-prepare 'region 'ipython3 dedicated 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython3-no-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive "r")
(py--execute-prepare 'region 'ipython3 dedicated 'no-switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython3-dedicated (beg end &optional fast split switch proc wholebuf)
"Send region at point to IPython unique interpreter. "
(interactive "r")
(py--execute-prepare 'region 'ipython3 t switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-ipython3-dedicated-switch (beg end &optional fast split proc wholebuf)
"Send region at point to IPython unique interpreter and switch to result. "
(interactive "r")
(py--execute-prepare 'region 'ipython3 t 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-jython (beg end &optional dedicated fast split switch proc wholebuf)
"Send region at point to Jython interpreter. "
(interactive "r")
(py--execute-prepare 'region 'jython dedicated switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-jython-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive "r")
(py--execute-prepare 'region 'jython dedicated 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-jython-no-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive "r")
(py--execute-prepare 'region 'jython dedicated 'no-switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-jython-dedicated (beg end &optional fast split switch proc wholebuf)
"Send region at point to Jython unique interpreter. "
(interactive "r")
(py--execute-prepare 'region 'jython t switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-jython-dedicated-switch (beg end &optional fast split proc wholebuf)
"Send region at point to Jython unique interpreter and switch to result. "
(interactive "r")
(py--execute-prepare 'region 'jython t 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python (beg end &optional dedicated fast split switch proc wholebuf)
"Send region at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive "r")
(py--execute-prepare 'region 'python dedicated switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive "r")
(py--execute-prepare 'region 'python dedicated 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python-no-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive "r")
(py--execute-prepare 'region 'python dedicated 'no-switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python-dedicated (beg end &optional fast split switch proc wholebuf)
"Send region at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive "r")
(py--execute-prepare 'region 'python t switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python-dedicated-switch (beg end &optional fast split proc wholebuf)
"Send region at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive "r")
(py--execute-prepare 'region 'python t 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python2 (beg end &optional dedicated fast split switch proc wholebuf)
"Send region at point to Python2 interpreter. "
(interactive "r")
(py--execute-prepare 'region 'python2 dedicated switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python2-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive "r")
(py--execute-prepare 'region 'python2 dedicated 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python2-no-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive "r")
(py--execute-prepare 'region 'python2 dedicated 'no-switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python2-dedicated (beg end &optional fast split switch proc wholebuf)
"Send region at point to Python2 unique interpreter. "
(interactive "r")
(py--execute-prepare 'region 'python2 t switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python2-dedicated-switch (beg end &optional fast split proc wholebuf)
"Send region at point to Python2 unique interpreter and switch to result. "
(interactive "r")
(py--execute-prepare 'region 'python2 t 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python3 (beg end &optional dedicated fast split switch proc wholebuf)
"Send region at point to Python3 interpreter. "
(interactive "r")
(py--execute-prepare 'region 'python3 dedicated switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python3-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive "r")
(py--execute-prepare 'region 'python3 dedicated 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python3-no-switch (beg end &optional dedicated fast split proc wholebuf)
"Send region at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive "r")
(py--execute-prepare 'region 'python3 dedicated 'no-switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python3-dedicated (beg end &optional fast split switch proc wholebuf)
"Send region at point to Python3 unique interpreter. "
(interactive "r")
(py--execute-prepare 'region 'python3 t switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-region-python3-dedicated-switch (beg end &optional fast split proc wholebuf)
"Send region at point to Python3 unique interpreter and switch to result. "
(interactive "r")
(py--execute-prepare 'region 'python3 t 'switch (or beg (region-beginning)) (or end (region-end)) nil fast proc wholebuf split))
(defun py-execute-statement (&optional shell dedicated fast split switch proc wholebuf)
"Send statement at point to interpreter. "
(interactive)
(py--execute-prepare 'statement shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-statement-switch (&optional shell dedicated fast split proc wholebuf)
"Send statement at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'statement shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-statement-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send statement at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'statement shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-statement-dedicated (&optional shell fast split switch proc wholebuf)
"Send statement at point to unique interpreter. "
(interactive)
(py--execute-prepare 'statement shell t switch nil fast proc wholebuf split))
(defun py-execute-statement-dedicated-switch (&optional shell fast split proc wholebuf)
"Send statement at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'statement shell t 'switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython (&optional dedicated fast split switch proc wholebuf)
"Send statement at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'statement 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'statement 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'statement 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send statement at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'statement 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send statement at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'statement 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send statement at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'statement 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'statement 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'statement 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send statement at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'statement 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send statement at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'statement 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send statement at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'statement 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'statement 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'statement 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send statement at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'statement 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-statement-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send statement at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'statement 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-statement-jython (&optional dedicated fast split switch proc wholebuf)
"Send statement at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'statement 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-statement-jython-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'statement 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-statement-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'statement 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-statement-jython-dedicated (&optional fast split switch proc wholebuf)
"Send statement at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'statement 'jython t switch nil fast proc wholebuf split))
(defun py-execute-statement-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send statement at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'statement 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-statement-python (&optional dedicated fast split switch proc wholebuf)
"Send statement at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'statement 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-statement-python-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'statement 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-statement-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'statement 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-statement-python-dedicated (&optional fast split switch proc wholebuf)
"Send statement at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'statement 'python t switch nil fast proc wholebuf split))
(defun py-execute-statement-python-dedicated-switch (&optional fast split proc wholebuf)
"Send statement at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'statement 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-statement-python2 (&optional dedicated fast split switch proc wholebuf)
"Send statement at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'statement 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-statement-python2-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'statement 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-statement-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'statement 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-statement-python2-dedicated (&optional fast split switch proc wholebuf)
"Send statement at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'statement 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-statement-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send statement at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'statement 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-statement-python3 (&optional dedicated fast split switch proc wholebuf)
"Send statement at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'statement 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-statement-python3-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'statement 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-statement-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send statement at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'statement 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-statement-python3-dedicated (&optional fast split switch proc wholebuf)
"Send statement at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'statement 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-statement-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send statement at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'statement 'python3 t 'switch nil fast proc wholebuf split))
(defun py-execute-top-level (&optional shell dedicated fast split switch proc wholebuf)
"Send top-level at point to interpreter. "
(interactive)
(py--execute-prepare 'top-level shell dedicated switch nil fast proc wholebuf split))
(defun py-execute-top-level-switch (&optional shell dedicated fast split proc wholebuf)
"Send top-level at point to interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'top-level shell dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-no-switch (&optional shell dedicated fast split proc wholebuf)
"Send top-level at point to interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'top-level shell dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-top-level-dedicated (&optional shell fast split switch proc wholebuf)
"Send top-level at point to unique interpreter. "
(interactive)
(py--execute-prepare 'top-level shell t switch nil fast proc wholebuf split))
(defun py-execute-top-level-dedicated-switch (&optional shell fast split proc wholebuf)
"Send top-level at point to unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'top-level shell t 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython (&optional dedicated fast split switch proc wholebuf)
"Send top-level at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'top-level 'ipython dedicated switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'top-level 'ipython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython-no-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'top-level 'ipython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython-dedicated (&optional fast split switch proc wholebuf)
"Send top-level at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'top-level 'ipython t switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython-dedicated-switch (&optional fast split proc wholebuf)
"Send top-level at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'top-level 'ipython t 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython2.7 (&optional dedicated fast split switch proc wholebuf)
"Send top-level at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'top-level 'ipython2.7 dedicated switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython2.7-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'top-level 'ipython2.7 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython2.7-no-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'top-level 'ipython2.7 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython2.7-dedicated (&optional fast split switch proc wholebuf)
"Send top-level at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'top-level 'ipython2.7 t switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython2.7-dedicated-switch (&optional fast split proc wholebuf)
"Send top-level at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'top-level 'ipython2.7 t 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython3 (&optional dedicated fast split switch proc wholebuf)
"Send top-level at point to IPython interpreter. "
(interactive)
(py--execute-prepare 'top-level 'ipython3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython3-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to IPython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'top-level 'ipython3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython3-no-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to IPython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'top-level 'ipython3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython3-dedicated (&optional fast split switch proc wholebuf)
"Send top-level at point to IPython unique interpreter. "
(interactive)
(py--execute-prepare 'top-level 'ipython3 t switch nil fast proc wholebuf split))
(defun py-execute-top-level-ipython3-dedicated-switch (&optional fast split proc wholebuf)
"Send top-level at point to IPython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'top-level 'ipython3 t 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-jython (&optional dedicated fast split switch proc wholebuf)
"Send top-level at point to Jython interpreter. "
(interactive)
(py--execute-prepare 'top-level 'jython dedicated switch nil fast proc wholebuf split))
(defun py-execute-top-level-jython-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to Jython interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'top-level 'jython dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-jython-no-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to Jython interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'top-level 'jython dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-top-level-jython-dedicated (&optional fast split switch proc wholebuf)
"Send top-level at point to Jython unique interpreter. "
(interactive)
(py--execute-prepare 'top-level 'jython t switch nil fast proc wholebuf split))
(defun py-execute-top-level-jython-dedicated-switch (&optional fast split proc wholebuf)
"Send top-level at point to Jython unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'top-level 'jython t 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-python (&optional dedicated fast split switch proc wholebuf)
"Send top-level at point to default interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'top-level 'python dedicated switch nil fast proc wholebuf split))
(defun py-execute-top-level-python-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to default interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'top-level 'python dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-python-no-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to default interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p'
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'top-level 'python dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-top-level-python-dedicated (&optional fast split switch proc wholebuf)
"Send top-level at point to default unique interpreter.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'top-level 'python t switch nil fast proc wholebuf split))
(defun py-execute-top-level-python-dedicated-switch (&optional fast split proc wholebuf)
"Send top-level at point to default unique interpreter and switch to result.
For `default' see value of `py-shell-name'"
(interactive)
(py--execute-prepare 'top-level 'python t 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-python2 (&optional dedicated fast split switch proc wholebuf)
"Send top-level at point to Python2 interpreter. "
(interactive)
(py--execute-prepare 'top-level 'python2 dedicated switch nil fast proc wholebuf split))
(defun py-execute-top-level-python2-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to Python2 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'top-level 'python2 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-python2-no-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to Python2 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'top-level 'python2 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-top-level-python2-dedicated (&optional fast split switch proc wholebuf)
"Send top-level at point to Python2 unique interpreter. "
(interactive)
(py--execute-prepare 'top-level 'python2 t switch nil fast proc wholebuf split))
(defun py-execute-top-level-python2-dedicated-switch (&optional fast split proc wholebuf)
"Send top-level at point to Python2 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'top-level 'python2 t 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-python3 (&optional dedicated fast split switch proc wholebuf)
"Send top-level at point to Python3 interpreter. "
(interactive)
(py--execute-prepare 'top-level 'python3 dedicated switch nil fast proc wholebuf split))
(defun py-execute-top-level-python3-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to Python3 interpreter.
Switch to output buffer. Ignores `py-switch-buffers-on-execute-p'. "
(interactive)
(py--execute-prepare 'top-level 'python3 dedicated 'switch nil fast proc wholebuf split))
(defun py-execute-top-level-python3-no-switch (&optional dedicated fast split proc wholebuf)
"Send top-level at point to Python3 interpreter.
Keep current buffer. Ignores `py-switch-buffers-on-execute-p' "
(interactive)
(py--execute-prepare 'top-level 'python3 dedicated 'no-switch nil fast proc wholebuf split))
(defun py-execute-top-level-python3-dedicated (&optional fast split switch proc wholebuf)
"Send top-level at point to Python3 unique interpreter. "
(interactive)
(py--execute-prepare 'top-level 'python3 t switch nil fast proc wholebuf split))
(defun py-execute-top-level-python3-dedicated-switch (&optional fast split proc wholebuf)
"Send top-level at point to Python3 unique interpreter and switch to result. "
(interactive)
(py--execute-prepare 'top-level 'python3 t 'switch nil fast proc wholebuf split))
;; python-abbrev-propose
(defun py-edit-abbrevs ()
"Jumps to `python-mode-abbrev-table' in a buffer containing lists of abbrev definitions.
You can edit them and type \\\\[edit-abbrevs-redefine] to redefine abbrevs
according to your editing.
Buffer contains a header line for each abbrev table,
which is the abbrev table name in parentheses.
This is followed by one line per abbrev in that table:
NAME USECOUNT EXPANSION HOOK
where NAME and EXPANSION are strings with quotes,
USECOUNT is an integer, and HOOK is any valid function
or may be omitted (it is usually omitted). "
(interactive)
(save-excursion
(let ((mat (abbrev-table-name local-abbrev-table)))
(prepare-abbrev-list-buffer)
(set-buffer "*Abbrevs*")
(switch-to-buffer (current-buffer))
(goto-char (point-min))
(search-forward (concat "(" (format "%s" mat))))))
(defun py--add-abbrev-propose (table type arg &optional dont-ask)
(save-excursion
(let ((orig (point))
proposal exp name)
(while (< 0 arg)
(py-beginning-of-partial-expression)
(when (looking-at "[[:alpha:]]")
(setq proposal (concat (downcase (match-string-no-properties 0)) proposal)))
(setq arg (1- arg)))
(setq exp (buffer-substring-no-properties (point) orig))
(setq name
;; ask only when interactive
(if dont-ask
proposal
(read-string (format (if exp "%s abbrev for \"%s\": "
"Undefine %s abbrev: ")
type exp) proposal)))
(set-text-properties 0 (length name) nil name)
(when (or (null exp)
(not (abbrev-expansion name table))
(y-or-n-p (format "%s expands to \"%s\"; redefine? "
name (abbrev-expansion name table))))
(define-abbrev table (downcase name) exp)))))
(defun py-add-abbrev (arg)
"Defines python-mode specific abbrev for last expressions before point.
Argument is how many `py-partial-expression's form the expansion; or zero means the region is the expansion.
Reads the abbreviation in the minibuffer; with numeric arg it displays a proposal for an abbrev.
Proposal is composed from the initial character(s) of the
expansion.
Don't use this function in a Lisp program; use `define-abbrev' instead."
(interactive "p")
(save-excursion
(py--add-abbrev-propose
(if only-global-abbrevs
global-abbrev-table
(or local-abbrev-table
(error "No per-mode abbrev table")))
"Mode" arg)))
;; python-components-paragraph
(defun py-fill-paren (&optional justify)
"Paren fill function for `py-fill-paragraph'.
JUSTIFY should be used (if applicable) as in `fill-paragraph'."
(interactive "*P")
(save-restriction
(save-excursion
(let ((pps (parse-partial-sexp (point-min) (point))))
(if (nth 1 pps)
(let* ((beg (copy-marker (nth 1 pps)))
(end (and beg (save-excursion (goto-char (nth 1 pps))
(forward-list))))
(paragraph-start "\f\\|[ \t]*$")
(paragraph-separate ","))
(when end (narrow-to-region beg end)
(fill-region beg end justify)
(while (not (eobp))
(forward-line 1)
(py-indent-line)
(goto-char (line-end-position))))))))))
(defun py-fill-string-django (&optional justify)
"Fill docstring according to Django's coding standards style.
\"\"\"
Process foo, return bar.
\"\"\"
\"\"\"
Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
See available styles at `py-fill-paragraph' or var `py-docstring-style'
"
(interactive "*P")
(py-fill-string justify 'django t))
(defun py-fill-string-onetwo (&optional justify)
"One newline and start and Two at end style.
\"\"\"Process foo, return bar.\"\"\"
\"\"\"
Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
See available styles at `py-fill-paragraph' or var `py-docstring-style'
"
(interactive "*P")
(py-fill-string justify 'onetwo t))
(defun py-fill-string-pep-257 (&optional justify)
"PEP-257 with 2 newlines at end of string.
\"\"\"Process foo, return bar.\"\"\"
\"\"\"Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
See available styles at `py-fill-paragraph' or var `py-docstring-style'
"
(interactive "*P")
(py-fill-string justify 'pep-257 t))
(defun py-fill-string-pep-257-nn (&optional justify)
"PEP-257 with 1 newline at end of string.
\"\"\"Process foo, return bar.\"\"\"
\"\"\"Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
See available styles at `py-fill-paragraph' or var `py-docstring-style'
"
(interactive "*P")
(py-fill-string justify 'pep-257-nn t))
(defun py-fill-string-symmetric (&optional justify)
"Symmetric style.
\"\"\"Process foo, return bar.\"\"\"
\"\"\"
Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
See available styles at `py-fill-paragraph' or var `py-docstring-style'
"
(interactive "*P")
(py-fill-string justify 'symmetric t))
(defun py-set-nil-docstring-style ()
"Set py-docstring-style to 'nil"
(interactive)
(setq py-docstring-style 'nil)
(when (and (called-interactively-p 'any) py-verbose-p)
(message "docstring-style set to: %s" py-docstring-style)))
(defun py-set-pep-257-nn-docstring-style ()
"Set py-docstring-style to 'pep-257-nn"
(interactive)
(setq py-docstring-style 'pep-257-nn)
(when (and (called-interactively-p 'any) py-verbose-p)
(message "docstring-style set to: %s" py-docstring-style)))
(defun py-set-pep-257-docstring-style ()
"Set py-docstring-style to 'pep-257"
(interactive)
(setq py-docstring-style 'pep-257)
(when (and (called-interactively-p 'any) py-verbose-p)
(message "docstring-style set to: %s" py-docstring-style)))
(defun py-set-django-docstring-style ()
"Set py-docstring-style to 'django"
(interactive)
(setq py-docstring-style 'django)
(when (and (called-interactively-p 'any) py-verbose-p)
(message "docstring-style set to: %s" py-docstring-style)))
(defun py-set-symmetric-docstring-style ()
"Set py-docstring-style to 'symmetric"
(interactive)
(setq py-docstring-style 'symmetric)
(when (and (called-interactively-p 'any) py-verbose-p)
(message "docstring-style set to: %s" py-docstring-style)))
(defun py-set-onetwo-docstring-style ()
"Set py-docstring-style to 'onetwo"
(interactive)
(setq py-docstring-style 'onetwo)
(when (and (called-interactively-p 'any) py-verbose-p)
(message "docstring-style set to: %s" py-docstring-style)))
(defun py-fill-comment (&optional justify)
"Fill the comment paragraph at point"
(interactive "*P")
(let (;; Non-nil if the current line contains a comment.
has-comment
;; If has-comment, the appropriate fill-prefix (format "%s" r the comment.
comment-fill-prefix)
;; Figure out what kind of comment we are looking at.
(save-excursion
(beginning-of-line)
(cond
;; A line with nothing but a comment on it?
((looking-at "[ \t]*#[# \t]*")
(setq has-comment t
comment-fill-prefix (buffer-substring (match-beginning 0)
(match-end 0))))
;; A line with some code, followed by a comment? Remember that the hash
;; which starts the comment shouldn't be part of a string or character.
((progn
(while (not (looking-at "#\\|$"))
(skip-chars-forward "^#\n\"'\\")
(cond
((eq (char-after (point)) ?\\) (forward-char 2))
((memq (char-after (point)) '(?\" ?')) (forward-sexp 1))))
(looking-at "#+[\t ]*"))
(setq has-comment t)
(setq comment-fill-prefix
(concat (make-string (current-column) ? )
(buffer-substring (match-beginning 0) (match-end 0)))))))
(if (not has-comment)
(fill-paragraph justify)
;; Narrow to include only the comment, and then fill the region.
(save-restriction
(narrow-to-region
;; Find the first line we should include in the region to fill.
(save-excursion
(while (and (zerop (forward-line -1))
(looking-at "^[ \t]*#")))
;; We may have gone to far. Go forward again.
(or (looking-at "^[ \t]*#")
(forward-line 1))
(point))
;; Find the beginning of the first line past the region to fill.
(save-excursion
(while (progn (forward-line 1)
(looking-at "^[ \t]*#")))
(point)))
;; Lines with only hashes on them can be paragraph boundaries.
(let ((paragraph-start (concat paragraph-start "\\|[ \t#]*$"))
(paragraph-separate (concat paragraph-separate "\\|[ \t#]*$"))
(fill-prefix comment-fill-prefix))
(fill-paragraph justify))))
t))
(defun py-fill-labelled-string (beg end)
"Fill string or paragraph containing lines starting with label
See lp:1066489 "
(interactive "r*")
(let ((end (copy-marker end))
(last (copy-marker (point)))
this-beg)
(save-excursion
(save-restriction
;; (narrow-to-region beg end)
(goto-char beg)
(skip-chars-forward " \t\r\n\f")
(if (looking-at py-labelled-re)
(progn
(setq this-beg (line-beginning-position))
(goto-char (match-end 0))
(while (and (not (eobp)) (re-search-forward py-labelled-re end t 1)(< last (match-beginning 0))(setq last (match-beginning 0)))
(save-match-data (fill-region this-beg (1- (line-beginning-position))))
(setq this-beg (line-beginning-position))
(goto-char (match-end 0)))))))))
(defun py--in-or-behind-or-before-a-docstring ()
(interactive "*")
(save-excursion
(let* ((raw-pps (nth 8 (parse-partial-sexp (point-min) (point))))
;; ;; maybe just behind a string
(n8 (or raw-pps
;; maybe in front of a string
(back-to-indentation)
(nth 8 (parse-partial-sexp (point-min) (point)))))
(n8pps (or n8
(when
(equal (string-to-syntax "|")
(syntax-after (point)))
(and
(< 0 (skip-chars-forward "\"'"))
(nth 8 (parse-partial-sexp (point-min) (point))))))))
(and n8pps (py--docstring-p n8pps)))))
(defun py--string-fence-delete-spaces (&optional start)
"Delete spaces following or preceding delimiters of string at point. "
(interactive "*")
(let ((beg (or start (nth 8 (parse-partial-sexp (point-min) (point))))))
(save-excursion
(goto-char beg)
(skip-chars-forward "\"'rRuU")
(delete-region (point) (progn (skip-chars-forward " \t\r\n\f")(point)))
(goto-char beg)
(forward-char 1)
(skip-syntax-forward "^\|")
(skip-chars-backward "\"'rRuU")
;; (delete-region (point) (progn (skip-chars-backward " \t\r\n\f")(point)))
)))
(defun py--skip-raw-string-front-fence ()
"Skip forward chars u, U, r, R followed by string-delimiters. "
(when (member (char-after) (list ?u ?U ?r ?R))
(forward-char 1))
(skip-chars-forward "\'\""))
(defun py--fill-fix-end (thisend orig docstring delimiters-style)
;; Add the number of newlines indicated by the selected style
;; at the end.
;; (widen)
(goto-char thisend)
(skip-chars-backward "\"'\n ")
(delete-region (point) (progn (skip-chars-forward " \t\r\n\f") (point)))
(unless (eq (char-after) ?\n)
(and
(cdr delimiters-style)
(or (newline (cdr delimiters-style)) t)))
;; (py-indent-region docstring thisend)
(goto-char orig))
(defun py--fill-docstring-base (thisbeg thisend style multi-line-p first-line-p beg end py-current-indent orig docstring)
;; (widen)
;; fill-paragraph causes wrong indent, lp:1397936
;; (narrow-to-region thisbeg thisend)
(let ((delimiters-style
(case style
;; delimiters-style is a cons cell with the form
;; (START-NEWLINES . END-NEWLINES). When any of the sexps
;; is NIL means to not add any newlines for start or end
;; of docstring. See `py-docstring-style' for a
;; graphic idea of each style.
(django (cons 1 1))
(onetwo (and multi-line-p (cons 1 2)))
(pep-257 (and multi-line-p (cons nil 2)))
(pep-257-nn (and multi-line-p (cons nil 1)))
(symmetric (and multi-line-p (cons 1 1))))))
;; (save-excursion
(when style
;; Add the number of newlines indicated by the selected style
;; at the start.
(goto-char thisbeg)
(py--skip-raw-string-front-fence)
(skip-chars-forward "\'\"")
(when
(car delimiters-style)
(unless (or (empty-line-p)(eolp))
(newline (car delimiters-style))))
(indent-region beg end py-current-indent))
(when multi-line-p
(goto-char thisbeg)
(py--skip-raw-string-front-fence)
(skip-chars-forward " \t\r\n\f")
(forward-line 1)
(beginning-of-line)
(unless (empty-line-p) (newline)))
(py--fill-fix-end thisend orig docstring delimiters-style)))
(defun py--fill-docstring-last-line (thisend beg end)
(widen)
;; (narrow-to-region thisbeg thisend)
(goto-char thisend)
(skip-chars-backward "\"'")
(delete-region (point) (progn (skip-chars-backward " \t\r\n\f")(point)))
;; (narrow-to-region beg end)
(fill-region beg end)
(setq multi-line-p (string-match "\n" (buffer-substring-no-properties beg end)))
(when multi-line-p
;; adjust the region to fill according to style
(goto-char end)))
;; (py--fill-docstring-base thisbeg thisend style multi-line-p first-line-p beg end py-current-indent orig docstring))
;; (goto-char orig))
(defun py--fill-docstring-first-line (beg end thisbeg thisend style)
"Refill first line after newline maybe. "
(fill-region beg (line-end-position))
(forward-line 1)
(fill-region (line-beginning-position) end)
(save-restriction
(widen)
(setq multi-line-p (string-match "\n" (buffer-substring-no-properties thisbeg thisend))))
(when multi-line-p
;; adjust the region to fill according to style
(goto-char beg)
(skip-chars-forward "\"'")
;; style might be nil
(when style
(unless (or (eq style 'pep-257-nn)(eq style 'pep-257)(eq (char-after) ?\n))
(newline-and-indent)
;; if TQS is at a single line, re-fill remaining line
(fill-region (point) end)))))
(defun py--fill-docstring (justify style docstring orig py-current-indent)
;; Delete spaces after/before string fence
(py--string-fence-delete-spaces docstring)
(let* ((thisbeg (copy-marker docstring))
(thisend (copy-marker
(progn
(goto-char thisbeg)
(py--skip-raw-string-front-fence)
(skip-syntax-forward "^\|")
(point))))
(parabeg (progn (goto-char orig) (py--beginning-of-paragraph-position)))
(paraend (progn (goto-char orig) (py--end-of-paragraph-position)))
;; if paragraph is a substring, take it
(beg (copy-marker (if (< thisbeg parabeg) parabeg thisbeg)))
(end (copy-marker (if (< thisend paraend) thisend paraend)))
(multi-line-p (string-match "\n" (buffer-substring-no-properties thisbeg thisend)))
first-line-p)
;; (narrow-to-region beg end)
(goto-char beg)
(setq first-line-p (member (char-after) (list ?\" ?\' ?u ?U ?r ?R)))
(cond ((string-match (concat "^" py-labelled-re) (buffer-substring-no-properties beg end))
(py-fill-labelled-string beg end))
(first-line-p
(py--fill-docstring-first-line beg end thisbeg thisend style))
((save-excursion (goto-char end)
(or (member (char-after) (list ?\" ?\'))
(member (char-before) (list ?\" ?\'))))
(py--fill-docstring-last-line thisend beg end))
(t ;; (narrow-to-region beg end)
(fill-region beg end justify)))
(py--fill-docstring-base thisbeg thisend style multi-line-p first-line-p beg end py-current-indent orig docstring)))
(defun py-fill-string (&optional justify style docstring)
"String fill function for `py-fill-paragraph'.
JUSTIFY should be used (if applicable) as in `fill-paragraph'.
Fill according to `py-docstring-style' "
(interactive
(list
(progn
(barf-if-buffer-read-only)
(list (if current-prefix-arg 'full) t))
py-docstring-style
(or docstring (py--in-or-behind-or-before-a-docstring))))
(let* ((pps (parse-partial-sexp (point-min) (point)))
(indent (save-excursion (and (nth 3 pps) (goto-char (nth 8 pps)) (current-indentation))))
;; fill-paragraph sets orig
(orig (if (boundp 'orig) (copy-marker orig) (copy-marker (point))))
(docstring (if (and docstring (not (number-or-marker-p docstring)))
(py--in-or-behind-or-before-a-docstring)
docstring)))
(if docstring
(py--fill-docstring justify style docstring orig indent)
(py-fill-paragraph justify))))
(defun py-fill-paragraph (&optional justify)
(interactive "*")
(save-excursion
(save-restriction
(window-configuration-to-register py-windows-config-register)
(let* ((pps (parse-partial-sexp (point-min) (point)))
(docstring (unless (not py-docstring-style)(py--in-or-behind-or-before-a-docstring)))
(fill-column py-comment-fill-column))
(cond ((or (nth 4 pps)
(and (bolp) (looking-at "[ \t]*#[# \t]*")))
(py-fill-comment))
(docstring
(setq fill-column py-docstring-fill-column)
(py-fill-string justify py-docstring-style docstring))
(t
(let* ((beg (save-excursion
(if (looking-at paragraph-start)
(point)
(backward-paragraph)
(when (looking-at paragraph-start)
(point)))))
(end
(when beg
(save-excursion
(forward-paragraph)
(when (looking-at paragraph-separate)
(point))))))
(and beg end (fill-region beg end))))))
(jump-to-register py-windows-config-register))))
;; python-components-shift-forms
(defun py-shift-left (&optional count start end)
"Dedent region according to `py-indent-offset' by COUNT times.
If no region is active, current line is dedented.
Returns indentation reached. "
(interactive "p")
(let ((erg (py--shift-intern (- count) start end)))
(when (and (called-interactively-p 'any) py-verbose-p) (message "%s" erg))
erg))
(defun py-shift-right (&optional count beg end)
"Indent region according to `py-indent-offset' by COUNT times.
If no region is active, current line is indented.
Returns indentation reached. "
(interactive "p")
(let ((erg (py--shift-intern count beg end)))
(when (and (called-interactively-p 'any) py-verbose-p) (message "%s" erg))
erg))
(defun py--shift-intern (count &optional start end)
(save-excursion
(let* ((inhibit-point-motion-hooks t)
deactivate-mark
(beg (cond (start)
;; (use-region-p)
((and (mark) (not (eq (mark) (point))))
(save-excursion
(goto-char
(region-beginning))))
(t (line-beginning-position))))
(end (cond (end)
;; (use-region-p)
((and (mark) (not (eq (mark) (point))))
(save-excursion
(goto-char
(region-end))))
(t (line-end-position)))))
(setq beg (copy-marker beg))
(setq end (copy-marker end))
(if (< 0 count)
(indent-rigidly beg end py-indent-offset)
(indent-rigidly beg end (- py-indent-offset)))
(push-mark beg t)
(goto-char end)
(skip-chars-backward " \t\r\n\f"))
(py-indentation-of-statement)))
(defun py--shift-forms-base (form arg &optional beg end)
(let* ((begform (concat "py-backward-" form))
(endform (concat "py-forward-" form))
(orig (copy-marker (point)))
(beg (cond (beg)
;; ((and (string-match "region" form) (mark) (not (eq (mark) (point)))(region-beginning)))
((use-region-p)
(save-excursion
(goto-char (region-beginning))
(line-beginning-position)))
(t (save-excursion
(if
(ignore-errors (funcall (car (read-from-string begform))))
(line-beginning-position)
(error "py--shift-forms-base: No active region"))))))
(end (cond (end)
(
;; (and (mark) (not (eq (mark) (point))))
(use-region-p)
(region-end))
(t (funcall (car (read-from-string endform))))))
(erg (py--shift-intern arg beg end)))
(goto-char orig)
erg))
(defun py-shift-block-right (&optional arg)
"Indent block by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "block" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-block-left (&optional arg)
"Dedent block by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "block" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-block-or-clause-right (&optional arg)
"Indent block-or-clause by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "block-or-clause" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-block-or-clause-left (&optional arg)
"Dedent block-or-clause by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "block-or-clause" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-class-right (&optional arg)
"Indent class by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "class" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-class-left (&optional arg)
"Dedent class by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "class" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-clause-right (&optional arg)
"Indent clause by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "clause" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-clause-left (&optional arg)
"Dedent clause by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "clause" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-comment-right (&optional arg)
"Indent comment by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "comment" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-comment-left (&optional arg)
"Dedent comment by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "comment" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-def-right (&optional arg)
"Indent def by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "def" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-def-left (&optional arg)
"Dedent def by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "def" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-def-or-class-right (&optional arg)
"Indent def-or-class by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "def-or-class" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-def-or-class-left (&optional arg)
"Dedent def-or-class by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "def-or-class" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-indent-right (&optional arg)
"Indent indent by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "indent" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-indent-left (&optional arg)
"Dedent indent by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "indent" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-minor-block-right (&optional arg)
"Indent minor-block by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "minor-block" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-minor-block-left (&optional arg)
"Dedent minor-block by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "minor-block" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-paragraph-right (&optional arg)
"Indent paragraph by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "paragraph" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-paragraph-left (&optional arg)
"Dedent paragraph by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "paragraph" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-region-right (&optional arg)
"Indent region by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "region" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-region-left (&optional arg)
"Dedent region by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "region" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-statement-right (&optional arg)
"Indent statement by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "statement" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-statement-left (&optional arg)
"Dedent statement by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "statement" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-top-level-right (&optional arg)
"Indent top-level by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "top-level" (or arg py-indent-offset))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-shift-top-level-left (&optional arg)
"Dedent top-level by COUNT spaces.
COUNT defaults to `py-indent-offset',
use \[universal-argument] to specify a different value.
Returns outmost indentation reached. "
(interactive "*P")
(let ((erg (py--shift-forms-base "top-level" (- (or arg py-indent-offset)))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
;; python-components-execute-file
;; Execute file commands
(defun py-execute-file-python (&optional filename)
"Send file to Python default interpreter."
(interactive "fFile: ")
(py--execute-prepare filename "python" nil nil nil nil t))
(defun py-execute-file-python-switch (&optional filename)
"Send file to Python default interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python" nil 'switch nil nil t))
(defun py-execute-file-python-no-switch (&optional filename)
"Send file to Python default interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python" nil 'no-switch nil nil t))
(defun py-execute-file-python-dedicated (&optional filename)
"Send file to Python default interpreter.
Uses a dedicated shell."
(interactive "fFile: ")
(py--execute-prepare filename "python" 'dedicated nil nil nil t))
(defun py-execute-file-python-dedicated-switch (&optional filename)
"Send file to Python default interpreter.
Uses a dedicated shell.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python" 'dedicated 'switch nil nil t))
(defun py-execute-file-ipython (&optional filename)
"Send file to a Ipython interpreter."
(interactive "fFile: ")
(py--execute-prepare filename "ipython" nil nil nil nil t))
(defun py-execute-file-ipython-switch (&optional filename)
"Send file to a Ipython interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "ipython" nil 'switch nil nil t))
(defun py-execute-file-ipython-no-switch (&optional filename)
"Send file to a Ipython interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"nil\""
(interactive "fFile: ")
(py--execute-prepare filename "ipython" nil 'no-switch nil nil t))
(defun py-execute-file-ipython-dedicated (&optional filename)
"Send file to a Ipython interpreter.
Uses a dedicated shell."
(interactive "fFile: ")
(py--execute-prepare filename "ipython" 'dedicated nil nil nil t))
(defun py-execute-file-ipython-dedicated-switch (&optional filename)
"Send file to a Ipython interpreter.
Uses a dedicated shell.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "ipython" 'dedicated 'switch nil nil t))
(defun py-execute-file-python3 (&optional filename)
"Send file to a Python3 interpreter."
(interactive "fFile: ")
(py--execute-prepare filename "python3" nil nil nil nil t))
(defun py-execute-file-python3-switch (&optional filename)
"Send file to a Python3 interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python3" nil 'switch nil nil t))
(defun py-execute-file-python3-no-switch (&optional filename)
"Send file to a Python3 interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python3" nil 'no-switch nil nil t))
(defun py-execute-file-python3-dedicated (&optional filename)
"Send file to a Python3 interpreter.
Uses a dedicated shell."
(interactive "fFile: ")
(py--execute-prepare filename "python3" 'dedicated nil nil nil t))
(defun py-execute-file-python3-dedicated-switch (&optional filename)
"Send file to a Python3 interpreter.
Uses a dedicated shell.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python3" 'dedicated 'switch nil nil t))
(defun py-execute-file-python2 (&optional filename)
"Send file to a Python2 interpreter."
(interactive "fFile: ")
(py--execute-prepare filename "python2" nil nil nil nil t))
(defun py-execute-file-python2-switch (&optional filename)
"Send file to a Python2 interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python2" nil 'switch nil nil t))
(defun py-execute-file-python2-no-switch (&optional filename)
"Send file to a Python2 interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python2" nil 'no-switch nil nil t))
(defun py-execute-file-python2-dedicated (&optional filename)
"Send file to a Python2 interpreter.
Uses a dedicated shell."
(interactive "fFile: ")
(py--execute-prepare filename "python2" 'dedicated nil nil nil t))
(defun py-execute-file-python2-dedicated-switch (&optional filename)
"Send file to a Python2 interpreter.
Uses a dedicated shell.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python2" 'dedicated 'switch nil nil t))
(defun py-execute-file-python2.7 (&optional filename)
"Send file to a Python2.7 interpreter."
(interactive "fFile: ")
(py--execute-prepare filename "python2.7" nil nil nil nil t))
(defun py-execute-file-python2.7-switch (&optional filename)
"Send file to a Python2.7 interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python2.7" nil 'switch nil nil t))
(defun py-execute-file-python2.7-no-switch (&optional filename)
"Send file to a Python2.7 interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python2.7" nil 'no-switch nil nil t))
(defun py-execute-file-python2.7-dedicated (&optional filename)
"Send file to a Python2.7 interpreter.
Uses a dedicated shell."
(interactive "fFile: ")
(py--execute-prepare filename "python2.7" 'dedicated nil nil nil t))
(defun py-execute-file-python2.7-dedicated-switch (&optional filename)
"Send file to a Python2.7 interpreter.
Uses a dedicated shell.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python2.7" 'dedicated 'switch nil nil t))
(defun py-execute-file-jython (&optional filename)
"Send file to a Jython interpreter."
(interactive "fFile: ")
(py--execute-prepare filename "jython" nil nil nil nil t))
(defun py-execute-file-jython-switch (&optional filename)
"Send file to a Jython interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "jython" nil 'switch nil nil t))
(defun py-execute-file-jython-no-switch (&optional filename)
"Send file to a Jython interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"nil\""
(interactive "fFile: ")
(py--execute-prepare filename "jython" nil 'no-switch nil nil t))
(defun py-execute-file-jython-dedicated (&optional filename)
"Send file to a Jython interpreter.
Uses a dedicated shell."
(interactive "fFile: ")
(py--execute-prepare filename "jython" 'dedicated nil nil nil t))
(defun py-execute-file-jython-dedicated-switch (&optional filename)
"Send file to a Jython interpreter.
Uses a dedicated shell.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "jython" 'dedicated 'switch nil nil t))
(defun py-execute-file-python3.2 (&optional filename)
"Send file to a Python3.2 interpreter."
(interactive "fFile: ")
(py--execute-prepare filename "python3.2" nil nil nil nil t))
(defun py-execute-file-python3.2-switch (&optional filename)
"Send file to a Python3.2 interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python3.2" nil 'switch nil nil t))
(defun py-execute-file-python3.2-no-switch (&optional filename)
"Send file to a Python3.2 interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python3.2" nil 'no-switch nil nil t))
(defun py-execute-file-python3.2-dedicated (&optional filename)
"Send file to a Python3.2 interpreter.
Uses a dedicated shell."
(interactive "fFile: ")
(py--execute-prepare filename "python3.2" 'dedicated nil nil nil t))
(defun py-execute-file-python3.2-dedicated-switch (&optional filename)
"Send file to a Python3.2 interpreter.
Uses a dedicated shell.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python3.2" 'dedicated 'switch nil nil t))
(defun py-execute-file-python3.3 (&optional filename)
"Send file to a Python3.3 interpreter."
(interactive "fFile: ")
(py--execute-prepare filename "python3.3" nil nil nil nil t))
(defun py-execute-file-python3.3-switch (&optional filename)
"Send file to a Python3.3 interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python3.3" nil 'switch nil nil t))
(defun py-execute-file-python3.3-no-switch (&optional filename)
"Send file to a Python3.3 interpreter.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python3.3" nil 'no-switch nil nil t))
(defun py-execute-file-python3.3-dedicated (&optional filename)
"Send file to a Python3.3 interpreter.
Uses a dedicated shell."
(interactive "fFile: ")
(py--execute-prepare filename "python3.3" 'dedicated nil nil nil t))
(defun py-execute-file-python3.3-dedicated-switch (&optional filename)
"Send file to a Python3.3 interpreter.
Uses a dedicated shell.
Ignores default of `py-switch-buffers-on-execute-p', uses it with value \"non-nil\""
(interactive "fFile: ")
(py--execute-prepare filename "python3.3" 'dedicated 'switch nil nil t))
;; python-components-section-forms
(defun py-execute-section ()
"Execute section at point."
(interactive)
(py-execute-section-prepare))
(defun py-execute-section-python ()
"Execute section at point using python interpreter."
(interactive)
(py-execute-section-prepare "python"))
(defun py-execute-section-python2 ()
"Execute section at point using python2 interpreter."
(interactive)
(py-execute-section-prepare "python2"))
(defun py-execute-section-python3 ()
"Execute section at point using python3 interpreter."
(interactive)
(py-execute-section-prepare "python3"))
(defun py-execute-section-ipython ()
"Execute section at point using ipython interpreter."
(interactive)
(py-execute-section-prepare "ipython"))
(defun py-execute-section-ipython2.7 ()
"Execute section at point using ipython2.7 interpreter."
(interactive)
(py-execute-section-prepare "ipython2.7"))
(defun py-execute-section-ipython3 ()
"Execute section at point using ipython3 interpreter."
(interactive)
(py-execute-section-prepare "ipython3"))
(defun py-execute-section-jython ()
"Execute section at point using jython interpreter."
(interactive)
(py-execute-section-prepare "jython"))
;; python-components-comment
(defun py-comment-region (beg end &optional arg)
"Like `comment-region' but uses double hash (`#') comment starter."
(interactive "r\nP")
(let ((comment-start (if py-block-comment-prefix-p
py-block-comment-prefix
comment-start)))
(comment-region beg end arg)))
(defun py-comment-block (&optional beg end arg)
"Comments block at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"
(interactive "*")
(save-excursion
(let ((comment-start (if py-block-comment-prefix-p
py-block-comment-prefix
comment-start))
(beg (or beg (py--beginning-of-block-position)))
(end (or end (py--end-of-block-position))))
(goto-char beg)
(push-mark)
(goto-char end)
(comment-region beg end arg))))
(defun py-comment-block-or-clause (&optional beg end arg)
"Comments block-or-clause at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"
(interactive "*")
(save-excursion
(let ((comment-start (if py-block-comment-prefix-p
py-block-comment-prefix
comment-start))
(beg (or beg (py--beginning-of-block-or-clause-position)))
(end (or end (py--end-of-block-or-clause-position))))
(goto-char beg)
(push-mark)
(goto-char end)
(comment-region beg end arg))))
(defun py-comment-class (&optional beg end arg)
"Comments class at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"
(interactive "*")
(save-excursion
(let ((comment-start (if py-block-comment-prefix-p
py-block-comment-prefix
comment-start))
(beg (or beg (py--beginning-of-class-position)))
(end (or end (py--end-of-class-position))))
(goto-char beg)
(push-mark)
(goto-char end)
(comment-region beg end arg))))
(defun py-comment-clause (&optional beg end arg)
"Comments clause at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"
(interactive "*")
(save-excursion
(let ((comment-start (if py-block-comment-prefix-p
py-block-comment-prefix
comment-start))
(beg (or beg (py--beginning-of-clause-position)))
(end (or end (py--end-of-clause-position))))
(goto-char beg)
(push-mark)
(goto-char end)
(comment-region beg end arg))))
(defun py-comment-def (&optional beg end arg)
"Comments def at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"
(interactive "*")
(save-excursion
(let ((comment-start (if py-block-comment-prefix-p
py-block-comment-prefix
comment-start))
(beg (or beg (py--beginning-of-def-position)))
(end (or end (py--end-of-def-position))))
(goto-char beg)
(push-mark)
(goto-char end)
(comment-region beg end arg))))
(defun py-comment-def-or-class (&optional beg end arg)
"Comments def-or-class at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"
(interactive "*")
(save-excursion
(let ((comment-start (if py-block-comment-prefix-p
py-block-comment-prefix
comment-start))
(beg (or beg (py--beginning-of-def-or-class-position)))
(end (or end (py--end-of-def-or-class-position))))
(goto-char beg)
(push-mark)
(goto-char end)
(comment-region beg end arg))))
(defun py-comment-indent (&optional beg end arg)
"Comments indent at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"
(interactive "*")
(save-excursion
(let ((comment-start (if py-block-comment-prefix-p
py-block-comment-prefix
comment-start))
(beg (or beg (py--beginning-of-indent-position)))
(end (or end (py--end-of-indent-position))))
(goto-char beg)
(push-mark)
(goto-char end)
(comment-region beg end arg))))
(defun py-comment-minor-block (&optional beg end arg)
"Comments minor-block at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"
(interactive "*")
(save-excursion
(let ((comment-start (if py-block-comment-prefix-p
py-block-comment-prefix
comment-start))
(beg (or beg (py--beginning-of-minor-block-position)))
(end (or end (py--end-of-minor-block-position))))
(goto-char beg)
(push-mark)
(goto-char end)
(comment-region beg end arg))))
(defun py-comment-section (&optional beg end arg)
"Comments section at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"
(interactive "*")
(save-excursion
(let ((comment-start (if py-block-comment-prefix-p
py-block-comment-prefix
comment-start))
(beg (or beg (py--beginning-of-section-position)))
(end (or end (py--end-of-section-position))))
(goto-char beg)
(push-mark)
(goto-char end)
(comment-region beg end arg))))
(defun py-comment-statement (&optional beg end arg)
"Comments statement at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"
(interactive "*")
(save-excursion
(let ((comment-start (if py-block-comment-prefix-p
py-block-comment-prefix
comment-start))
(beg (or beg (py--beginning-of-statement-position)))
(end (or end (py--end-of-statement-position))))
(goto-char beg)
(push-mark)
(goto-char end)
(comment-region beg end arg))))
(defun py-comment-top-level (&optional beg end arg)
"Comments top-level at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"
(interactive "*")
(save-excursion
(let ((comment-start (if py-block-comment-prefix-p
py-block-comment-prefix
comment-start))
(beg (or beg (py--beginning-of-top-level-position)))
(end (or end (py--end-of-top-level-position))))
(goto-char beg)
(push-mark)
(goto-char end)
(comment-region beg end arg))))
;; python-components-comment ends here
;; python-components-forms-code
(defun py-block ()
"Block at point.
Return code of `py-block' at point, a string. "
(interactive)
(let ((erg (py--mark-base "block")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-block-or-clause ()
"Block-Or-Clause at point.
Return code of `py-block-or-clause' at point, a string. "
(interactive)
(let ((erg (py--mark-base "block-or-clause")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-buffer ()
"Buffer at point.
Return code of `py-buffer' at point, a string. "
(interactive)
(let ((erg (py--mark-base "buffer")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-class ()
"Class at point.
Return code of `py-class' at point, a string. "
(interactive)
(let ((erg (py--mark-base "class")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-clause ()
"Clause at point.
Return code of `py-clause' at point, a string. "
(interactive)
(let ((erg (py--mark-base "clause")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-def ()
"Def at point.
Return code of `py-def' at point, a string. "
(interactive)
(let ((erg (py--mark-base "def")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-def-or-class ()
"Def-Or-Class at point.
Return code of `py-def-or-class' at point, a string. "
(interactive)
(let ((erg (py--mark-base "def-or-class")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-expression ()
"Expression at point.
Return code of `py-expression' at point, a string. "
(interactive)
(let ((erg (py--mark-base "expression")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-indent ()
"Indent at point.
Return code of `py-indent' at point, a string. "
(interactive)
(let ((erg (py--mark-base "indent")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-line ()
"Line at point.
Return code of `py-line' at point, a string. "
(interactive)
(let ((erg (py--mark-base "line")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-minor-block ()
"Minor-Block at point.
Return code of `py-minor-block' at point, a string. "
(interactive)
(let ((erg (py--mark-base "minor-block")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-paragraph ()
"Paragraph at point.
Return code of `py-paragraph' at point, a string. "
(interactive)
(let ((erg (py--mark-base "paragraph")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-partial-expression ()
"Partial-Expression at point.
Return code of `py-partial-expression' at point, a string. "
(interactive)
(let ((erg (py--mark-base "partial-expression")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-region ()
"Region at point.
Return code of `py-region' at point, a string. "
(interactive)
(let ((erg (py--mark-base "region")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-statement ()
"Statement at point.
Return code of `py-statement' at point, a string. "
(interactive)
(let ((erg (py--mark-base "statement")))
(py--forms-report-result erg (called-interactively-p 'any))))
(defun py-top-level ()
"Top-Level at point.
Return code of `py-top-level' at point, a string. "
(interactive)
(let ((erg (py--mark-base "top-level")))
(py--forms-report-result erg (called-interactively-p 'any))))
;; python-components-forms-code.el ends here
;; python-components-fast-forms
;; Process forms fast
(defun py--filter-result (strg)
"Set `py-result' according to `py-fast-filter-re'.
Remove trailing newline"
(replace-regexp-in-string (format "[ \n]*%s[ \n]*" py-fast-filter-re) "" (ansi-color-filter-apply strg)))
(defun py-fast-process (&optional buffer)
"Connect am (I)Python process suitable for large output.
Output buffer displays \"Fast\" by default
It is not in interactive, i.e. comint-mode, as its bookkeepings seem linked to the freeze reported by lp:1253907"
(interactive)
(let ((this-buffer
(set-buffer (or (and buffer (get-buffer-create buffer))
(get-buffer-create py-buffer-name)))))
(let ((proc (start-process py-shell-name this-buffer py-shell-name)))
(with-current-buffer this-buffer
(erase-buffer))
proc)))
(defun py--fast-send-string-intern (strg proc output-buffer return)
(with-current-buffer output-buffer
(process-send-string proc "\n")
(let ((orig (point)))
(process-send-string proc strg)
(process-send-string proc "\n")
(accept-process-output proc 5)
(sit-for py-fast-completion-delay t)
(when return
(setq py-result (py--filter-result (py--fetch-result orig))))
py-result)))
(defun py--fast-send-string (strg)
"Process Python strings, being prepared for large output.
Output buffer displays \"Fast\" by default
See also `py-fast-shell'
"
(let ((proc (or (get-buffer-process (get-buffer py-fast-output-buffer))
(py-fast-process))))
;; (with-current-buffer py-fast-output-buffer
;; (erase-buffer))
(process-send-string proc strg)
(or (string-match "\n$" strg)
(process-send-string proc "\n"))
(accept-process-output proc 1)
(set-buffer py-fast-output-buffer)
(beginning-of-line)
(skip-chars-backward "\r\n")
(delete-region (point) (point-max))))
(defun py--fast-send-string-no-output (strg proc output-buffer)
(with-current-buffer output-buffer
(process-send-string proc "\n")
(let ((orig (point-max)))
(sit-for 1 t)
(process-send-string proc strg)
(process-send-string proc "\n")
(accept-process-output proc 5)
(sit-for 1 t)
(delete-region orig (point-max)))))
(defun py-process-region-fast (beg end)
(interactive "r")
(let ((py-fast-process-p t))
(py-execute-region beg end)))
(defun py-execute-block-fast (&optional shell dedicated switch beg end file)
"Process block at point by a Python interpreter.
Suitable for large output, doesn't mess up interactive shell.
Output buffer not in comint-mode, displays \"Fast\" by default"
(interactive)
(py--execute-prepare 'block shell dedicated switch beg end file t))
(defun py-execute-block-or-clause-fast (&optional shell dedicated switch beg end file)
"Process block-or-clause at point by a Python interpreter.
Suitable for large output, doesn't mess up interactive shell.
Output buffer not in comint-mode, displays \"Fast\" by default"
(interactive)
(py--execute-prepare 'block-or-clause shell dedicated switch beg end file t))
(defun py-execute-class-fast (&optional shell dedicated switch beg end file)
"Process class at point by a Python interpreter.
Suitable for large output, doesn't mess up interactive shell.
Output buffer not in comint-mode, displays \"Fast\" by default"
(interactive)
(py--execute-prepare 'class shell dedicated switch beg end file t))
(defun py-execute-clause-fast (&optional shell dedicated switch beg end file)
"Process clause at point by a Python interpreter.
Suitable for large output, doesn't mess up interactive shell.
Output buffer not in comint-mode, displays \"Fast\" by default"
(interactive)
(py--execute-prepare 'clause shell dedicated switch beg end file t))
(defun py-execute-def-fast (&optional shell dedicated switch beg end file)
"Process def at point by a Python interpreter.
Suitable for large output, doesn't mess up interactive shell.
Output buffer not in comint-mode, displays \"Fast\" by default"
(interactive)
(py--execute-prepare 'def shell dedicated switch beg end file t))
(defun py-execute-def-or-class-fast (&optional shell dedicated switch beg end file)
"Process def-or-class at point by a Python interpreter.
Suitable for large output, doesn't mess up interactive shell.
Output buffer not in comint-mode, displays \"Fast\" by default"
(interactive)
(py--execute-prepare 'def-or-class shell dedicated switch beg end file t))
(defun py-execute-expression-fast (&optional shell dedicated switch beg end file)
"Process expression at point by a Python interpreter.
Suitable for large output, doesn't mess up interactive shell.
Output buffer not in comint-mode, displays \"Fast\" by default"
(interactive)
(py--execute-prepare 'expression shell dedicated switch beg end file t))
(defun py-execute-partial-expression-fast (&optional shell dedicated switch beg end file)
"Process partial-expression at point by a Python interpreter.
Suitable for large output, doesn't mess up interactive shell.
Output buffer not in comint-mode, displays \"Fast\" by default"
(interactive)
(py--execute-prepare 'partial-expression shell dedicated switch beg end file t))
(defun py-execute-section-fast (&optional shell dedicated switch beg end file)
"Process section at point by a Python interpreter.
Suitable for large output, doesn't mess up interactive shell.
Output buffer not in comint-mode, displays \"Fast\" by default"
(interactive)
(py--execute-prepare 'section shell dedicated switch beg end file t))
(defun py-execute-statement-fast (&optional shell dedicated switch beg end file)
"Process statement at point by a Python interpreter.
Suitable for large output, doesn't mess up interactive shell.
Output buffer not in comint-mode, displays \"Fast\" by default"
(interactive)
(py--execute-prepare 'statement shell dedicated switch beg end file t))
(defun py-execute-top-level-fast (&optional shell dedicated switch beg end file)
"Process top-level at point by a Python interpreter.
Suitable for large output, doesn't mess up interactive shell.
Output buffer not in comint-mode, displays \"Fast\" by default"
(interactive)
(py--execute-prepare 'top-level shell dedicated switch beg end file t))
;; python-components-narrow
(defun py-narrow-to-block ()
"Narrow to block at point."
(interactive)
(py--narrow-prepare "block"))
(defun py-narrow-to-block-or-clause ()
"Narrow to block-or-clause at point."
(interactive)
(py--narrow-prepare "block-or-clause"))
(defun py-narrow-to-class ()
"Narrow to class at point."
(interactive)
(py--narrow-prepare "class"))
(defun py-narrow-to-clause ()
"Narrow to clause at point."
(interactive)
(py--narrow-prepare "clause"))
(defun py-narrow-to-def ()
"Narrow to def at point."
(interactive)
(py--narrow-prepare "def"))
(defun py-narrow-to-def-or-class ()
"Narrow to def-or-class at point."
(interactive)
(py--narrow-prepare "def-or-class"))
(defun py-narrow-to-statement ()
"Narrow to statement at point."
(interactive)
(py--narrow-prepare "statement"))
;; python-components-auto-fill
(defvar py-auto-fill-mode-orig (auto-fill-mode)
"Store the original state of auto-fill-mode. ")
;; py-fill-column-orig already defined
(defun py-comment-auto-fill (&optional arg)
"Toggles comment-auto-fill mode"
(interactive "P")
(if (or (and arg (< 0 (prefix-numeric-value arg))) (and (boundp 'py-comment-auto-fill)(not py-comment-auto-fill)))
(progn
(set (make-local-variable 'py-comment-auto-fill-p) t)
(setq fill-column comment-fill-column)
(auto-fill-mode 1))
(set (make-local-variable 'py-comment-auto-fill-p) nil)
;; (set (make-local-variable 'py-comment-auto-fill-only-comments) nil)
;; (setq fill-column fill-column-orig)
(auto-fill-mode -1)))
(defun py-comment-auto-fill-on ()
(interactive)
(py-comment-auto-fill 1))
(defun py-comment-auto-fill-off ()
(interactive)
(py-comment-auto-fill -1))
;; python-components-hide-show
;; (setq hs-block-start-regexp 'py-extended-block-or-clause-re)
;; (setq hs-forward-sexp-func 'py-forward-block)
(defun py-hide-base (form &optional beg end)
"Hide visibility of existing form at point. "
(hs-minor-mode 1)
(save-excursion
(let* ((form (prin1-to-string form))
(beg (or beg (or (funcall (intern-soft (concat "py--beginning-of-" form "-p")))
(funcall (intern-soft (concat "py-backward-" form))))))
(end (or end (funcall (intern-soft (concat "py-forward-" form)))))
(modified (buffer-modified-p))
(inhibit-read-only t))
(if (and beg end)
(progn
(hs-make-overlay beg end 'code)
(set-buffer-modified-p modified))
(error (concat "No " (format "%s" form) " at point!"))))))
(defun py-show-base (form &optional beg end)
"Remove invisibility of existing form at point. "
(save-excursion
(let* ((form (prin1-to-string form))
(beg (or beg (or (funcall (intern-soft (concat "py--beginning-of-" form "-p")))
(funcall (intern-soft (concat "py-backward-" form))))))
(end (or end (funcall (intern-soft (concat "py-forward-" form)))))
(modified (buffer-modified-p))
(inhibit-read-only t))
(if (and beg end)
(progn
(hs-discard-overlays beg end)
(set-buffer-modified-p modified))
(error (concat "No " (format "%s" form) " at point!"))))))
(defun py-hide-show (&optional form beg end)
"Toggle visibility of existing forms at point. "
(interactive)
(save-excursion
(let* ((form (prin1-to-string form))
(beg (or beg (or (funcall (intern-soft (concat "py--beginning-of-" form "-p")))
(funcall (intern-soft (concat "py-backward-" form))))))
(end (or end (funcall (intern-soft (concat "py-forward-" form)))))
(modified (buffer-modified-p))
(inhibit-read-only t))
(if (and beg end)
(if (overlays-in beg end)
(hs-discard-overlays beg end)
(hs-make-overlay beg end 'code))
(error (concat "No " (format "%s" form) " at point!")))
(set-buffer-modified-p modified))))
(defun py-hide-region (beg end)
"Hide active region. "
(interactive
(list
(and (use-region-p) (region-beginning))(and (use-region-p) (region-end))))
(py-hide-base 'region beg end))
(defun py-show-region (beg end)
"Un-hide active region. "
(interactive
(list
(and (use-region-p) (region-beginning))(and (use-region-p) (region-end))))
(py-show-base 'region beg end))
(defun py-hide-block ()
"Hide block at point. "
(interactive)
(py-hide-base 'block))
(defun py-show-block ()
"Show block at point. "
(interactive)
(py-show-base 'block))
(defun py-hide-block-or-clause ()
"Hide block-or-clause at point. "
(interactive)
(py-hide-base 'block-or-clause))
(defun py-show-block-or-clause ()
"Show block-or-clause at point. "
(interactive)
(py-show-base 'block-or-clause))
(defun py-hide-class ()
"Hide class at point. "
(interactive)
(py-hide-base 'class))
(defun py-show-class ()
"Show class at point. "
(interactive)
(py-show-base 'class))
(defun py-hide-clause ()
"Hide clause at point. "
(interactive)
(py-hide-base 'clause))
(defun py-show-clause ()
"Show clause at point. "
(interactive)
(py-show-base 'clause))
(defun py-hide-comment ()
"Hide comment at point. "
(interactive)
(py-hide-base 'comment))
(defun py-show-comment ()
"Show comment at point. "
(interactive)
(py-show-base 'comment))
(defun py-hide-def ()
"Hide def at point. "
(interactive)
(py-hide-base 'def))
(defun py-show-def ()
"Show def at point. "
(interactive)
(py-show-base 'def))
(defun py-hide-def-or-class ()
"Hide def-or-class at point. "
(interactive)
(py-hide-base 'def-or-class))
(defun py-show-def-or-class ()
"Show def-or-class at point. "
(interactive)
(py-show-base 'def-or-class))
(defun py-hide-elif-block ()
"Hide elif-block at point. "
(interactive)
(py-hide-base 'elif-block))
(defun py-show-elif-block ()
"Show elif-block at point. "
(interactive)
(py-show-base 'elif-block))
(defun py-hide-else-block ()
"Hide else-block at point. "
(interactive)
(py-hide-base 'else-block))
(defun py-show-else-block ()
"Show else-block at point. "
(interactive)
(py-show-base 'else-block))
(defun py-hide-except-block ()
"Hide except-block at point. "
(interactive)
(py-hide-base 'except-block))
(defun py-show-except-block ()
"Show except-block at point. "
(interactive)
(py-show-base 'except-block))
(defun py-hide-expression ()
"Hide expression at point. "
(interactive)
(py-hide-base 'expression))
(defun py-show-expression ()
"Show expression at point. "
(interactive)
(py-show-base 'expression))
(defun py-hide-for-block ()
"Hide for-block at point. "
(interactive)
(py-hide-base 'for-block))
(defun py-show-for-block ()
"Show for-block at point. "
(interactive)
(py-show-base 'for-block))
(defun py-hide-if-block ()
"Hide if-block at point. "
(interactive)
(py-hide-base 'if-block))
(defun py-show-if-block ()
"Show if-block at point. "
(interactive)
(py-show-base 'if-block))
(defun py-hide-indent ()
"Hide indent at point. "
(interactive)
(py-hide-base 'indent))
(defun py-show-indent ()
"Show indent at point. "
(interactive)
(py-show-base 'indent))
(defun py-hide-line ()
"Hide line at point. "
(interactive)
(py-hide-base 'line))
(defun py-show-line ()
"Show line at point. "
(interactive)
(py-show-base 'line))
(defun py-hide-minor-block ()
"Hide minor-block at point. "
(interactive)
(py-hide-base 'minor-block))
(defun py-show-minor-block ()
"Show minor-block at point. "
(interactive)
(py-show-base 'minor-block))
(defun py-hide-paragraph ()
"Hide paragraph at point. "
(interactive)
(py-hide-base 'paragraph))
(defun py-show-paragraph ()
"Show paragraph at point. "
(interactive)
(py-show-base 'paragraph))
(defun py-hide-partial-expression ()
"Hide partial-expression at point. "
(interactive)
(py-hide-base 'partial-expression))
(defun py-show-partial-expression ()
"Show partial-expression at point. "
(interactive)
(py-show-base 'partial-expression))
(defun py-hide-section ()
"Hide section at point. "
(interactive)
(py-hide-base 'section))
(defun py-show-section ()
"Show section at point. "
(interactive)
(py-show-base 'section))
(defun py-hide-statement ()
"Hide statement at point. "
(interactive)
(py-hide-base 'statement))
(defun py-show-statement ()
"Show statement at point. "
(interactive)
(py-show-base 'statement))
(defun py-hide-top-level ()
"Hide top-level at point. "
(interactive)
(py-hide-base 'top-level))
(defun py-show-top-level ()
"Show top-level at point. "
(interactive)
(py-show-base 'top-level))
;; python-components-hide-show.el ends here
;; python-components-fast-complete
(defun py--fast-completion-get-completions (input process completion-code)
"Retrieve available completions for INPUT using PROCESS.
Argument COMPLETION-CODE is the python code used to get
completions on the current context."
(let ((completions
(py--fast-send-string-intern
(format completion-code input) process py-buffer-name t)))
(when (> (length completions) 2)
(split-string completions "^'\\|^\"\\|;\\|'$\\|\"$" t))))
(defun py--fast--do-completion-at-point (process imports input orig code output-buffer)
"Do completion at point for PROCESS."
;; send setup-code
(let (py-return-result-p)
(when imports
;; (message "%s" imports)
(py--fast-send-string-no-output imports process output-buffer)))
(let* ((completion
(py--fast-completion-get-completions input process code)))
(cond ((eq completion t)
(and py-verbose-p (message "py--fast--do-completion-at-point %s" "`t' is returned, not completion. Might be a bug."))
nil)
((null completion)
(and py-verbose-p (message "py--fast--do-completion-at-point %s" "Don't see a completion"))
nil)
((and completion
(or (and (listp completion)
(string= input (car completion)))
(and (stringp completion)
(string= input completion))))
nil)
((and completion (stringp completion)(not (string= input completion)))
(progn (delete-char (- (length input)))
(insert completion)
;; (move-marker orig (point))
;; minibuffer.el expects a list
nil))
(t (py--try-completion input completion)))
nil))
(defun py--fast-complete-base (shell pos word imports exception-buffer)
(let* ((shell (or shell (py-choose-shell nil t)))
(py-buffer-name (py-shell nil nil shell nil t))
(proc (get-buffer-process py-buffer-name))
(code (if (string-match "[Ii][Pp]ython*" shell)
(py-set-ipython-completion-command-string shell)
py-shell-module-completion-code)))
(with-current-buffer py-buffer-name
(erase-buffer))
(py--fast--do-completion-at-point proc imports word pos code py-buffer-name)))
(defun py-fast-complete (&optional shell debug beg end word)
"Complete word before point, if any.
Use `py-fast-process' "
(interactive)
(setq py-last-window-configuration
(current-window-configuration))
(py--complete-prepare shell beg end word t))
;; python-components-intern
;; Keymap
(defun ar--beginning-of-form-intern (regexp &optional iact indent orig lc)
"Go to beginning of FORM.
With INDENT, go to beginning one level above.
Whit IACT, print result in message buffer.
Returns beginning of FORM if successful, nil otherwise"
(interactive "P")
(let (erg)
(unless (bobp)
(let* ((orig (or orig (point)))
(indent (or indent (progn
(back-to-indentation)
(or (ar--beginning-of-statement-p)
(ar-backward-statement))
(current-indentation)))))
(setq erg (cond ((and (< (point) orig) (looking-at (symbol-value regexp)))
(point))
((and (eq 0 (current-column)) (numberp indent) (< 0 indent))
(when (< 0 (abs (skip-chars-backward " \t\r\n\f")))
(ar-backward-statement)
(unless (looking-at (symbol-value regexp))
(cdr (ar--go-to-keyword (symbol-value regexp) (current-indentation))))))
((numberp indent)
(cdr (ar--go-to-keyword (symbol-value regexp) indent)))
(t (ignore-errors
(cdr (ar--go-to-keyword (symbol-value regexp)
(- (progn (if (ar--beginning-of-statement-p) (current-indentation) (save-excursion (ar-backward-statement) (current-indentation)))) py-indent-offset)))))))
(when lc (beginning-of-line) (setq erg (point)))))
;; (when (and ar-verbose-p iact) (message "%s" erg))
erg))
(defun py--indent-prepare (inter-re)
(progn (back-to-indentation)
(or (ar--beginning-of-statement-p)
(ar-backward-statement))
(cond ((eq 0 (current-indentation))
(current-indentation))
((looking-at (symbol-value inter-re))
(current-indentation))
(t
(if (<= py-indent-offset (current-indentation))
(- (current-indentation) (if ar-smart-indentation (ar-guess-indent-offset) py-indent-offset))
py-indent-offset)))))
(defun ar--beginning-of-prepare (indent final-re &optional inter-re iact lc)
(let ((orig (point))
(indent (or indent (py--indent-prepare inter-re)))
erg)
(if (and (< (point) orig) (looking-at (symbol-value final-re)))
(progn
(and lc (beginning-of-line))
(setq erg (point))
;; (when (and ar-verbose-p iact) (message "%s" erg))
erg)
(ar--beginning-of-form-intern final-re iact indent orig lc))))
(defun ar--end-of-prepare (indent final-re &optional inter-re iact lc)
(let ((orig (point))
(indent
(or indent
(progn (back-to-indentation)
(or (ar--beginning-of-statement-p)
(ar-backward-statement))
(cond ((eq 0 (current-indentation))
(current-indentation))
((looking-at (symbol-value inter-re))
(current-indentation))
(t
(if (<= py-indent-offset (current-indentation))
(- (current-indentation) (if ar-smart-indentation (ar-guess-indent-offset) py-indent-offset))
py-indent-offset))))))
erg)
(if (and (< orig (point)) (looking-at (symbol-value final-re)))
(progn
(and lc (beginning-of-line))
(setq erg (point))
;; (when (and ar-verbose-p iact) (message "%s" erg))
erg)
(ar--beginning-of-form-intern final-re iact indent orig lc))))
(defun py-separator-char ()
"Return the file-path separator char from current machine.
When `py-separator-char' is customized, its taken.
Returns char found. "
(let ((erg (cond ((characterp py-separator-char)
(char-to-string py-separator-char))
;; epd hack
((and
(string-match "[Ii][Pp]ython" py-shell-name)
(string-match "epd\\|EPD" py-shell-name))
(replace-regexp-in-string "\n" ""
(shell-command-to-string (concat py-shell-name " -c \"import os; print(os.sep)\"")))))))
(if (and erg (string-match "^$" erg))
(setq erg (substring erg (string-match "^$" erg)))
(setq erg (replace-regexp-in-string "\n" "" (shell-command-to-string (concat py-shell-name " -W ignore" " -c \"import os; print(os.sep)\"")))))
erg))
(defun pps-emacs-version ()
"Include the appropriate `parse-partial-sexp' "
(if (featurep 'xemacs)
'(parse-partial-sexp (point-min) (point))
'(parse-partial-sexp (point-min) (point))))
(defun py-in-comment-p ()
"Return the beginning of current line's comment, if inside. "
(interactive)
(let* ((pps (parse-partial-sexp (point-min) (point)))
(erg (and (nth 4 pps) (nth 8 pps))))
erg))
;;
(defun py-in-string-or-comment-p ()
"Returns beginning position if inside a string or comment, nil otherwise. "
(or (nth 8 (parse-partial-sexp (point-min) (point)))
(when (or (looking-at "\"")(looking-at "[ \t]*#[ \t]*"))
(point))))
(when py-org-cycle-p
(define-key python-mode-map (kbd "") 'org-cycle))
(defun py--buffer-filename-remote-maybe (&optional file-name buffer)
(let ((file-name (or file-name (buffer-file-name))))
(if (and (featurep 'tramp) (tramp-tramp-file-p file-name))
(tramp-file-name-localname
(tramp-dissect-file-name file-name))
(buffer-file-name (or buffer (current-buffer))))))
(defun py-forward-buffer ()
"A complementary form used by auto-generated commands.
Returns position reached if successful"
(interactive)
(unless (eobp)
(goto-char (point-max))))
(defun py-backward-buffer ()
"A complementary form used by auto-generated commands.
Returns position reached if successful"
(interactive)
(unless (bobp)
(goto-char (point-min))))
(defun py--execute-prepare (form &optional shell dedicated switch beg end file fast proc wholebuf split)
"Used by python-extended-executes ."
(save-excursion
(let* ((form (prin1-to-string form))
(origline (py-count-lines))
(beg (unless file
(prog1
(or beg (funcall (intern-soft (concat "py--beginning-of-" form "-p")))
(funcall (intern-soft (concat "py-backward-" form)))
(push-mark)))))
(end (unless file
(or end (funcall (intern-soft (concat "py-forward-" form))))))
filename)
(setq py-buffer-name nil)
(if file
(progn
(setq filename (expand-file-name form))
(if (file-readable-p filename)
(py--execute-file-base nil filename nil nil origline)
(message "%s not readable. %s" file "Do you have write permissions?")))
(py--execute-base beg end shell filename proc file wholebuf fast dedicated split switch)))))
(defun py-load-skeletons ()
"Load skeletons from extensions. "
(interactive)
(load (concat py-install-directory "/extensions/python-components-skeletons.el")))
(defun py--kill-emacs-hook ()
"Delete files in `py-file-queue'.
These are Python temporary files awaiting execution."
(mapc #'(lambda (filename)
(ignore-errors (delete-file filename)))
py-file-queue))
;; Add a designator to the minor mode strings
(or (assq 'py-pdbtrack-is-tracking-p minor-mode-alist)
(push '(py-pdbtrack-is-tracking-p py-pdbtrack-minor-mode-string)
minor-mode-alist))
;; bottle.py
;; py = sys.version_info
;; py3k = py >= (3,0,0)
;; py25 = py < (2,6,0)
;; py31 = (3,1,0) <= py < (3,2,0)
;; sys.version_info[0]
(defun py-python-version (&optional executable verbose)
"Returns versions number of a Python EXECUTABLE, string.
If no EXECUTABLE given, `py-shell-name' is used.
Interactively output of `--version' is displayed. "
(interactive)
(let* ((executable (or executable py-shell-name))
(erg (py--string-strip (shell-command-to-string (concat executable " --version")))))
(when (called-interactively-p 'any) (message "%s" erg))
(unless verbose (setq erg (cadr (split-string erg))))
erg))
(defun py-version ()
"Echo the current version of `python-mode' in the minibuffer."
(interactive)
(message "Using `python-mode' version %s" py-version)
(py-keep-region-active))
;; Utility stuff
(declare-function compilation-shell-minor-mode "compile" (&optional arg))
;; dereived from shipped python.el
(defun py-history-input-filter (str)
"`comint-input-filter' function for Python process.
Don't save anything for STR matching `py-history-filter-regexp'."
(not (string-match py-history-filter-regexp str)))
(defun py-load-file (file-name)
"Load a Python file FILE-NAME into the Python process.
If the file has extension `.py' import or reload it as a module.
Treating it as a module keeps the global namespace clean, provides
function location information for debugging, and supports users of
module-qualified names."
(interactive "f")
(py--execute-file-base (get-buffer-process (get-buffer (py-shell))) file-name))
(defun py-proc (&optional argprompt)
"Return the current Python process.
Start a new process if necessary. "
(interactive "P")
(let ((erg
(cond ((comint-check-proc (current-buffer))
(get-buffer-process (buffer-name (current-buffer))))
(t (py-shell argprompt)))))
;; (when (called-interactively-p 'any) (message "%S" erg))
erg))
;; Miscellany.
(defun py--shell-simple-send (proc strg)
(let* ((strg (substring-no-properties strg))
(nln (string-match "\n$" strg)))
;; (or nln (setq strg (concat strg "\n")))
;; (comint-simple-send proc (substring-no-properties strg))
(process-send-string proc strg)
(or nln (process-send-string proc "\n"))))
(defalias
'py-shell-redirect-send-command-to-process
'comint-redirect-send-command-to-process)
(defalias
'py-shell-dynamic-simple-complete
'comint-dynamic-simple-complete)
;; Hooks
;; arrange to kill temp files when Emacs exists
(add-hook 'kill-emacs-hook 'py--kill-emacs-hook)
(when py--warn-tmp-files-left-p
(add-hook 'python-mode-hook 'py--warn-tmp-files-left))
(defun py-guess-pdb-path ()
"If py-pdb-path isn't set, find location of pdb.py. "
(interactive)
(let ((ele (split-string (shell-command-to-string "whereis python")))
erg)
(while (or (not erg)(string= "" erg))
(when (and (string-match "^/" (car ele)) (not (string-match "/man" (car ele))))
(setq erg (shell-command-to-string (concat "find " (car ele) " -type f -name \"pdb.py\""))))
(setq ele (cdr ele)))
(if erg
(message "%s" erg)
(message "%s" "pdb.py not found, please customize `py-pdb-path'"))
erg))
(if py-mode-output-map
nil
(setq py-mode-output-map (make-sparse-keymap))
(define-key py-mode-output-map [button2] 'py-mouseto-exception)
(define-key py-mode-output-map "\C-c\C-c" 'py-goto-exception)
;; TBD: Disable all self-inserting keys. This is bogus, we should
;; really implement this as *Python Output* buffer being read-only
(mapc #' (lambda (key)
(define-key py-mode-output-map key
#'(lambda () (interactive) (beep))))
(where-is-internal 'self-insert-command)))
;; backward compatibility
(defalias 'py-switch-shells 'py-switch-shell)
(defalias 'py-toggle-shell 'py-switch-shell)
(defun py-switch-shell (&optional arg)
"Toggles between the interpreter customized in `py-shell-toggle-1' resp. `py-shell-toggle-2'. Was hard-coded CPython and Jython in earlier versions, now starts with Python2 and Python3 by default.
ARG might be a python-version string to set to.
\\[universal-argument] `py-toggle-shell' prompts to specify a reachable Python command.
\\[universal-argument] followed by numerical arg 2 or 3, `py-toggle-shell' opens a respective Python shell.
\\[universal-argument] followed by numerical arg 5 opens a Jython shell.
Should you need more shells to select, extend this command by adding inside the first cond:
((eq NUMBER (prefix-numeric-value arg))
\"MY-PATH-TO-SHELL\")"
(interactive "P")
(let ((name (cond ((eq 2 (prefix-numeric-value arg))
"python2")
((eq 3 (prefix-numeric-value arg))
"python3")
((eq 4 (prefix-numeric-value arg))
(py--string-strip
(read-from-minibuffer "Python Shell: " py-shell-name) "\" " "\" "
))
((eq 5 (prefix-numeric-value arg))
"jython")
(t (if (string-match py-shell-name
py-shell-toggle-1)
py-shell-toggle-2
py-shell-toggle-1))))
erg msg)
(cond ((or (string= "ipython" name)
(string= "IPython" name))
(setq py-shell-name name
py-which-bufname "IPython"
msg "IPython"
mode-name "IPython"))
((string-match "python3" name)
(setq py-shell-name name
py-which-bufname (py--choose-buffer-name)
msg "CPython"
mode-name (py--choose-buffer-name)))
((string-match "jython" name)
(setq py-shell-name name
py-which-bufname (py--choose-buffer-name)
msg "Jython"
mode-name (py--choose-buffer-name)))
((string-match "python" name)
(setq py-shell-name name
py-which-bufname (py--choose-buffer-name)
msg "CPython"
mode-name py-which-bufname))
(t
(setq py-shell-name name
py-which-bufname name
msg name
mode-name name)))
;; py-edit-only-p has no interpreter
;; (if py-edit-only-p
;; (setq erg py-shell-name)
(setq erg (executable-find py-shell-name))
;;)
(if erg
(progn
(force-mode-line-update)
(when (called-interactively-p 'any)
(message "Using the %s shell, %s" msg erg))
(setq py-output-buffer (format "*%s Output*" py-which-bufname)))
(error (concat "Could not detect " py-shell-name " on your sys
tem")))))
(defun py-toggle-local-default-use ()
(interactive)
"Toggle boolean value of `py-use-local-default'.
Returns `py-use-local-default'
See also `py-install-local-shells'
Installing named virualenv shells is the preffered way,
as it leaves your system default unchanged."
(setq py-use-local-default (not py-use-local-default))
(when (called-interactively-p 'any) (message "py-use-local-default set to %s" py-use-local-default))
py-use-local-default)
(defalias 'py-hungry-delete-forward 'c-hungry-delete-forward)
(defalias 'py-hungry-delete-backwards 'c-hungry-delete-backwards)
;; FixMe: for unknown reasons this is not done by mode
(if (file-readable-p abbrev-file-name)
(add-hook 'python-mode-hook
(lambda ()
(setq py-this-abbrevs-changed abbrevs-changed)
(load abbrev-file-name nil t)
(setq abbrevs-changed py-this-abbrevs-changed)))
(message "Warning: %s" "no abbrev-file found, customize `abbrev-file-name' in order to make mode-specific abbrevs work. "))
;; ;
(push (list
'python-mode
;; start regex
(concat (if py-hide-show-hide-docstrings
"^\\s-*\"\"\"\\|" "")
(mapconcat 'identity
(mapcar #'(lambda (x) (concat "^\\s-*" x "\\_>"))
py-hide-show-keywords)
"\\|"))
;; end regex
nil
;; comment-start regex
"#"
;; forward-sexp function
(lambda ()
(py-forward-block-or-clause))
nil) hs-special-modes-alist)
;; ;
(defun py--input-filter (str)
"`comint-input-filter' function for Python.
Don't save anything for STR matching `py-input-filter-re' "
(not (string-match py-input-filter-re str)))
(make-obsolete 'jpython-mode 'jython-mode nil)
(push (purecopy "*Python*") same-window-buffer-names)
(push (purecopy "*IPython*") same-window-buffer-names)
(push (cons (purecopy "\\.py\\'") 'python-mode) auto-mode-alist)
;; Python Macro File
(push (cons (purecopy "\.pym\'") 'python-mode) auto-mode-alist)
(push (cons (purecopy "\.pyc\'") 'python-mode) auto-mode-alist)
;; Pyrex Source
(push (cons (purecopy "\.pyx\'") 'python-mode) auto-mode-alist)
;; Python Optimized Code
(push (cons (purecopy "\.pyo\'") 'python-mode) auto-mode-alist)
;; Pyrex Definition File
(push (cons (purecopy "\.pxd\'") 'python-mode) auto-mode-alist)
;; Python Repository
(push (cons (purecopy "\.pyr\'") 'python-mode) auto-mode-alist)
;; Python Path Configuration
(push (cons (purecopy "\.pth\'") 'python-mode) auto-mode-alist)
;; Python Wheels
(push (cons (purecopy "\.whl\'") 'python-mode) auto-mode-alist)
(push '("!#[ \t]*/.*[jp]ython[0-9.]*" . python-mode) magic-mode-alist
)
;; lp:1355458, what about using `magic-mode-alist'?
(defun py--uncomment-intern (beg end)
(uncomment-region beg end)
(when py-uncomment-indents-p
(py-indent-region beg end)))
(defun py-uncomment (&optional beg)
"Uncomment commented lines at point.
If region is active, restrict uncommenting at region "
(interactive "*")
(save-excursion
(save-restriction
(when (use-region-p)
(narrow-to-region (region-beginning) (region-end)))
(let* (last
(beg (or beg (save-excursion
(while (and (py-beginning-of-comment) (setq last (point))(prog1 (forward-line -1)(end-of-line))))
last))))
(and (py-forward-comment))
(py--uncomment-intern beg (point))))))
(defun py--set-auto-fill-values ()
"Internal use by `py--run-auto-fill-timer'"
(let ((pps (parse-partial-sexp (point-min) (point))))
(cond ((and (nth 4 pps)(numberp py-comment-fill-column))
(setq fill-column py-comment-fill-column))
((and (nth 3 pps)(numberp py-docstring-fill-column))
(set (make-local-variable 'fill-column) py-docstring-fill-column))
(t (setq fill-column py-fill-column-orig)))))
(defun py--run-auto-fill-timer ()
"Set fill-column to values of `py-docstring-fill-column' resp. to `py-comment-fill-column' according to environment. "
(when py-auto-fill-mode
(unless py-autofill-timer
(setq py-autofill-timer
(run-with-idle-timer
py-autofill-timer-delay t
'py--set-auto-fill-values)))))
;; unconditional Hooks
;; (orgstruct-mode 1)
(add-hook 'python-mode-hook
(lambda ()
(setq imenu-create-index-function py--imenu-create-index-function)
(setq indent-tabs-mode py-indent-tabs-mode)))
(remove-hook 'python-mode-hook 'python-setup-brm)
(defun py-complete-auto ()
"Auto-complete function using py-complete. "
;; disable company
;; (when company-mode (company-mode))
(let ((modified (buffer-chars-modified-tick)))
;; don't try completion if buffer wasn't modified
(unless (eq modified py-complete-last-modified)
(if py-auto-completion-mode-p
(if (string= "*PythonCompletions*" (buffer-name (current-buffer)))
(sit-for 0.1 t)
(if
(eq py-auto-completion-buffer (current-buffer))
;; not after whitespace, TAB or newline
(unless (member (char-before) (list 32 9 10))
(py-complete)
(setq py-complete-last-modified (buffer-chars-modified-tick)))
(setq py-auto-completion-mode-p nil
py-auto-completion-buffer nil)
(cancel-timer py--auto-complete-timer)))))))
(defun py-set-command-args (arguments)
"Set Python arguments on the fly, override defaults in this session.
Use `defcustom' to keep value across sessions "
(interactive
(list
(read-from-minibuffer "Command args: " py-python-command-args)))
(setq py-python-command-args arguments))
(defun py---emacs-version-greater-23 ()
"Return `t' if emacs major version is above 23"
(< 23 (string-to-number (car (split-string emacs-version "\\.")))))
(defun py--empty-arglist-indent (nesting &optional indent-offset indent-offset)
"Internally used by `py-compute-indentation'"
(if
(and (eq 1 nesting)
(save-excursion
(back-to-indentation)
(looking-at py-extended-block-or-clause-re)))
(progn
(back-to-indentation)
(+ (current-column) (* 2 (or indent-offset py-indent-offset))))
(+ (current-indentation) (or indent-offset py-indent-offset))))
(defun py-symbol-at-point ()
"Return the current Python symbol."
(interactive)
(let ((erg (with-syntax-table
py-dotted-expression-syntax-table
(current-word))))
;; (when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py-kill-buffer-unconditional (buffer)
"Kill buffer unconditional, kill buffer-process if existing. "
(interactive
(list (current-buffer)))
(let ((buffer (or (and (bufferp buffer) buffer)
(get-buffer buffer)))
proc kill-buffer-query-functions)
(ignore-errors
(setq proc (get-buffer-process buffer))
(and proc (kill-process proc))
(set-buffer buffer)
(set-buffer-modified-p 'nil)
(kill-buffer (current-buffer)))))
(defun py--line-backward-maybe ()
"Return result of (< 0 (abs (skip-chars-backward \" \\t\\r\\n\\f\"))) "
(skip-chars-backward " \t\f" (line-beginning-position))
(< 0 (abs (skip-chars-backward " \t\r\n\f"))))
(defun py--after-empty-line ()
"Return `t' if line before contains only whitespace characters. "
(save-excursion
(beginning-of-line)
(forward-line -1)
(beginning-of-line)
(looking-at "\\s-*$")))
(defalias 'py-count-indentation 'py-compute-indentation)
(defun py-compute-indentation (&optional iact orig origline closing line nesting repeat indent-offset liep)
"Compute Python indentation.
When HONOR-BLOCK-CLOSE-P is non-nil, statements such as `return',
`raise', `break', `continue', and `pass' force one level of dedenting.
Optional arguments are flags resp. values set and used by `py-compute-indentation' internally:
ORIG keeps original position
ORIGLINE keeps line where compute started
CLOSING is t when started at a char delimiting a list as \"]})\"
LINE indicates being not at origline now
NESTING is currently ignored, if executing from inside a list
REPEAT counter enables checks against `py-max-specpdl-size'
INDENT-OFFSET allows calculation of block-local values
LIEP stores line-end-position at point-of-interest
"
(interactive "p")
(save-excursion
(save-restriction
(widen)
;; in shell, narrow from previous prompt
;; needed by closing
(unless orig (unless (bobp) (back-to-indentation)))
(let* ((orig (or orig (point)))
(origline (or origline (py-count-lines (point-min) (point))))
;; closing indicates: when started, looked
;; at a single closing parenthesis
;; line: moved already a line backward
(liep (or liep (line-end-position)))
(line line)
(verbose py-verbose-p)
(pps (parse-partial-sexp (point-min) (point)))
(closing
(or closing
(and (nth 1 pps)
(looking-at ".*\\(\\s)\\)")(nth 0 pps)
;; char doesn't matter for now, maybe drop
(string-to-char (match-string-no-properties 1)))))
;; in a recursive call already
(repeat (if repeat
(setq repeat (1+ repeat))
0))
;; nesting: started nesting a list
(nesting nesting)
(indent-offset (or indent-offset py-indent-offset))
(cubuf (current-buffer))
erg indent this-line)
(if (and (< repeat 1)
(and (comint-check-proc (current-buffer))
(re-search-backward (concat py-shell-prompt-regexp "\\|" py-ipython-output-prompt-re "\\|" py-ipython-input-prompt-re) nil t 1)))
;; common recursion not suitable because of prompt
(with-temp-buffer
(insert-buffer-substring cubuf (match-end 0) orig)
(setq indent (py-compute-indentation)))
(if (< py-max-specpdl-size repeat)
(error "`py-compute-indentation' reached loops max.") (setq nesting (nth 0 pps))
(setq indent
(cond ((bobp)
(cond ((eq liep (line-end-position))
0)
((looking-at py-outdent-re)
(+ (if py-smart-indentation (py-guess-indent-offset) indent-offset) (current-indentation)))
(t
(current-indentation))))
;; in string
((and (nth 3 pps)(nth 8 pps))
(cond
((py--docstring-p)
(save-excursion
(back-to-indentation)
(skip-chars-backward " \t\r\n\f")
(back-to-indentation)
(current-indentation)))
(t 0)))
((and (looking-at "\"\"\"\\|'''")(not (bobp)))
(py-backward-statement)
(py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep))
;; comments
((nth 8 pps)
(if (eq liep (line-end-position))
(progn
(goto-char (nth 8 pps))
(when (py--line-backward-maybe) (setq line t))
(skip-chars-backward " \t")
(py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep))
(goto-char (nth 8 pps))
(if
line
(if py-indent-honors-inline-comment
(current-column)
(if py-indent-comments
(progn
(py-backward-comment)
(py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep))
0))
(forward-char -1)
(py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep))))
((and
(looking-at (concat "[ \t]*" comment-start))
(looking-back "^[ \t]*" (line-beginning-position))(not line)
(eq liep (line-end-position)))
(if py-indent-comments
(progn
(setq line t)
(skip-chars-backward " \t\r\n\f")
;; as previous comment-line might
;; be wrongly unindented, travel
;; whole commented section
(py-backward-comment)
(py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep))
0))
((and
(looking-at (concat "[ \t]*" comment-start))
(looking-back "^[ \t]*" (line-beginning-position))
(not (eq liep (line-end-position))))
(current-indentation))
((and (eq 11 (syntax-after (point))) line py-indent-honors-inline-comment)
(current-column))
;; lists
((nth 1 pps)
(save-excursion
(goto-char (nth 1 pps))
(setq this-line (py-count-lines))
(cond
((< 0 (- origline this-line))
(if (< 1 (- origline this-line))
(cond
(closing
(cond
(py-closing-list-dedents-bos
(goto-char (nth 1 pps))
(current-indentation))
((looking-back "^[ \t]*" (line-beginning-position))
(current-column))
((and (looking-at "\\s([ \t]*$") py-closing-list-keeps-space)
(+ (current-column) py-closing-list-space))
((looking-at "\\s([ \t]*$")
(py--empty-arglist-indent nesting py-indent-offset indent-offset))
((looking-at "\\s([ \t]*\\([^ \t]+.*\\)$")
(goto-char (match-beginning 1))
(if py-indent-paren-spanned-multilines-p
(+ (current-column) py-indent-offset)
(current-column)))
(t (py--fetch-previous-indent orig))))
;; already behind a dedented element in list
((<= 2 (- origline this-line))
(py--fetch-previous-indent orig))
((< (current-indentation) (current-column))
(+ (current-indentation) py-indent-offset))
(t (py--fetch-previous-indent orig)))
(cond ((looking-at "\\s([ \t]*$")
(py--empty-arglist-indent nesting py-indent-offset indent-offset))
((looking-at "\\s([ \t]*\\([^ \t]+.*\\)$")
(goto-char (match-beginning 1))
(if py-indent-paren-spanned-multilines-p
(+ (current-column) py-indent-offset)
(current-column)))
(t (+ (current-column) (* (nth 0 pps)))))))
((nth 1 (parse-partial-sexp (point-min) (point)))
(goto-char (nth 1 (parse-partial-sexp (point-min) (point))))
(setq line
;; should be faster
(< (line-end-position) liep))
(py-compute-indentation orig origline closing line nesting repeat indent-offset liep))
((not (py--beginning-of-statement-p))
(py-backward-statement)
(py-compute-indentation orig origline closing line nesting repeat indent-offset liep))
(t (1+ (current-column))))))
((and (eq (char-after) (or ?\( ?\{ ?\[)) line)
(1+ (current-column)))
((py-preceding-line-backslashed-p)
(progn
(py-backward-statement)
(setq this-line (py-count-lines))
(if (< 1 (- origline this-line))
(py--fetch-previous-indent orig)
(if (looking-at "from +\\([^ \t\n]+\\) +import")
py-backslashed-lines-indent-offset
(+ (current-indentation) py-continuation-offset)))))
((and (looking-at py-block-closing-keywords-re)
(eq liep (line-end-position)))
(skip-chars-backward "[ \t\r\n\f]")
(py-backward-statement)
(cond ((looking-at py-extended-block-or-clause-re)
(+
(if py-smart-indentation (py-guess-indent-offset) indent-offset)
(current-indentation)))
((looking-at py-block-closing-keywords-re)
(- (current-indentation) py-indent-offset))
(t (current-column))))
((looking-at py-block-closing-keywords-re)
(if (< (line-end-position) orig)
(- (current-indentation) py-indent-offset)
(py-backward-block-or-clause (current-indentation))
(current-indentation)))
((and (looking-at py-elif-re) (eq (py-count-lines) origline))
(when (py--line-backward-maybe) (setq line t))
(car (py--clause-lookup-keyword py-elif-re -1 nil origline)))
((and (looking-at py-clause-re)(not line)
(eq liep (line-end-position)))
(cond ((looking-at py-finally-re)
(car (py--clause-lookup-keyword py-finally-re -1 nil origline)))
((looking-at py-except-re)
(car (py--clause-lookup-keyword py-except-re -1 nil origline)))
((looking-at py-else-block-re)
(car (py--clause-lookup-keyword py-else-block-re -1 nil origline)))
((looking-at py-elif-block-re)
(car (py--clause-lookup-keyword py-elif-re -1 nil origline)))
;; maybe at if, try, with
(t (car (py--clause-lookup-keyword py-block-or-clause-re -1 nil origline)))))
((looking-at py-extended-block-or-clause-re)
(cond ((and (not line)
(eq liep (line-end-position)))
(when (py--line-backward-maybe) (setq line t))
(py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep))
(t (+
(cond (indent-offset)
(py-smart-indentation
(py-guess-indent-offset))
(t py-indent-offset))
(current-indentation)))))
((and
(< (line-end-position) liep)
(eq (current-column) (current-indentation)))
(and
(looking-at py-assignment-re)
(goto-char (match-end 0)))
;; multiline-assignment
(if (and nesting (looking-at " *[[{(]")(not (looking-at ".+[]})][ \t]*$")))
(+ (current-indentation) py-indent-offset)
(current-indentation)))
((looking-at py-assignment-re)
(py-backward-statement)
(py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep))
((and (< (current-indentation) (current-column))(not line))
(back-to-indentation)
(unless line
(setq nesting (nth 0 (parse-partial-sexp (point-min) (point)))))
(py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep))
((and (not (py--beginning-of-statement-p)) (not (and line (eq 11 (syntax-after (point))))))
(if (bobp)
(current-column)
(if (eq (point) orig)
(progn
(when (py--line-backward-maybe) (setq line t))
(py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep))
(py-backward-statement)
(py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep))))
((or (py--statement-opens-block-p py-extended-block-or-clause-re)(looking-at "@"))
(if (< (py-count-lines) origline)
(+ (if py-smart-indentation (py-guess-indent-offset) indent-offset) (current-indentation))
(skip-chars-backward " \t\r\n\f")
(setq line t)
(back-to-indentation)
(py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep)))
((and py-empty-line-closes-p (py--after-empty-line))
(progn (py-backward-statement)
(- (current-indentation) py-indent-offset)))
;; still at orignial line
((and (eq liep (line-end-position))
(save-excursion
(and (setq erg (py--go-to-keyword py-extended-block-or-clause-re))
(if py-smart-indentation (setq indent-offset (py-guess-indent-offset)) t)
(ignore-errors (< orig (or (py-forward-block-or-clause)(point)))))))
(+ (car erg) (if py-smart-indentation
(or indent (py-guess-indent-offset))
indent-offset)))
((and (not line)
(eq liep (line-end-position))
(py--beginning-of-statement-p))
(py-backward-statement)
(py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep))
(t (current-indentation))))
(when (and verbose iact) (message "%s" indent))
indent))))))
(defun py--fetch-previous-indent (orig)
"Report the preceding indent. "
(save-excursion
(goto-char orig)
(forward-line -1)
(end-of-line)
(skip-chars-backward " \t\r\n\f")
(current-indentation)))
(defun py-continuation-offset (&optional arg)
"With numeric ARG different from 1 py-continuation-offset is set to that value; returns py-continuation-offset. "
(interactive "p")
(and (numberp arg) (not (eq 1 arg)) (setq py-continuation-offset arg))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" py-continuation-offset))
py-continuation-offset)
(defalias 'pios 'py-indentation-of-statement)
(defalias 'ios 'py-indentation-of-statement)
(defun py-indentation-of-statement ()
"Returns the indenation of the statement at point. "
(interactive)
(let ((erg (save-excursion
(back-to-indentation)
(or (py--beginning-of-statement-p)
(py-backward-statement))
(current-indentation))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defalias 'py-in-list-p 'py-list-beginning-position)
(defun py-list-beginning-position (&optional start)
"Return lists beginning position, nil if not inside.
Optional ARG indicates a start-position for `parse-partial-sexp'."
(nth 1 (parse-partial-sexp (or start (point-min)) (point))))
(defun py-end-of-list-position (&optional arg)
"Return end position, nil if not inside.
Optional ARG indicates a start-position for `parse-partial-sexp'."
(interactive)
(let* ((ppstart (or arg (point-min)))
(erg (parse-partial-sexp ppstart (point)))
(beg (nth 1 erg))
end)
(when beg
(save-excursion
(goto-char beg)
(forward-list 1)
(setq end (point))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" end))
end))
(defun py--in-comment-p ()
"Return the beginning of current line's comment, if inside. "
(save-restriction
(widen)
(let* ((pps (parse-partial-sexp (point-min) (point)))
(erg (when (nth 4 pps) (nth 8 pps))))
(unless erg
(when (looking-at (concat "^[ \t]*" comment-start-skip))
(setq erg (point))))
erg)))
(defun py-in-triplequoted-string-p ()
"Returns character address of start tqs-string, nil if not inside. "
(interactive)
(let* ((pps (parse-partial-sexp (point-min) (point)))
(erg (when (and (nth 3 pps) (nth 8 pps))(nth 2 pps))))
(save-excursion
(unless erg (setq erg
(progn
(when (looking-at "\"\"\"\\|''''")
(goto-char (match-end 0))
(setq pps (parse-partial-sexp (point-min) (point)))
(when (and (nth 3 pps) (nth 8 pps)) (nth 2 pps)))))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-in-string-p-intern (pps)
(goto-char (nth 8 pps))
(list (point) (char-after)(skip-chars-forward (char-to-string (char-after)))))
(defun py-in-string-p ()
"if inside a double- triple- or singlequoted string,
If non-nil, return a list composed of
- beginning position
- the character used as string-delimiter (in decimal)
- and length of delimiter, commonly 1 or 3 "
(interactive)
(save-excursion
(let* ((pps (parse-partial-sexp (point-min) (point)))
(erg (when (nth 3 pps)
(py-in-string-p-intern pps))))
(unless erg
(when (looking-at "\"\\|'")
(forward-char 1)
(setq pps (parse-partial-sexp (line-beginning-position) (point)))
(when (nth 3 pps)
(setq erg (py-in-string-p-intern pps)))))
;; (list (nth 8 pps) (char-before) (1+ (skip-chars-forward (char-to-string (char-before)))))
;; (when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg)))
(defun py-in-statement-p ()
"Returns list of beginning and end-position if inside.
Result is useful for booleans too: (when (py-in-statement-p)...)
will work.
"
(interactive)
(let ((orig (point))
beg end erg)
(save-excursion
(setq end (py-forward-statement))
(setq beg (py-backward-statement))
(when (and (<= beg orig)(<= orig end))
(setq erg (cons beg end))
(when (called-interactively-p 'any) (message "%s" erg))
erg))))
;; Beginning-of- p
(defun py-backward-top-level-p ()
"Returns position, if cursor is at the beginning of a top-level, nil otherwise. "
(interactive)
(let (erg)
(and (py--beginning-of-statement-p)
(eq 0 (current-column))
(setq erg (point))
erg)))
(defun py--beginning-of-buffer-p ()
"Returns position, if cursor is at the beginning of buffer, nil otherwise. "
(when (bobp)(point)))
;; End-of- p
;; Opens
(defun py--statement-opens-block-p (&optional regexp)
"Return position if the current statement opens a block
in stricter or wider sense.
For stricter sense specify regexp. "
(let* ((regexp (or regexp py-block-or-clause-re))
(erg (py--statement-opens-base regexp)))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py--statement-opens-base (regexp)
(let ((orig (point))
erg)
(save-excursion
(back-to-indentation)
(py-forward-statement)
(py-backward-statement)
(when (and
(<= (line-beginning-position) orig)(looking-back "^[ \t]*" (line-beginning-position))(looking-at regexp))
(setq erg (point))))
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py--statement-opens-clause-p ()
"Return position if the current statement opens block or clause. "
(py--statement-opens-base py-clause-re))
(defun py--statement-opens-block-or-clause-p ()
"Return position if the current statement opens block or clause. "
(py--statement-opens-base py-block-or-clause-re))
(defun py--statement-opens-class-p ()
"Return `t' if the statement opens a functions or class definition, nil otherwise. "
(py--statement-opens-base py-class-re))
(defun py--statement-opens-def-p ()
"Return `t' if the statement opens a functions or class definition, nil otherwise. "
(py--statement-opens-base py-def-re))
(defun py--statement-opens-def-or-class-p ()
"Return `t' if the statement opens a functions or class definition, nil otherwise. "
(py--statement-opens-base py-def-or-class-re))
(defun py--record-list-error (pps)
"When encountering a missing parenthesis, store its line, position. `py-verbose-p' must be t
Unclosed-string errors are not handled here, as made visible by fontification already.
"
(let ((this-err
(save-excursion
(list
(nth 1 pps)
(progn
(goto-char (nth 1 pps))
(py-count-lines (point-min) (point)))))))
this-err))
(defun py--message-error (err)
"Receives a list (position line) "
(message "Closing paren missed: line %s pos %s" (cadr err) (car err)))
(defun py--end-base-look-upward (thisregexp regexp)
(progn (back-to-indentation)
(let ((bofst (py--beginning-of-statement-p)))
(cond ((and bofst (eq regexp 'py-clause-re)(looking-at py-extended-block-or-clause-re))
(point))
((and bofst (looking-at thisregexp))
(point))
(t
(when
(cdr-safe
(py--go-to-keyword
thisregexp))
(when (py--statement-opens-block-p py-extended-block-or-clause-re)
(point))))))))
(defun py--go-down-when-found-upward (regexp)
(let ((thisindent (current-indentation))
last)
(back-to-indentation)
(while
(and (py-down-statement)
(or (< thisindent (current-indentation))
(and (eq thisindent (current-indentation))
(or (eq regexp 'py-minor-block-re)
(eq regexp 'py-block-re)
(eq regexp 'py-if-block-re))
(looking-at py-clause-re)))
(py-forward-statement)(setq last (point))))
(and last (goto-char last))))
(defun py--end-of-paragraph (regexp)
(let* ((regexp (if (symbolp regexp) (symbol-value regexp)
regexp)))
(while (and (not (eobp)) (re-search-forward regexp nil 'move 1)(nth 8 (parse-partial-sexp (point-min) (point)))))))
(defun py--end-base (regexp &optional orig decorator bol indent done)
"Used internal by functions going to the end forms.
Must find start first "
(unless (eobp)
(if (eq regexp 'py-paragraph-re)
(py--end-of-paragraph regexp)
(let* ((pps (parse-partial-sexp (point-min) (point)))
;; (repeat (or (and repeat (1+ repeat)) 0))
(orig (or orig (point)))
(regexp (or regexp (symbol-value 'py-extended-block-or-clause-re)))
(thisregexp (if (symbolp regexp)
(cond ((eq regexp 'py-clause-re)
(symbol-value 'py-extended-block-or-clause-re))
(t (symbol-value regexp)))
regexp))
(indent (or indent (if (py--beginning-of-statement-p)
(current-indentation)
(save-excursion (py-backward-statement) (current-indentation)))))
;; start of form maybe inside
(this
(if (and (looking-at thisregexp)(not (or (nth 1 pps) (nth 8 pps))))
(point)
(py--go-to-keyword thisregexp indent)))
erg)
(cond
(this (setq erg (py--go-down-when-found-upward regexp)))
(t (goto-char orig)))
(if (< orig (point))
(and erg bol (setq erg (py--beginning-of-line-form erg)))
(setq erg nil)
(unless (eq done orig)
(when
(py-forward-statement)
(py--end-base regexp (point) decorator bol indent (point)))))
erg))))
(defun py--look-downward-for-beginning (regexp)
"When above any beginning of FORM, search downward. "
(let* ((orig (point))
(erg orig)
(last orig)
pps)
(while (and (setq last (point)) (not (eobp)) (re-search-forward regexp nil t 1)(setq erg (match-beginning 0)) (setq pps (parse-partial-sexp (point-min) (point)))
(or (nth 8 pps) (nth 1 pps))))
(cond ((not (or (nth 8 pps) (nth 1 pps) (or (looking-at comment-start))))
(when (ignore-errors (< orig erg))
erg)))))
(defun py-look-downward-for-clause (&optional ind orig regexp)
"If beginning of other clause exists downward in current block.
If succesful return position. "
(interactive)
(unless (eobp)
(let ((ind (or ind
(save-excursion
(py-backward-statement)
(if (py--statement-opens-block-p)
(current-indentation)
(- (current-indentation) py-indent-offset)))))
(orig (or orig (point)))
(regexp (or regexp py-extended-block-or-clause-re))
erg last)
(end-of-line)
(when (re-search-forward regexp nil t 1)
(when (nth 8 (parse-partial-sexp (point-min) (point)))
(while (and (re-search-forward regexp nil t 1)
(nth 8 (parse-partial-sexp (point-min) (point))))))
(setq last (point))
(back-to-indentation)
(unless (and (looking-at py-clause-re)
(not (nth 8 (parse-partial-sexp (point-min) (point)))) (eq (current-indentation) ind))
(progn (setq ind (current-indentation))
(while (and (py-forward-statement-bol)(not (looking-at py-clause-re))(<= ind (current-indentation)))))
(if (and (looking-at py-clause-re)
(not (nth 8 (parse-partial-sexp (point-min) (point))))
(< orig (point)))
(setq erg (point))
(goto-char orig))))
(when (called-interactively-p 'any) (message "%s" erg))
erg)))
(defun py-current-defun (&optional iact)
"Go to the outermost method or class definition in current scope.
Python value for `add-log-current-defun-function'.
This tells add-log.el how to find the current function/method/variable.
Returns name of class or methods definition, if found, nil otherwise.
See customizable variables `py-current-defun-show' and `py-current-defun-delay'."
(interactive "p")
(save-restriction
(widen)
(save-excursion
(let ((erg (when (py-backward-def-or-class)
(forward-word 1)
(skip-chars-forward " \t")
(prin1-to-string (symbol-at-point)))))
(when (and erg py-current-defun-show)
(push-mark (point) t t) (skip-chars-forward "^ (")
(exchange-point-and-mark)
(sit-for py-current-defun-delay))
(when iact (message (prin1-to-string erg)))
erg))))
(defun py-sort-imports ()
"Sort multiline imports.
Put point inside the parentheses of a multiline import and hit
\\[py-sort-imports] to sort the imports lexicographically"
(interactive)
(save-excursion
(let ((open-paren (ignore-errors (save-excursion (progn (up-list -1) (point)))))
(close-paren (ignore-errors (save-excursion (progn (up-list 1) (point)))))
sorted-imports)
(when (and open-paren close-paren)
(goto-char (1+ open-paren))
(skip-chars-forward " \n\t")
(setq sorted-imports
(sort
(delete-dups
(split-string (buffer-substring
(point)
(save-excursion (goto-char (1- close-paren))
(skip-chars-backward " \n\t")
(point)))
", *\\(\n *\\)?"))
;; XXX Should this sort case insensitively?
'string-lessp))
;; Remove empty strings.
(delete-region open-paren close-paren)
(goto-char open-paren)
(insert "(\n")
(insert (py--join-words-wrapping (remove "" sorted-imports) "," " " 78))
(insert ")")))))
(defun py--in-literal (&optional lim)
"Return non-nil if point is in a Python literal (a comment or string).
Optional argument LIM indicates the beginning of the containing form,
i.e. the limit on how far back to scan."
(let* ((lim (or lim (point-min)))
(state (parse-partial-sexp (point-min) (point))))
(cond
((nth 3 state) 'string)
((nth 4 state) 'comment))))
(defconst py-help-address "python-mode@python.org"
"List dealing with usage and developing python-mode.
Also accepts submission of bug reports, whilst a ticket at
http://launchpad.net/python-mode
is preferable for that. ")
;; Utilities
(defun py--point (position)
"Returns the value of point at certain commonly referenced POSITIONs.
POSITION can be one of the following symbols:
bol -- beginning of line
eol -- end of line
bod -- beginning of def or class
eod -- end of def or class
bob -- beginning of buffer
eob -- end of buffer
boi -- back to indentation
bos -- beginning of statement
This function does not modify point or mark."
(let (erg)
(save-excursion
(setq erg
(progn
(cond
((eq position 'bol) (beginning-of-line))
((eq position 'eol) (end-of-line))
((eq position 'bod) (py-backward-def-or-class))
((eq position 'eod) (py-forward-def-or-class))
;; Kind of funny, I know, but useful for py-up-exception.
((eq position 'bob) (goto-char (point-min)))
((eq position 'eob) (goto-char (point-max)))
((eq position 'boi) (back-to-indentation))
((eq position 'bos) (py-backward-statement))
(t (error "Unknown buffer position requested: %s" position))) (point))))
erg))
(defun py-install-search-local ()
(interactive)
(let ((erg (split-string (shell-command-to-string (concat "find " default-directory " -maxdepth 9 -type f -name \"*python\"")))))))
(defun py-install-local-shells (&optional local)
"Builds Python-shell commands from executable found in LOCAL.
If LOCAL is empty, shell-command `find' searches beneath current directory.
Eval resulting buffer to install it, see customizable `py-extensions'. "
(interactive)
(let* ((local-dir (if local
(expand-file-name local)
(read-from-minibuffer "Virtualenv directory: " default-directory)))
(path-separator (if (string-match "/" local-dir)
"/"
"\\" t))
(shells (split-string (shell-command-to-string (concat "find " local-dir " -maxdepth 9 -type f -executable -name \"*python\""))))
prefix end orig curexe aktpath)
(set-buffer (get-buffer-create py-extensions))
(erase-buffer)
(dolist (elt shells)
(setq prefix "")
(setq curexe (substring elt (1+ (string-match "/[^/]+$" elt))))
(setq aktpath (substring elt 0 (1+ (string-match "/[^/]+$" elt))))
(dolist (prf (split-string aktpath (regexp-quote path-separator)))
(unless (string= "" prf)
(setq prefix (concat prefix (substring prf 0 1)))))
(setq orig (point))
(insert py-shell-template)
(setq end (point))
(goto-char orig)
(when (re-search-forward "\\" end t 1)
(replace-match (concat prefix "-" (substring elt (1+ (save-match-data (string-match "/[^/]+$" elt)))))t))
(goto-char orig)
(while (search-forward "DOCNAME" end t 1)
(replace-match (if (string= "ipython" curexe)
"IPython"
(capitalize curexe)) t))
(goto-char orig)
(when (search-forward "FULLNAME" end t 1)
(replace-match elt t))
(goto-char (point-max)))
(emacs-lisp-mode)
(if (file-readable-p (concat py-install-directory "/" py-extensions))
(find-file (concat py-install-directory "/" py-extensions)))))
(defun py-end-of-string (&optional beginning-of-string-position)
"Go to end of string at point if any, if successful return position. "
(interactive)
(let ((orig (point))
(beginning-of-string-position (or beginning-of-string-position (and (nth 3 (parse-partial-sexp 1 (point)))(nth 8 (parse-partial-sexp 1 (point))))
(and (looking-at "\"\"\"\\|'''\\|\"\\|\'")(match-beginning 0))))
erg)
(if beginning-of-string-position
(progn
(goto-char beginning-of-string-position)
(when
;; work around parse-partial-sexp error
(and (nth 3 (parse-partial-sexp 1 (point)))(nth 8 (parse-partial-sexp 1 (point))))
(goto-char (nth 3 (parse-partial-sexp 1 (point)))))
(if (ignore-errors (setq erg (scan-sexps (point) 1)))
(goto-char erg)
(goto-char orig)))
(error (concat "py-end-of-string: don't see end-of-string at " (buffer-name (current-buffer)) "at pos " (point))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
;; (goto-char (match-end 0))
;; (search-forward (match-string-no-properties 0))))
(defun py--until-found (search-string liste)
"Search liste for search-string until found. "
(let ((liste liste) element)
(while liste
(if (member search-string (car liste))
(setq element (car liste) liste nil))
(setq liste (cdr liste)))
(when element
(while (and element (not (numberp element)))
(if (member search-string (car element))
(setq element (car element))
(setq element (cdr element))))
element)))
(defun py--delay-process-dependent (process)
"Call a `py-ipython-send-delay' or `py-python-send-delay' according to process"
(if (string-match "ipython" (prin1-to-string process))
(sit-for py-ipython-send-delay t)
(sit-for py-python-send-delay t)))
(defun py--send-string-no-output (strg &optional process msg)
"Send STRING to PROCESS and inhibit output display.
When MSG is non-nil messages the first line of STRING. Return
the output."
(let* (output
(process (or process (get-buffer-process (py-shell))))
(comint-preoutput-filter-functions
(append comint-preoutput-filter-functions
'(ansi-color-filter-apply
(lambda (strg)
(setq output strg)
"")))))
(py-send-string strg process)
(sit-for 0.1 t)
;; (py--delay-process-dependent process)
(when (and output (not (string= "" output)))
(py--string-strip
(format "[ \n]*%s[ \n]*" py-fast-filter-re)))))
(defun py--send-string-return-output (strg &optional process msg)
"Send STRING to PROCESS and return output.
When MSG is non-nil messages the first line of STRING. Return
the output."
(let ((process (or process (get-buffer-process (py-shell)))))
(with-current-buffer (process-buffer process)
(let* (erg
(comint-preoutput-filter-functions
(append comint-preoutput-filter-functions
'(ansi-color-filter-apply
(lambda (strg)
strg)))))
(py-send-string strg process)
(accept-process-output process 5)
(sit-for 0.1 t)
(when (and erg (not (string= "" erg)))
(setq erg
(replace-regexp-in-string
(format "[ \n]*%s[ \n]*" py-fast-filter-re)
"" erg)))
;; (sit-for 0.1 t)
erg))))
(defun py-which-def-or-class (&optional orig)
"Returns concatenated `def' and `class' names in hierarchical order, if cursor is inside.
Returns \"???\" otherwise
Used by variable `which-func-functions' "
(interactive)
(let* ((orig (or orig (point)))
(backindent 99999)
(re (concat py-def-or-class-re "\\([[:alnum:]_]+\\)"))
erg forward indent backward limit)
(if
(and (looking-at re)
(not (nth 8 (parse-partial-sexp (point-min) (point)))))
(progn
(setq erg (list (match-string-no-properties 2)))
(setq backindent (current-indentation)))
;; maybe inside a definition's symbol
(or (eolp) (and (looking-at "[[:alnum:]]")(forward-word 1))))
(if
(and (not (and erg (eq 0 (current-indentation))))
(setq limit (py-backward-top-level))
(looking-at re))
(progn
(push (match-string-no-properties 2) erg)
(setq indent (current-indentation)))
(goto-char orig)
(while (and
(re-search-backward py-def-or-class-re limit t 1)
(< (current-indentation) backindent)
(setq backindent (current-indentation))
(setq backward (point))
(or (< 0 (current-indentation))
(nth 8 (parse-partial-sexp (point-min) (point))))))
(when (and backward
(goto-char backward)
(looking-at re))
(push (match-string-no-properties 2) erg)
(setq indent (current-indentation))))
;; (goto-char orig))
(if erg
(progn
(end-of-line)
(while (and (re-search-forward py-def-or-class-re nil t 1)
(<= (point) orig)
(< indent (current-indentation))
(or
(nth 8 (parse-partial-sexp (point-min) (point)))
(setq forward (point)))))
(if forward
(progn
(goto-char forward)
(save-excursion
(back-to-indentation)
(and (looking-at re)
(setq erg (list (car erg) (match-string-no-properties 2)))
;; (< (py-forward-def-or-class) orig)
;; if match was beyond definition, nil
;; (setq erg nil)
)))
(goto-char orig))))
(if erg
(if (< 1 (length erg))
(setq erg (mapconcat 'identity erg "."))
(setq erg (car erg)))
(setq erg "???"))
(goto-char orig)
(when (called-interactively-p 'any) (message "%s" erg))
erg))
(defun py--beginning-of-form-intern (final-re &optional inter-re iact indent orig lc decorator)
"Go to beginning of FORM.
With INDENT, go to beginning one level above.
Whit IACT, print result in message buffer.
Returns beginning of FORM if successful, nil otherwise"
(interactive "P")
(let ((regexp
;; (if inter-re
;; (concat (symbol-value inter-re) "\\|" (symbol-value final-re))
(symbol-value final-re))
;; ))
erg)
(unless (bobp)
(let* ((orig (or orig (point)))
(indent (or indent (progn
(back-to-indentation)
(or (py--beginning-of-statement-p)
(py-backward-statement))
(current-indentation)))))
(setq erg (cond ((and (< (point) orig) (looking-at regexp))
(point))
((and (eq 0 (current-column)) (numberp indent) (< 0 indent))
(when (< 0 (abs (skip-chars-backward " \t\r\n\f")))
(py-backward-statement)
(unless (looking-at regexp)
(cdr (py--go-to-keyword regexp (current-indentation))))))
((numberp indent)
(or (cdr (py--go-to-keyword regexp indent))
(progn
(goto-char orig)
(cdr (py--go-to-keyword regexp indent)))))
(t (ignore-errors
(cdr (py--go-to-keyword regexp
(- (progn (if (py--beginning-of-statement-p) (current-indentation) (save-excursion (py-backward-statement) (current-indentation)))) py-indent-offset)))))))
(when lc (beginning-of-line) (setq erg (point)))))
(when (and py-verbose-p iact) (message "%s" erg))
erg))
(defun py--backward-prepare (&optional indent final-re inter-re iact decorator lc)
(let* ((orig (point))
(indent
(or indent
(progn
(or (py--beginning-of-statement-p)
(py-backward-statement))
;; maybe after last statement?
(when (save-excursion
(< (py-forward-statement) orig))
(goto-char orig))
(cond ((looking-back "^[ \t]*" (line-beginning-position))
(current-indentation))
(t (progn (back-to-indentation)
(cond ((eq 0 (current-indentation))
(current-indentation))
((and inter-re (looking-at (symbol-value inter-re)))
(current-indentation)))))))))
erg)
;; def and class need lesser value
(when (and
(member final-re (list 'py-def-or-class-re 'py-class-re 'py-def-re))
(<= 0 (- indent (if py-smart-indentation (py-guess-indent-offset) py-indent-offset))))
(setq indent (- indent (if py-smart-indentation (py-guess-indent-offset) py-indent-offset))))
(if (and (< (point) orig) (looking-at (symbol-value final-re)))
(progn
(and lc (beginning-of-line))
(setq erg (point))
(when (and py-verbose-p iact) (message "%s" erg))
erg)
(py--beginning-of-form-intern final-re inter-re iact indent orig lc decorator))))
(defun py--fetch-first-python-buffer ()
"Returns first (I)Python-buffer found in `buffer-list'"
(let ((buli (buffer-list))
erg)
(while (and buli (not erg))
(if (string-match "Python" (prin1-to-string (car buli)))
(setq erg (car buli))
(setq buli (cdr buli))))
erg))
(defun py-unload-python-el ()
"Unloads python-mode delivered by shipped python.el
Removes python-skeleton forms from abbrevs.
These would interfere when inserting forms heading a block"
(interactive)
(let (done)
(when (featurep 'python) (unload-feature 'python t))
(when (file-readable-p abbrev-file-name)
(find-file abbrev-file-name)
(goto-char (point-min))
(while (re-search-forward "^.+python-skeleton.+$" nil t 1)
(setq done t)
(delete-region (match-beginning 0) (1+ (match-end 0))))
(when done (write-file abbrev-file-name)
;; now reload
(read-abbrev-file abbrev-file-name))
(kill-buffer (file-name-nondirectory abbrev-file-name)))))
(defmacro py--kill-buffer-unconditional (buffer)
"Kill buffer unconditional, kill buffer-process if existing. "
`(let ((proc (get-buffer-process ,buffer))
kill-buffer-query-functions)
(ignore-errors
(and proc (kill-process proc))
(set-buffer ,buffer)
(set-buffer-modified-p 'nil)
(kill-buffer (current-buffer)))))
(defun py--skip-to-semicolon-backward (&optional limit)
"Fetch the beginning of statement after a semicolon.
Returns position reached if point was moved. "
(prog1
(< 0 (abs (skip-chars-backward "^;" (or limit (line-beginning-position)))))
(skip-chars-forward " \t" (line-end-position))))
(defun py--end-of-comment-intern (pos)
(while (and (not (eobp))
(forward-comment 99999)))
;; forward-comment fails sometimes
(and (eq pos (point)) (prog1 (forward-line 1) (back-to-indentation))
(while (member (char-after) (list comment-start 10))(forward-line 1)(back-to-indentation))))
(defun py--skip-to-comment-or-semicolon (done)
"Returns position if comment or semicolon found. "
(let ((orig (point)))
(cond ((and done (< 0 (abs (skip-chars-forward "^#;" (line-end-position))))
(member (char-after) (list ?# ?\;)))
(when (eq ?\; (char-after))
(skip-chars-forward ";" (line-end-position))))
((and (< 0 (abs (skip-chars-forward "^#;" (line-end-position))))
(member (char-after) (list ?# ?\;)))
(when (eq ?\; (char-after))
(skip-chars-forward ";" (line-end-position))))
((not done)
(end-of-line)))
(skip-chars-backward " \t" (line-beginning-position))
(and (< orig (point))(setq done t)
done)))
(defun py-backward-top-level ()
"Go up to beginning of statments until level of indentation is null.
Returns position if successful, nil otherwise "
(interactive)
(let (erg)
(unless (bobp)
(while (and (not (bobp))
(setq erg (re-search-backward "^[[:alpha:]_'\"]" nil t 1))
(nth 8 (parse-partial-sexp (point-min) (point)))
(setq erg nil)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg)))
(defun py-forward-top-level ()
"Go to end of top-level form at point.
Returns position if successful, nil otherwise"
(interactive)
(let ((orig (point))
erg)
(unless (eobp)
(unless (py--beginning-of-statement-p)
(py-backward-statement))
(unless (eq 0 (current-column))
(py-backward-top-level))
(cond ((looking-at py-def-re)
(setq erg (py-forward-def)))
((looking-at py-class-re)
(setq erg (py-forward-class)))
((looking-at py-block-re)
(setq erg (py-forward-block)))
(t (setq erg (py-forward-statement))))
(unless (< orig (point))
(while (and (not (eobp)) (py-down-statement)(< 0 (current-indentation))))
(if (looking-at py-block-re)
(setq erg (py-forward-block))
(setq erg (py-forward-statement))))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg)))
(defun py-down-top-level ()
"Go to beginning of next top-level form downward.
Returns position if successful, nil otherwise"
(interactive)
(let ((orig (point))
erg)
(while (and (not (eobp))
(progn (end-of-line)
(re-search-forward "^[[:alpha:]_'\"]" nil 'move 1))
(nth 8 (parse-partial-sexp (point-min) (point)))))
(when (and (not (eobp)) (< orig (point)))
(goto-char (match-beginning 0))
(setq erg (point)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-forward-top-level-bol ()
"Go to end of top-level form at point, stop at next beginning-of-line.
Returns position successful, nil otherwise"
(interactive)
(let (erg)
(py-forward-top-level)
(unless (or (eobp) (bolp))
(forward-line 1)
(beginning-of-line)
(setq erg (point)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py-down (&optional indent)
"Go to beginning one level below of compound statement or definition at point.
If no statement or block below, but a delimited form --string or list-- go to its beginning. Repeated call from there will behave like down-list.
Returns position if successful, nil otherwise"
(interactive "P")
(let* ((orig (point))
erg
(indent (if
(py--beginning-of-statement-p)
(current-indentation)
(progn
(py-backward-statement)
(current-indentation))))
last)
(while (and (setq last (point)) (py-forward-statement) (py-forward-statement) (py-backward-statement) (eq (current-indentation) indent)))
(if (< indent (current-indentation))
(setq erg (point))
(goto-char last))
(when (< (point) orig)
(goto-char orig))
(when (and (eq (point) orig)
(progn (forward-char 1)
(skip-chars-forward "^\"'[({" (line-end-position))
(member (char-after) (list ?\( ?\" ?\' ?\[ ?\{)))
(setq erg (point))))
(unless erg
(goto-char orig))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
(defun py--beginning-of-line-form (erg)
"Internal use: Go to beginning of line following end of form. "
(when erg
(unless (eobp)
(forward-line 1)
(beginning-of-line)
(setq erg (point)))))
(defun py--mark-base (form &optional mark-decorators)
"Returns boundaries of FORM, a cons.
If PY-MARK-DECORATORS, `def'- and `class'-forms include decorators
If BOL is t, mark from beginning-of-line"
(let* ((begform (intern-soft (concat "py-backward-" form)))
(endform (intern-soft (concat "py-forward-" form)))
(begcheckform (intern-soft (concat "py--beginning-of-" form "-p")))
(orig (point))
beg end erg)
(setq beg (if
(setq beg (funcall begcheckform))
beg
(funcall begform)))
(and mark-decorators
(and (setq erg (py-backward-decorator))
(setq beg erg)))
(push-mark)
(setq end (funcall endform))
(unless end (when (< beg (point))
(setq end (point))))
(if (and beg end (<= beg orig) (<= orig end))
(cons beg end)
nil)))
(defun py--mark-base-bol (form &optional py-mark-decorators)
(let* ((begform (intern-soft (concat "py-backward-" form "-bol")))
(endform (intern-soft (concat "py-forward-" form "-bol")))
(begcheckform (intern-soft (concat "py--beginning-of-" form "-bol-p")))
beg end erg)
(setq beg (if
(setq beg (funcall begcheckform))
beg
(funcall begform)))
(when py-mark-decorators
(save-excursion
(when (setq erg (py-backward-decorator))
(setq beg erg))))
(setq end (funcall endform))
(push-mark beg t t)
(unless end (when (< beg (point))
(setq end (point))))
(cons beg end)))
(defun py-mark-base (form &optional mark-decorators)
"Calls py--mark-base, returns bounds of form, a cons. "
(let* ((bounds (py--mark-base form mark-decorators))
(beg (car bounds)))
(push-mark beg t t)
bounds))
(defun py-beginning (&optional indent)
"Go to beginning of compound statement or definition at point.
With \\[universal-argument], go to beginning one level above.
Returns position if successful, nil otherwise"
(interactive "P")
(py--beginning-of-form-intern py-extended-block-or-clause-re (called-interactively-p 'any) indent))
(defun py-end ()
"Go to end of of compound statement or definition at point.
Returns position block if successful, nil otherwise"
(interactive "P")
(let* ((orig (point))
(erg (py--end-base 'py-extended-block-or-clause-re orig)))
(when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg))
erg))
;; Buffer
(defun py-beginning-of-buffer ()
"Go to beginning-of-buffer, return position. "
(let ((erg (unless (bobp)
(goto-char (point-min)))))
erg))
(defun py-end-of-buffer ()
"Go to end-of-buffer, return position.
If already at end-of-buffer and not at EOB, go to end of next line. "
(let ((erg (unless (eobp)
(goto-char (point-max)))))
erg))
(defun py-backward-same-level ()
"Go form backward keeping indent level if possible.
If inside a delimited form --string or list-- go to its beginning.
If not at beginning of a statement or block, go to its beginning.
If at beginning of a statement or block, go to previous beginning of compound statement or definition at point.
If no further element at same level, go one level up."
(interactive)
(let ((pps (parse-partial-sexp (point-min) (point))))
(cond ((nth 8 pps) (goto-char (nth 8 pps)))
((nth 1 pps) (goto-char (nth 1 pps)))
(t (if (eq (current-column) (current-indentation))
(py--beginning-of-form-intern 'py-extended-block-or-clause-re (called-interactively-p 'any))
(back-to-indentation)
(py-backward-same-level))))))
(defun py--end-of-buffer-p ()
"Returns position, if cursor is at the end of buffer, nil otherwise. "
(when (eobp)(point)))
(defun py-sectionize-region (&optional beg end)
"Markup code in region as section.
Use current region unless optional args BEG END are delivered."
(interactive "*")
(let ((beg (or beg (region-beginning)))
(end (or (and end (copy-marker end)) (copy-marker (region-end)))))
(save-excursion
(goto-char beg)
(unless (empty-line-p) (split-line))
(beginning-of-line)
(insert py-section-start)
(goto-char end)
(unless (empty-line-p) (newline))
(insert py-section-end))))
(defun py-execute-section-prepare (&optional shell)
"Execute section at point. "
(save-excursion
(let ((start (when (or (py--beginning-of-section-p)
(py-backward-section))
(forward-line 1)
(beginning-of-line)
(point))))
(if (and start (py-forward-section))
(progn
(beginning-of-line)
(skip-chars-backward " \t\r\n\f")
(if shell
(funcall (car (read-from-string (concat "py-execute-region-" shell))) start (point))
(py-execute-region start (point))))
(error "Can't see `py-section-start' resp. `py-section-end'")))))
(defun py--narrow-prepare (name)
"Used internally. "
(save-excursion
(let ((start (cond ((string= name "statement")
(if (py--beginning-of-statement-p)
(point)
(py-backward-statement-bol)))
((funcall (car (read-from-string (concat "py--statement-opens-" name "-p")))))
(t (funcall (car (read-from-string (concat "py-backward-" name "-bol"))))))))
(funcall (car (read-from-string (concat "py-forward-" name))))
(narrow-to-region (point) start))))
(defun py--forms-report-result (erg &optional iact)
(let ((res (ignore-errors (buffer-substring-no-properties (car-safe erg) (cdr-safe erg)))))
(when (and res iact)
(goto-char (car-safe erg))
(set-mark (point))
(goto-char (cdr-safe erg)))
res))
(defun py-rotate-shell-fontify-style (msg)
"Rotates between possible values 'all, 'input and nil. "
(interactive "p")
(cond ((eq py-shell-fontify-style 'all)
(setq py-shell-fontify-style nil))
((eq py-shell-fontify-style 'input)
(setq py-shell-fontify-style 'all))
(t (setq py-shell-fontify-style 'input)))
(py--shell-setup-fontification py-shell-fontify-style)
(when msg (message "py-shell-fontify-style set to: %s" py-shell-fontify-style)))
(defun py-toggle-execute-use-temp-file ()
(interactive)
(setq py--execute-use-temp-file-p (not py--execute-use-temp-file-p)))
(defun py--close-intern (regexp)
"Core function, internal used only. "
(let ((cui (car (py--go-to-keyword (symbol-value regexp)))))
(message "%s" cui)
(py--end-base regexp (point))
(forward-line 1)
(if py-close-provides-newline
(unless (empty-line-p) (split-line))
(fixup-whitespace))
(indent-to-column cui)
cui))
;; /usr/lib/python2.7/pdb.py eyp.py
(defalias 'IPython 'ipython)
(defalias 'Ipython 'ipython)
(defalias 'Python 'python)
(defalias 'Python2 'python2)
(defalias 'Python3 'python3)
(defalias 'ipy 'ipython)
(defalias 'iyp 'ipython)
(defalias 'py-execute-region-default 'py-execute-region)
(defalias 'py-execute-region-default-dedicated 'py-execute-region-dedicated)
(defalias 'py-fast-send-string 'py-execute-string-fast)
(defalias 'py-kill-minor-expression 'py-kill-partial-expression)
(defalias 'pyhotn 'python)
(defalias 'pyhton 'python)
(defalias 'pyt 'python)
;; python-components-shell-menu
(and (ignore-errors (require 'easymenu) t)
;; (easy-menu-define py-menu map "Python Tools"
;; `("PyTools"
(easy-menu-define
py-shell-menu py-python-shell-mode-map "Py-Shell Mode menu"
`("Py-Shell"
("Edit"
("Shift"
("Shift right"
["Shift block right" py-shift-block-right
:help " `py-shift-block-right'
Indent block by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift block or clause right" py-shift-block-or-clause-right
:help " `py-shift-block-or-clause-right'
Indent block-or-clause by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift class right" py-shift-class-right
:help " `py-shift-class-right'
Indent class by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift clause right" py-shift-clause-right
:help " `py-shift-clause-right'
Indent clause by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift comment right" py-shift-comment-right
:help " `py-shift-comment-right'"]
["Shift def right" py-shift-def-right
:help " `py-shift-def-right'
Indent def by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift def or class right" py-shift-def-or-class-right
:help " `py-shift-def-or-class-right'
Indent def-or-class by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift minor block right" py-shift-minor-block-right
:help " `py-shift-minor-block-right'
Indent minor-block by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
A minor block is started by a `for', `if', `try' or `with'."]
["Shift paragraph right" py-shift-paragraph-right
:help " `py-shift-paragraph-right'
Indent paragraph by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift region right" py-shift-region-right
:help " `py-shift-region-right'
Indent region according to `py-indent-offset' by COUNT times.
If no region is active, current line is indented.
Returns indentation reached."]
["Shift statement right" py-shift-statement-right
:help " `py-shift-statement-right'
Indent statement by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift top level right" py-shift-top-level-right
:help " `py-shift-top-level-right'"]
)
("Shift left"
["Shift block left" py-shift-block-left
:help " `py-shift-block-left'
Dedent block by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift block or clause left" py-shift-block-or-clause-left
:help " `py-shift-block-or-clause-left'
Dedent block-or-clause by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift class left" py-shift-class-left
:help " `py-shift-class-left'
Dedent class by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift clause left" py-shift-clause-left
:help " `py-shift-clause-left'
Dedent clause by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift comment left" py-shift-comment-left
:help " `py-shift-comment-left'"]
["Shift def left" py-shift-def-left
:help " `py-shift-def-left'
Dedent def by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift def or class left" py-shift-def-or-class-left
:help " `py-shift-def-or-class-left'
Dedent def-or-class by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift minor block left" py-shift-minor-block-left
:help " `py-shift-minor-block-left'
Dedent minor-block by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
A minor block is started by a `for', `if', `try' or `with'."]
["Shift paragraph left" py-shift-paragraph-left
:help " `py-shift-paragraph-left'
Dedent paragraph by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
["Shift region left" py-shift-region-left
:help " `py-shift-region-left'
Dedent region according to `py-indent-offset' by COUNT times.
If no region is active, current line is dedented.
Returns indentation reached."]
["Shift statement left" py-shift-statement-left
:help " `py-shift-statement-left'
Dedent statement by COUNT spaces.
COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.
Returns outmost indentation reached."]
))
("Mark"
["Mark block" py-mark-block
:help " `py-mark-block'
Mark block at point.
Returns beginning and end positions of marked area, a cons."]
["Mark block or clause" py-mark-block-or-clause
:help " `py-mark-block-or-clause'
Mark block-or-clause at point.
Returns beginning and end positions of marked area, a cons."]
["Mark class" py-mark-class
:help " `py-mark-class'
Mark class at point.
With C-u or `py-mark-decorators' set to `t', decorators are marked too.
Returns beginning and end positions of marked area, a cons."]
["Mark clause" py-mark-clause
:help " `py-mark-clause'
Mark clause at point.
Returns beginning and end positions of marked area, a cons."]
["Mark comment" py-mark-comment
:help " `py-mark-comment'
Mark comment at point.
Returns beginning and end positions of marked area, a cons."]
["Mark def" py-mark-def
:help " `py-mark-def'
Mark def at point.
With C-u or `py-mark-decorators' set to `t', decorators are marked too.
Returns beginning and end positions of marked area, a cons."]
["Mark def or class" py-mark-def-or-class
:help " `py-mark-def-or-class'
Mark def-or-class at point.
With C-u or `py-mark-decorators' set to `t', decorators are marked too.
Returns beginning and end positions of marked area, a cons."]
["Mark expression" py-mark-expression
:help " `py-mark-expression'
Mark expression at point.
Returns beginning and end positions of marked area, a cons."]
["Mark line" py-mark-line
:help " `py-mark-line'
Mark line at point.
Returns beginning and end positions of marked area, a cons."]
["Mark minor block" py-mark-minor-block
:help " `py-mark-minor-block'
Mark minor-block at point.
Returns beginning and end positions of marked area, a cons."]
["Mark paragraph" py-mark-paragraph
:help " `py-mark-paragraph'
Mark paragraph at point.
Returns beginning and end positions of marked area, a cons."]
["Mark partial expression" py-mark-partial-expression
:help " `py-mark-partial-expression'
Mark partial-expression at point.
Returns beginning and end positions of marked area, a cons."]
["Mark statement" py-mark-statement
:help " `py-mark-statement'
Mark statement at point.
Returns beginning and end positions of marked area, a cons."]
["Mark top level" py-mark-top-level
:help " `py-mark-top-level'
Mark top-level at point.
Returns beginning and end positions of marked area, a cons."]
)
("Copy"
["Copy block" py-copy-block
:help " `py-copy-block'
Copy block at point.
Store data in kill ring, so it might yanked back."]
["Copy block or clause" py-copy-block-or-clause
:help " `py-copy-block-or-clause'
Copy block-or-clause at point.
Store data in kill ring, so it might yanked back."]
["Copy class" py-copy-class
:help " `py-copy-class'
Copy class at point.
Store data in kill ring, so it might yanked back."]
["Copy clause" py-copy-clause
:help " `py-copy-clause'
Copy clause at point.
Store data in kill ring, so it might yanked back."]
["Copy comment" py-copy-comment
:help " `py-copy-comment'"]
["Copy def" py-copy-def
:help " `py-copy-def'
Copy def at point.
Store data in kill ring, so it might yanked back."]
["Copy def or class" py-copy-def-or-class
:help " `py-copy-def-or-class'
Copy def-or-class at point.
Store data in kill ring, so it might yanked back."]
["Copy expression" py-copy-expression
:help " `py-copy-expression'
Copy expression at point.
Store data in kill ring, so it might yanked back."]
["Copy line" py-copy-line
:help " `py-copy-line'"]
["Copy minor block" py-copy-minor-block
:help " `py-copy-minor-block'
Copy minor-block at point.
Store data in kill ring, so it might yanked back."]
["Copy paragraph" py-copy-paragraph
:help " `py-copy-paragraph'"]
["Copy partial expression" py-copy-partial-expression
:help " `py-copy-partial-expression'
Copy partial-expression at point.
Store data in kill ring, so it might yanked back."]
["Copy statement" py-copy-statement
:help " `py-copy-statement'
Copy statement at point.
Store data in kill ring, so it might yanked back."]
["Copy top level" py-copy-top-level
:help " `py-copy-top-level'
Copy top-level at point.
Store data in kill ring, so it might yanked back."]
)
("Kill"
["Kill block" py-kill-block
:help " `py-kill-block'
Delete `block' at point.
Stores data in kill ring"]
["Kill block or clause" py-kill-block-or-clause
:help " `py-kill-block-or-clause'
Delete `block-or-clause' at point.
Stores data in kill ring"]
["Kill class" py-kill-class
:help " `py-kill-class'
Delete `class' at point.
Stores data in kill ring"]
["Kill clause" py-kill-clause
:help " `py-kill-clause'
Delete `clause' at point.
Stores data in kill ring"]
["Kill comment" py-kill-comment
:help " `py-kill-comment'"]
["Kill def" py-kill-def
:help " `py-kill-def'
Delete `def' at point.
Stores data in kill ring"]
["Kill def or class" py-kill-def-or-class
:help " `py-kill-def-or-class'
Delete `def-or-class' at point.
Stores data in kill ring"]
["Kill expression" py-kill-expression
:help " `py-kill-expression'
Delete `expression' at point.
Stores data in kill ring"]
["Kill line" py-kill-line
:help " `py-kill-line'"]
["Kill minor block" py-kill-minor-block
:help " `py-kill-minor-block'
Delete `minor-block' at point.
Stores data in kill ring"]
["Kill paragraph" py-kill-paragraph
:help " `py-kill-paragraph'"]
["Kill partial expression" py-kill-partial-expression
:help " `py-kill-partial-expression'
Delete `partial-expression' at point.
Stores data in kill ring"]
["Kill statement" py-kill-statement
:help " `py-kill-statement'
Delete `statement' at point.
Stores data in kill ring"]
["Kill top level" py-kill-top-level
:help " `py-kill-top-level'
Delete `top-level' at point.
Stores data in kill ring"]
)
("Delete"
["Delete block" py-delete-block
:help " `py-delete-block'
Delete BLOCK at point.
Don't store data in kill ring."]
["Delete block or clause" py-delete-block-or-clause
:help " `py-delete-block-or-clause'
Delete BLOCK-OR-CLAUSE at point.
Don't store data in kill ring."]
["Delete class" py-delete-class
:help " `py-delete-class'
Delete CLASS at point.
Don't store data in kill ring.
With C-u or `py-mark-decorators' set to `t', `decorators' are included."]
["Delete clause" py-delete-clause
:help " `py-delete-clause'
Delete CLAUSE at point.
Don't store data in kill ring."]
["Delete comment" py-delete-comment
:help " `py-delete-comment'"]
["Delete def" py-delete-def
:help " `py-delete-def'
Delete DEF at point.
Don't store data in kill ring.
With C-u or `py-mark-decorators' set to `t', `decorators' are included."]
["Delete def or class" py-delete-def-or-class
:help " `py-delete-def-or-class'
Delete DEF-OR-CLASS at point.
Don't store data in kill ring.
With C-u or `py-mark-decorators' set to `t', `decorators' are included."]
["Delete expression" py-delete-expression
:help " `py-delete-expression'
Delete EXPRESSION at point.
Don't store data in kill ring."]
["Delete line" py-delete-line
:help " `py-delete-line'"]
["Delete minor block" py-delete-minor-block
:help " `py-delete-minor-block'
Delete MINOR-BLOCK at point.
Don't store data in kill ring."]
["Delete paragraph" py-delete-paragraph
:help " `py-delete-paragraph'"]
["Delete partial expression" py-delete-partial-expression
:help " `py-delete-partial-expression'
Delete PARTIAL-EXPRESSION at point.
Don't store data in kill ring."]
["Delete statement" py-delete-statement
:help " `py-delete-statement'
Delete STATEMENT at point.
Don't store data in kill ring."]
["Delete top level" py-delete-top-level
:help " `py-delete-top-level'
Delete TOP-LEVEL at point.
Don't store data in kill ring."]
)
("Comment"
["Comment block" py-comment-block
:help " `py-comment-block'
Comments block at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"]
["Comment block or clause" py-comment-block-or-clause
:help " `py-comment-block-or-clause'
Comments block-or-clause at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"]
["Comment class" py-comment-class
:help " `py-comment-class'
Comments class at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"]
["Comment clause" py-comment-clause
:help " `py-comment-clause'
Comments clause at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"]
["Comment def" py-comment-def
:help " `py-comment-def'
Comments def at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"]
["Comment def or class" py-comment-def-or-class
:help " `py-comment-def-or-class'
Comments def-or-class at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"]
["Comment statement" py-comment-statement
:help " `py-comment-statement'
Comments statement at point.
Uses double hash (`#') comment starter when `py-block-comment-prefix-p' is `t',
the default"]
))
("Move"
("Backward"
["Beginning of block" py-beginning-of-block
:help " `py-beginning-of-block'
Go to beginning block, skip whitespace at BOL.
Returns beginning of block if successful, nil otherwise"]
["Beginning of block or clause" py-beginning-of-block-or-clause
:help " `py-beginning-of-block-or-clause'
Go to beginning block-or-clause, skip whitespace at BOL.
Returns beginning of block-or-clause if successful, nil otherwise"]
["Beginning of class" py-beginning-of-class
:help " `py-beginning-of-class'
Go to beginning class, skip whitespace at BOL.
Returns beginning of class if successful, nil otherwise
When `py-mark-decorators' is non-nil, decorators are considered too."]
["Beginning of clause" py-beginning-of-clause
:help " `py-beginning-of-clause'
Go to beginning clause, skip whitespace at BOL.
Returns beginning of clause if successful, nil otherwise"]
["Beginning of def" py-beginning-of-def
:help " `py-beginning-of-def'
Go to beginning def, skip whitespace at BOL.
Returns beginning of def if successful, nil otherwise
When `py-mark-decorators' is non-nil, decorators are considered too."]
["Beginning of def or class" py-beginning-of-def-or-class
:help " `py-beginning-of-def-or-class'
Go to beginning def-or-class, skip whitespace at BOL.
Returns beginning of def-or-class if successful, nil otherwise
When `py-mark-decorators' is non-nil, decorators are considered too."]
["Beginning of elif block" py-beginning-of-elif-block
:help " `py-beginning-of-elif-block'
Go to beginning elif-block, skip whitespace at BOL.
Returns beginning of elif-block if successful, nil otherwise"]
["Beginning of else block" py-beginning-of-else-block
:help " `py-beginning-of-else-block'
Go to beginning else-block, skip whitespace at BOL.
Returns beginning of else-block if successful, nil otherwise"]
["Beginning of except block" py-beginning-of-except-block
:help " `py-beginning-of-except-block'
Go to beginning except-block, skip whitespace at BOL.
Returns beginning of except-block if successful, nil otherwise"]
["Beginning of expression" py-beginning-of-expression
:help " `py-beginning-of-expression'
Go to the beginning of a compound python expression.
With numeric ARG do it that many times.
A a compound python expression might be concatenated by \".\" operator, thus composed by minor python expressions.
If already at the beginning or before a expression, go to next expression in buffer upwards
Expression here is conceived as the syntactical component of a statement in Python. See http://docs.python.org/reference
Operators however are left aside resp. limit py-expression designed for edit-purposes."]
["Beginning of if block" py-beginning-of-if-block
:help " `py-beginning-of-if-block'
Go to beginning if-block, skip whitespace at BOL.
Returns beginning of if-block if successful, nil otherwise"]
["Beginning of partial expression" py-beginning-of-partial-expression
:help " `py-beginning-of-partial-expression'"]
["Beginning of statement" py-beginning-of-statement
:help " `py-beginning-of-statement'
Go to the initial line of a simple statement.
For beginning of compound statement use py-beginning-of-block.
For beginning of clause py-beginning-of-clause."]
["Beginning of top level" py-beginning-of-top-level
:help " `py-beginning-of-top-level'
Go up to beginning of statments until level of indentation is null.
Returns position if successful, nil otherwise"]
["Beginning of try block" py-beginning-of-try-block
:help " `py-beginning-of-try-block'
Go to beginning try-block, skip whitespace at BOL.
Returns beginning of try-block if successful, nil otherwise"]
)
("Forward"
["End of block" py-end-of-block
:help " `py-end-of-block'
Go to end of block.
Returns end of block if successful, nil otherwise"]
["End of block or clause" py-end-of-block-or-clause
:help " `py-end-of-block-or-clause'
Go to end of block-or-clause.
Returns end of block-or-clause if successful, nil otherwise"]
["End of class" py-end-of-class
:help " `py-end-of-class'
Go to end of class.
Returns end of class if successful, nil otherwise"]
["End of clause" py-end-of-clause
:help " `py-end-of-clause'
Go to end of clause.
Returns end of clause if successful, nil otherwise"]
["End of def" py-end-of-def
:help " `py-end-of-def'
Go to end of def.
Returns end of def if successful, nil otherwise"]
["End of def or class" py-end-of-def-or-class
:help " `py-end-of-def-or-class'
Go to end of def-or-class.
Returns end of def-or-class if successful, nil otherwise"]
["End of elif block" py-end-of-elif-block
:help " `py-end-of-elif-block'
Go to end of elif-block.
Returns end of elif-block if successful, nil otherwise"]
["End of else block" py-end-of-else-block
:help " `py-end-of-else-block'
Go to end of else-block.
Returns end of else-block if successful, nil otherwise"]
["End of except block" py-end-of-except-block
:help " `py-end-of-except-block'
Go to end of except-block.
Returns end of except-block if successful, nil otherwise"]
["End of expression" py-end-of-expression
:help " `py-end-of-expression'
Go to the end of a compound python expression.
With numeric ARG do it that many times.
A a compound python expression might be concatenated by \".\" operator, thus composed by minor python expressions.
Expression here is conceived as the syntactical component of a statement in Python. See http://docs.python.org/reference
Operators however are left aside resp. limit py-expression designed for edit-purposes."]
["End of if block" py-end-of-if-block
:help " `py-end-of-if-block'
Go to end of if-block.
Returns end of if-block if successful, nil otherwise"]
["End of partial expression" py-end-of-partial-expression
:help " `py-end-of-partial-expression'"]
["End of statement" py-end-of-statement
:help " `py-end-of-statement'
Go to the last char of current statement.
Optional argument REPEAT, the number of loops done already, is checked for py-max-specpdl-size error. Avoid eternal loops due to missing string delimters etc."]
["End of top level" py-end-of-top-level
:help " `py-end-of-top-level'
Go to end of top-level form at point.
Returns position if successful, nil otherwise"]
["End of try block" py-end-of-try-block
:help " `py-end-of-try-block'
Go to end of try-block.
Returns end of try-block if successful, nil otherwise"]
)
("BOL-forms"
("Backward"
["Beginning of block bol" py-beginning-of-block-bol
:help " `py-beginning-of-block-bol'
Go to beginning block, go to BOL.
Returns beginning of block if successful, nil otherwise"]
["Beginning of block or clause bol" py-beginning-of-block-or-clause-bol
:help " `py-beginning-of-block-or-clause-bol'
Go to beginning block-or-clause, go to BOL.
Returns beginning of block-or-clause if successful, nil otherwise"]
["Beginning of class bol" py-beginning-of-class-bol
:help " `py-beginning-of-class-bol'
Go to beginning class, go to BOL.
Returns beginning of class if successful, nil otherwise
When `py-mark-decorators' is non-nil, decorators are considered too."]
["Beginning of clause bol" py-beginning-of-clause-bol
:help " `py-beginning-of-clause-bol'
Go to beginning clause, go to BOL.
Returns beginning of clause if successful, nil otherwise"]
["Beginning of def bol" py-beginning-of-def-bol
:help " `py-beginning-of-def-bol'
Go to beginning def, go to BOL.
Returns beginning of def if successful, nil otherwise
When `py-mark-decorators' is non-nil, decorators are considered too."]
["Beginning of def or class bol" py-beginning-of-def-or-class-bol
:help " `py-beginning-of-def-or-class-bol'
Go to beginning def-or-class, go to BOL.
Returns beginning of def-or-class if successful, nil otherwise
When `py-mark-decorators' is non-nil, decorators are considered too."]
["Beginning of elif block bol" py-beginning-of-elif-block-bol
:help " `py-beginning-of-elif-block-bol'
Go to beginning elif-block, go to BOL.
Returns beginning of elif-block if successful, nil otherwise"]
["Beginning of else block bol" py-beginning-of-else-block-bol
:help " `py-beginning-of-else-block-bol'
Go to beginning else-block, go to BOL.
Returns beginning of else-block if successful, nil otherwise"]
["Beginning of except block bol" py-beginning-of-except-block-bol
:help " `py-beginning-of-except-block-bol'
Go to beginning except-block, go to BOL.
Returns beginning of except-block if successful, nil otherwise"]
["Beginning of expression bol" py-beginning-of-expression-bol
:help " `py-beginning-of-expression-bol'"]
["Beginning of if block bol" py-beginning-of-if-block-bol
:help " `py-beginning-of-if-block-bol'
Go to beginning if-block, go to BOL.
Returns beginning of if-block if successful, nil otherwise"]
["Beginning of partial expression bol" py-beginning-of-partial-expression-bol
:help " `py-beginning-of-partial-expression-bol'"]
["Beginning of statement bol" py-beginning-of-statement-bol
:help " `py-beginning-of-statement-bol'
Goto beginning of line where statement starts.
Returns position reached, if successful, nil otherwise.
See also `py-up-statement': up from current definition to next beginning of statement above."]
["Beginning of try block bol" py-beginning-of-try-block-bol
:help " `py-beginning-of-try-block-bol'
Go to beginning try-block, go to BOL.
Returns beginning of try-block if successful, nil otherwise"]
)
("Forward"
["End of block bol" py-end-of-block-bol
:help " `py-end-of-block-bol'
Goto beginning of line following end of block.
Returns position reached, if successful, nil otherwise.
See also `py-down-block': down from current definition to next beginning of block below."]
["End of block or clause bol" py-end-of-block-or-clause-bol
:help " `py-end-of-block-or-clause-bol'
Goto beginning of line following end of block-or-clause.
Returns position reached, if successful, nil otherwise.
See also `py-down-block-or-clause': down from current definition to next beginning of block-or-clause below."]
["End of class bol" py-end-of-class-bol
:help " `py-end-of-class-bol'
Goto beginning of line following end of class.
Returns position reached, if successful, nil otherwise.
See also `py-down-class': down from current definition to next beginning of class below."]
["End of clause bol" py-end-of-clause-bol
:help " `py-end-of-clause-bol'
Goto beginning of line following end of clause.
Returns position reached, if successful, nil otherwise.
See also `py-down-clause': down from current definition to next beginning of clause below."]
["End of def bol" py-end-of-def-bol
:help " `py-end-of-def-bol'
Goto beginning of line following end of def.
Returns position reached, if successful, nil otherwise.
See also `py-down-def': down from current definition to next beginning of def below."]
["End of def or class bol" py-end-of-def-or-class-bol
:help " `py-end-of-def-or-class-bol'
Goto beginning of line following end of def-or-class.
Returns position reached, if successful, nil otherwise.
See also `py-down-def-or-class': down from current definition to next beginning of def-or-class below."]
["End of elif block bol" py-end-of-elif-block-bol
:help " `py-end-of-elif-block-bol'
Goto beginning of line following end of elif-block.
Returns position reached, if successful, nil otherwise.
See also `py-down-elif-block': down from current definition to next beginning of elif-block below."]
["End of else block bol" py-end-of-else-block-bol
:help " `py-end-of-else-block-bol'
Goto beginning of line following end of else-block.
Returns position reached, if successful, nil otherwise.
See also `py-down-else-block': down from current definition to next beginning of else-block below."]
["End of except block bol" py-end-of-except-block-bol
:help " `py-end-of-except-block-bol'
Goto beginning of line following end of except-block.
Returns position reached, if successful, nil otherwise.
See also `py-down-except-block': down from current definition to next beginning of except-block below."]
["End of expression bol" py-end-of-expression-bol
:help " `py-end-of-expression-bol'"]
["End of if block bol" py-end-of-if-block-bol
:help " `py-end-of-if-block-bol'
Goto beginning of line following end of if-block.
Returns position reached, if successful, nil otherwise.
See also `py-down-if-block': down from current definition to next beginning of if-block below."]
["End of partial expression bol" py-end-of-partial-expression-bol
:help " `py-end-of-partial-expression-bol'"]
["End of statement bol" py-end-of-statement-bol
:help " `py-end-of-statement-bol'
Go to the beginning-of-line following current statement."]
["End of top level bol" py-end-of-top-level-bol
:help " `py-end-of-top-level-bol'
Go to end of top-level form at point, stop at next beginning-of-line.
Returns position successful, nil otherwise"]
["End of try block bol" py-end-of-try-block-bol
:help " `py-end-of-try-block-bol'
Goto beginning of line following end of try-block.
Returns position reached, if successful, nil otherwise.
See also `py-down-try-block': down from current definition to next beginning of try-block below."]
))
("Up/Down"
["Up" py-up
:help " `py-up'
Go up or to beginning of form if inside.
If inside a delimited form --string or list-- go to its beginning.
If not at beginning of a statement or block, go to its beginning.
If at beginning of a statement or block, go to beginning one level above of compound statement or definition at point."]
["Down" py-down
:help " `py-down'
Go to beginning one level below of compound statement or definition at point.
If no statement or block below, but a delimited form --string or list-- go to its beginning. Repeated call from there will behave like down-list.
Returns position if successful, nil otherwise"]
))
("Hide-Show"
("Hide"
["Hide region" py-hide-region
:help " `py-hide-region'
Hide active region."]
["Hide statement" py-hide-statement
:help " `py-hide-statement'
Hide statement at point."]
["Hide block" py-hide-block
:help " `py-hide-block'
Hide block at point."]
["Hide clause" py-hide-clause
:help " `py-hide-clause'
Hide clause at point."]
["Hide block or clause" py-hide-block-or-clause
:help " `py-hide-block-or-clause'
Hide block-or-clause at point."]
["Hide def" py-hide-def
:help " `py-hide-def'
Hide def at point."]
["Hide class" py-hide-class
:help " `py-hide-class'
Hide class at point."]
["Hide expression" py-hide-expression
:help " `py-hide-expression'
Hide expression at point."]
["Hide partial expression" py-hide-partial-expression
:help " `py-hide-partial-expression'
Hide partial-expression at point."]
["Hide line" py-hide-line
:help " `py-hide-line'
Hide line at point."]
["Hide top level" py-hide-top-level
:help " `py-hide-top-level'
Hide top-level at point."]
)
("Show"
["Show region" py-show-region
:help " `py-show-region'
Un-hide active region."]
["Show statement" py-show-statement
:help " `py-show-statement'
Show statement at point."]
["Show block" py-show-block
:help " `py-show-block'
Show block at point."]
["Show clause" py-show-clause
:help " `py-show-clause'
Show clause at point."]
["Show block or clause" py-show-block-or-clause
:help " `py-show-block-or-clause'
Show block-or-clause at point."]
["Show def" py-show-def
:help " `py-show-def'
Show def at point."]
["Show class" py-show-class
:help " `py-show-class'
Show class at point."]
["Show expression" py-show-expression
:help " `py-show-expression'
Show expression at point."]
["Show partial expression" py-show-partial-expression
:help " `py-show-partial-expression'
Show partial-expression at point."]
["Show line" py-show-line
:help " `py-show-line'
Show line at point."]
["Show top level" py-show-top-level
:help " `py-show-top-level'
Show top-level at point."]
))
("Virtualenv"
["Virtualenv activate" virtualenv-activate
:help " `virtualenv-activate'
Activate the virtualenv located in DIR"]
["Virtualenv deactivate" virtualenv-deactivate
:help " `virtualenv-deactivate'
Deactivate the current virtual enviroment"]
["Virtualenv p" virtualenv-p
:help " `virtualenv-p'
Check if a directory is a virtualenv"]
["Virtualenv workon" virtualenv-workon
:help " `virtualenv-workon'
Issue a virtualenvwrapper-like virtualenv-workon command"]
)
("Help"
["Find definition" py-find-definition
:help " `py-find-definition'
Find source of definition of SYMBOL.
Interactively, prompt for SYMBOL."]
["Help at point" py-help-at-point
:help " `py-help-at-point'
Print help on symbol at point.
If symbol is defined in current buffer, jump to it's definition
Optional C-u used for debugging, will prevent deletion of temp file."]
["Info lookup symbol" py-info-lookup-symbol
:help " `py-info-lookup-symbol'"]
["Symbol at point" py-symbol-at-point
:help " `py-symbol-at-point'
Return the current Python symbol."]
)
("Customize"
["Python-mode customize group" (customize-group 'python-mode)
:help "Open the customization buffer for Python mode"]
("Switches"
:help "Toggle useful modes like `highlight-indentation'"
("Interpreter"
["Shell prompt read only"
(setq py-shell-prompt-read-only
(not py-shell-prompt-read-only))
:help "If non-nil, the python prompt is read only. Setting this variable will only effect new shells.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-shell-prompt-read-only]
["Remove cwd from path"
(setq py-remove-cwd-from-path
(not py-remove-cwd-from-path))
:help "Whether to allow loading of Python modules from the current directory.
If this is non-nil, Emacs removes '' from sys.path when starting
a Python process. This is the default, for security
reasons, as it is easy for the Python process to be started
without the user's realization (e.g. to perform completion).Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-remove-cwd-from-path]
["Honor IPYTHONDIR "
(setq py-honor-IPYTHONDIR-p
(not py-honor-IPYTHONDIR-p))
:help "When non-nil ipython-history file is constructed by \$IPYTHONDIR
followed by "/history". Default is nil.
Otherwise value of py-ipython-history is used. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-honor-IPYTHONDIR-p]
["Honor PYTHONHISTORY "
(setq py-honor-PYTHONHISTORY-p
(not py-honor-PYTHONHISTORY-p))
:help "When non-nil python-history file is set by \$PYTHONHISTORY
Default is nil.
Otherwise value of py-python-history is used. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-honor-PYTHONHISTORY-p]
["Enforce py-shell-name" force-py-shell-name-p-on
:help "Enforce customized default `py-shell-name' should upon execution. "]
["Don't enforce default interpreter" force-py-shell-name-p-off
:help "Make execute commands guess interpreter from environment"]
["Enforce local Python shell " py-force-local-shell-on
:help "Locally indicated Python being enforced upon sessions execute commands. "]
["Remove local Python shell enforcement, restore default" py-force-local-shell-off
:help "Restore `py-shell-name' default value and `behaviour'. "])
("Execute"
["Fast process" py-fast-process-p
:help " `py-fast-process-p'
Use `py-fast-process'\.
Commands prefixed \"py-fast-...\" suitable for large output
See: large output makes Emacs freeze, lp:1253907
Output-buffer is not in comint-mode"
:style toggle :selected py-fast-process-p]
["Python mode v5 behavior"
(setq python-mode-v5-behavior-p
(not python-mode-v5-behavior-p))
:help "Execute region through `shell-command-on-region' as
v5 did it - lp:990079. This might fail with certain chars - see UnicodeEncodeError lp:550661
Use `M-x customize-variable' to set it permanently"
:style toggle :selected python-mode-v5-behavior-p]
["Force shell name "
(setq py-force-py-shell-name-p
(not py-force-py-shell-name-p))
:help "When `t', execution with kind of Python specified in `py-shell-name' is enforced, possibly shebang doesn't take precedence. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-force-py-shell-name-p]
["Execute \"if name == main\" blocks p"
(setq py-if-name-main-permission-p
(not py-if-name-main-permission-p))
:help " `py-if-name-main-permission-p'
Allow execution of code inside blocks delimited by
if __name__ == '__main__'
Default is non-nil. "
:style toggle :selected py-if-name-main-permission-p]
["Ask about save"
(setq py-ask-about-save
(not py-ask-about-save))
:help "If not nil, ask about which buffers to save before executing some code.
Otherwise, all modified buffers are saved without asking.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-ask-about-save]
["Store result"
(setq py-store-result-p
(not py-store-result-p))
:help " `py-store-result-p'
When non-nil, put resulting string of `py-execute-...' into kill-ring, so it might be yanked. "
:style toggle :selected py-store-result-p]
["Prompt on changed "
(setq py-prompt-on-changed-p
(not py-prompt-on-changed-p))
:help "When called interactively, ask for save before a changed buffer is sent to interpreter.
Default is `t'Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-prompt-on-changed-p]
["Dedicated process "
(setq py-dedicated-process-p
(not py-dedicated-process-p))
:help "If commands executing code use a dedicated shell.
Default is nilUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-dedicated-process-p]
["Execute without temporary file"
(setq py-execute-no-temp-p
(not py-execute-no-temp-p))
:help " `py-execute-no-temp-p'
Seems Emacs-24.3 provided a way executing stuff without temporary files.
In experimental state yet "
:style toggle :selected py-execute-no-temp-p]
["Warn tmp files left "
(setq py--warn-tmp-files-left-p
(not py--warn-tmp-files-left-p))
:help "Messages a warning, when `py-temp-directory' contains files susceptible being left by previous Python-mode sessions. See also lp:987534 Use `M-x customize-variable' to set it permanently"
:style toggle :selected py--warn-tmp-files-left-p])
("Edit"
("Completion"
["Set Pymacs-based complete keymap "
(setq py-set-complete-keymap-p
(not py-set-complete-keymap-p))
:help "If `py-complete-initialize', which sets up enviroment for Pymacs based py-complete, should load it's keys into `python-mode-map'
Default is nil.
See also resp. edit `py-complete-set-keymap' Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-set-complete-keymap-p]
["Indent no completion "
(setq py-indent-no-completion-p
(not py-indent-no-completion-p))
:help "If completion function should indent when no completion found. Default is `t'
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-indent-no-completion-p]
["Company pycomplete "
(setq py-company-pycomplete-p
(not py-company-pycomplete-p))
:help "Load company-pycomplete stuff. Default is nilUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-company-pycomplete-p])
("Filling"
("Docstring styles"
:help "Switch docstring-style"
["Nil" py-set-nil-docstring-style
:help " `py-set-nil-docstring-style'
Set py-docstring-style to nil, format string normally. "]
["pep-257-nn" py-set-pep-257-nn-docstring-style
:help " `py-set-pep-257-nn-docstring-style'
Set py-docstring-style to 'pep-257-nn "]
["pep-257" py-set-pep-257-docstring-style
:help " `py-set-pep-257-docstring-style'
Set py-docstring-style to 'pep-257 "]
["django" py-set-django-docstring-style
:help " `py-set-django-docstring-style'
Set py-docstring-style to 'django "]
["onetwo" py-set-onetwo-docstring-style
:help " `py-set-onetwo-docstring-style'
Set py-docstring-style to 'onetwo "]
["symmetric" py-set-symmetric-docstring-style
:help " `py-set-symmetric-docstring-style'
Set py-docstring-style to 'symmetric "])
["Auto-fill mode"
(setq py-auto-fill-mode
(not py-auto-fill-mode))
:help "Fill according to `py-docstring-fill-column' and `py-comment-fill-column'
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-auto-fill-mode])
["Use current dir when execute"
(setq py-use-current-dir-when-execute-p
(not py-use-current-dir-when-execute-p))
:help " `toggle-py-use-current-dir-when-execute-p'
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-use-current-dir-when-execute-p]
("Indent"
("TAB related"
["indent-tabs-mode"
(setq indent-tabs-mode
(not indent-tabs-mode))
:help "Indentation can insert tabs if this is non-nil.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected indent-tabs-mode]
["Tab indent"
(setq py-tab-indent
(not py-tab-indent))
:help "Non-nil means TAB in Python mode calls `py-indent-line'.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-tab-indent]
["Tab shifts region "
(setq py-tab-shifts-region-p
(not py-tab-shifts-region-p))
:help "If `t', TAB will indent/cycle the region, not just the current line.
Default is nil
See also `py-tab-indents-region-p'
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-tab-shifts-region-p]
["Tab indents region "
(setq py-tab-indents-region-p
(not py-tab-indents-region-p))
:help "When `t' and first TAB doesn't shift, indent-region is called.
Default is nil
See also `py-tab-shifts-region-p'
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-tab-indents-region-p])
["Close at start column"
(setq py-closing-list-dedents-bos
(not py-closing-list-dedents-bos))
:help "When non-nil, indent list's closing delimiter like start-column.
It will be lined up under the first character of
the line that starts the multi-line construct, as in:
my_list = \[
1, 2, 3,
4, 5, 6,
]
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-closing-list-dedents-bos]
["Closing list keeps space"
(setq py-closing-list-keeps-space
(not py-closing-list-keeps-space))
:help "If non-nil, closing parenthesis dedents onto column of opening plus `py-closing-list-space', default is nil Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-closing-list-keeps-space]
["Closing list space"
(setq py-closing-list-space
(not py-closing-list-space))
:help "Number of chars, closing parenthesis outdent from opening, default is 1 Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-closing-list-space]
["Tab shifts region "
(setq py-tab-shifts-region-p
(not py-tab-shifts-region-p))
:help "If `t', TAB will indent/cycle the region, not just the current line.
Default is nil
See also `py-tab-indents-region-p'Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-tab-shifts-region-p]
["Lhs inbound indent"
(setq py-lhs-inbound-indent
(not py-lhs-inbound-indent))
:help "When line starts a multiline-assignment: How many colums indent should be more than opening bracket, brace or parenthesis. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-lhs-inbound-indent]
["Continuation offset"
(setq py-continuation-offset
(not py-continuation-offset))
:help "With numeric ARG different from 1 py-continuation-offset is set to that value; returns py-continuation-offset. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-continuation-offset]
["Electric colon"
(setq py-electric-colon-active-p
(not py-electric-colon-active-p))
:help " `py-electric-colon-active-p'
`py-electric-colon' feature. Default is `nil'. See lp:837065 for discussions. "
:style toggle :selected py-electric-colon-active-p]
["Electric colon at beginning of block only"
(setq py-electric-colon-bobl-only
(not py-electric-colon-bobl-only))
:help "When inserting a colon, do not indent lines unless at beginning of block.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-electric-colon-bobl-only]
["Electric yank active "
(setq py-electric-yank-active-p
(not py-electric-yank-active-p))
:help " When non-nil, `yank' will be followed by an `indent-according-to-mode'.
Default is nilUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-electric-yank-active-p]
["Electric kill backward "
(setq py-electric-kill-backward-p
(not py-electric-kill-backward-p))
:help "Affects `py-electric-backspace'. Default is nil.
If behind a delimited form of braces, brackets or parentheses,
backspace will kill it's contents
With when cursor after
my_string\[0:1]
--------------^
==>
my_string\[]
----------^
In result cursor is insided emptied delimited form.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-electric-kill-backward-p]
["Trailing whitespace smart delete "
(setq py-trailing-whitespace-smart-delete-p
(not py-trailing-whitespace-smart-delete-p))
:help "Default is nil. When t, python-mode calls
(add-hook 'before-save-hook 'delete-trailing-whitespace nil 'local)
Also commands may delete trailing whitespace by the way.
When editing other peoples code, this may produce a larger diff than expected Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-trailing-whitespace-smart-delete-p]
["Newline delete trailing whitespace "
(setq py-newline-delete-trailing-whitespace-p
(not py-newline-delete-trailing-whitespace-p))
:help "Delete trailing whitespace maybe left by `py-newline-and-indent'.
Default is `t'. See lp:1100892 Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-newline-delete-trailing-whitespace-p]
["Dedent keep relative column"
(setq py-dedent-keep-relative-column
(not py-dedent-keep-relative-column))
:help "If point should follow dedent or kind of electric move to end of line. Default is t - keep relative position. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-dedent-keep-relative-column]
["Indent paren spanned multilines "
(setq py-indent-paren-spanned-multilines-p
(not py-indent-paren-spanned-multilines-p))
:help "If non-nil, indents elements of list a value of `py-indent-offset' to first element:
def foo():
if (foo &&
baz):
bar()
Default lines up with first element:
def foo():
if (foo &&
baz):
bar()
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-indent-paren-spanned-multilines-p]
["Indent honors multiline listing"
(setq py-indent-honors-multiline-listing
(not py-indent-honors-multiline-listing))
:help "If `t', indents to 1\+ column of opening delimiter. If `nil', indent adds one level to the beginning of statement. Default is `nil'. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-indent-honors-multiline-listing]
["Indent comment "
(setq py-indent-comments
(not py-indent-comments))
:help "If comments should be indented like code. Default is `nil'.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-indent-comments]
["Uncomment indents "
(setq py-uncomment-indents-p
(not py-uncomment-indents-p))
:help "When non-nil, after uncomment indent lines. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-uncomment-indents-p]
["Indent honors inline comment"
(setq py-indent-honors-inline-comment
(not py-indent-honors-inline-comment))
:help "If non-nil, indents to column of inlined comment start.
Default is nil. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-indent-honors-inline-comment]
["Kill empty line"
(setq py-kill-empty-line
(not py-kill-empty-line))
:help "If t, py-indent-forward-line kills empty lines. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-kill-empty-line]
("Smart indentation"
:help "Toggle py-smart-indentation'
Use `M-x customize-variable' to set it permanently"
["Toggle py-smart-indentation" toggle-py-smart-indentation
:help "Toggles py-smart-indentation
Use `M-x customize-variable' to set it permanently"]
["py-smart-indentation on" py-smart-indentation-on
:help "Switches py-smart-indentation on
Use `M-x customize-variable' to set it permanently"]
["py-smart-indentation off" py-smart-indentation-off
:help "Switches py-smart-indentation off
Use `M-x customize-variable' to set it permanently"])
["Beep if tab change"
(setq py-beep-if-tab-change
(not py-beep-if-tab-change))
:help "Ring the bell if `tab-width' is changed.
If a comment of the form
# vi:set tabsize=:
is found before the first code line when the file is entered, and the
current value of (the general Emacs variable) `tab-width' does not
equal , `tab-width' is set to , a message saying so is
displayed in the echo area, and if `py-beep-if-tab-change' is non-nil
the Emacs bell is also rung as a warning.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-beep-if-tab-change]
["Highlight indentation" highlight-indentation
:help "Toggle highlight indentation.
Use `M-x customize-variable' to set it permanently
Make sure `highlight-indentation' is installed"
]
["Electric comment "
(setq py-electric-comment-p
(not py-electric-comment-p))
:help "If \"#\" should call `py-electric-comment'. Default is `nil'.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-electric-comment-p]
["Electric comment add space "
(setq py-electric-comment-add-space-p
(not py-electric-comment-add-space-p))
:help "If py-electric-comment should add a space. Default is `nil'. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-electric-comment-add-space-p]
["Empty line closes "
(setq py-empty-line-closes-p
(not py-empty-line-closes-p))
:help "When non-nil, dedent after empty line following block
if True:
print(\"Part of the if-statement\")
print(\"Not part of the if-statement\")
Default is nil
If non-nil, a C-j from empty line dedents.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-empty-line-closes-p])
["Defun use top level "
(setq py-defun-use-top-level-p
(not py-defun-use-top-level-p))
:help "When non-nil, keys C-M-a, C-M-e address top-level form.
Beginning- end-of-defun forms use
commands `py-beginning-of-top-level', `py-end-of-top-level'
mark-defun marks top-level form at point etc. "
:style toggle :selected py-defun-use-top-level-p]
["Close provides newline"
(setq py-close-provides-newline
(not py-close-provides-newline))
:help "If a newline is inserted, when line after block isn't empty. Default is non-nil. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-close-provides-newline]
["Block comment prefix "
(setq py-block-comment-prefix-p
(not py-block-comment-prefix-p))
:help "If py-comment inserts py-block-comment-prefix.
Default is tUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-block-comment-prefix-p])
("Display"
("Index"
["Imenu create index "
(setq py--imenu-create-index-p
(not py--imenu-create-index-p))
:help "Non-nil means Python mode creates and displays an index menu of functions and global variables. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py--imenu-create-index-p]
["Imenu show method args "
(setq py-imenu-show-method-args-p
(not py-imenu-show-method-args-p))
:help "Controls echoing of arguments of functions & methods in the Imenu buffer.
When non-nil, arguments are printed.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-imenu-show-method-args-p]
["Switch index-function" py-switch-imenu-index-function
:help "`py-switch-imenu-index-function'
Switch between `py--imenu-create-index' from 5.1 series and `py--imenu-create-index-new'."])
("Fontification"
["Mark decorators"
(setq py-mark-decorators
(not py-mark-decorators))
:help "If py-mark-def-or-class functions should mark decorators too. Default is `nil'. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-mark-decorators]
["Fontify shell buffer "
(setq py-fontify-shell-buffer-p
(not py-fontify-shell-buffer-p))
:help "If code in Python shell should be highlighted as in script buffer.
Default is nil.
If `t', related vars like `comment-start' will be set too.
Seems convenient when playing with stuff in IPython shell
Might not be TRT when a lot of output arrives Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-fontify-shell-buffer-p]
["Use font lock doc face "
(setq py-use-font-lock-doc-face-p
(not py-use-font-lock-doc-face-p))
:help "If documention string inside of def or class get `font-lock-doc-face'.
`font-lock-doc-face' inherits `font-lock-string-face'.
Call M-x `customize-face' in order to have a visible effect. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-use-font-lock-doc-face-p])
["Switch buffers on execute"
(setq py-switch-buffers-on-execute-p
(not py-switch-buffers-on-execute-p))
:help "When non-nil switch to the Python output buffer.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-switch-buffers-on-execute-p]
["Split windows on execute"
(setq py-split-window-on-execute
(not py-split-window-on-execute))
:help "When non-nil split windows.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-split-window-on-execute]
["Keep windows configuration"
(setq py-keep-windows-configuration
(not py-keep-windows-configuration))
:help "If a windows is splitted displaying results, this is directed by variable `py-split-window-on-execute'\. Also setting `py-switch-buffers-on-execute-p' affects window-configuration\. While commonly a screen splitted into source and Python-shell buffer is assumed, user may want to keep a different config\.
Setting `py-keep-windows-configuration' to `t' will restore windows-config regardless of settings mentioned above\. However, if an error occurs, it's displayed\.
To suppres window-changes due to error-signaling also: M-x customize-variable RET. Set `py-keep-4windows-configuration' onto 'force
Default is nil Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-keep-windows-configuration]
["Which split windows on execute function"
(progn
(if (eq 'split-window-vertically py-split-windows-on-execute-function)
(setq py-split-windows-on-execute-function'split-window-horizontally)
(setq py-split-windows-on-execute-function 'split-window-vertically))
(message "py-split-windows-on-execute-function set to: %s" py-split-windows-on-execute-function))
:help "If `split-window-vertically' or `...-horizontally'. Use `M-x customize-variable' RET `py-split-windows-on-execute-function' RET to set it permanently"
:style toggle :selected py-split-windows-on-execute-function]
["Modeline display full path "
(setq py-modeline-display-full-path-p
(not py-modeline-display-full-path-p))
:help "If the full PATH/TO/PYTHON should be displayed in shell modeline.
Default is nil. Note: when `py-shell-name' is specified with path, it's shown as an acronym in buffer-name already. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-modeline-display-full-path-p]
["Modeline acronym display home "
(setq py-modeline-acronym-display-home-p
(not py-modeline-acronym-display-home-p))
:help "If the modeline acronym should contain chars indicating the home-directory.
Default is nil Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-modeline-acronym-display-home-p]
["Hide show hide docstrings"
(setq py-hide-show-hide-docstrings
(not py-hide-show-hide-docstrings))
:help "Controls if doc strings can be hidden by hide-showUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-hide-show-hide-docstrings]
["Hide comments when hiding all"
(setq py-hide-comments-when-hiding-all
(not py-hide-comments-when-hiding-all))
:help "Hide the comments too when you do `hs-hide-all'. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-hide-comments-when-hiding-all]
["Max help buffer "
(setq py-max-help-buffer-p
(not py-max-help-buffer-p))
:help "If \"\*Python-Help\*\"-buffer should appear as the only visible.
Default is nil. In help-buffer, \"q\" will close it. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-max-help-buffer-p]
["Current defun show"
(setq py-current-defun-show
(not py-current-defun-show))
:help "If `py-current-defun' should jump to the definition, highlight it while waiting PY-WHICH-FUNC-DELAY seconds, before returning to previous position.
Default is `t'.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-current-defun-show]
["Match paren mode"
(setq py-match-paren-mode
(not py-match-paren-mode))
:help "Non-nil means, cursor will jump to beginning or end of a block.
This vice versa, to beginning first.
Sets `py-match-paren-key' in python-mode-map.
Customize `py-match-paren-key' which key to use. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-match-paren-mode])
("Debug"
["py-debug-p"
(setq py-debug-p
(not py-debug-p))
:help "When non-nil, keep resp\. store information useful for debugging\.
Temporary files are not deleted\. Other functions might implement
some logging etc\. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-debug-p]
["Pdbtrack do tracking "
(setq py-pdbtrack-do-tracking-p
(not py-pdbtrack-do-tracking-p))
:help "Controls whether the pdbtrack feature is enabled or not.
When non-nil, pdbtrack is enabled in all comint-based buffers,
e.g. shell buffers and the \*Python\* buffer. When using pdb to debug a
Python program, pdbtrack notices the pdb prompt and displays the
source file and line that the program is stopped at, much the same way
as gud-mode does for debugging C programs with gdb.Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-pdbtrack-do-tracking-p]
["Jump on exception"
(setq py-jump-on-exception
(not py-jump-on-exception))
:help "Jump to innermost exception frame in Python output buffer.
When this variable is non-nil and an exception occurs when running
Python code synchronously in a subprocess, jump immediately to the
source code of the innermost traceback frame.
Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-jump-on-exception]
["Highlight error in source "
(setq py-highlight-error-source-p
(not py-highlight-error-source-p))
:help "Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-highlight-error-source-p])
("Other"
("Directory"
["Guess install directory "
(setq py-guess-py-install-directory-p
(not py-guess-py-install-directory-p))
:help "If in cases, `py-install-directory' isn't set, `py-set-load-path'should guess it from `buffer-file-name'. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-guess-py-install-directory-p]
["Use local default"
(setq py-use-local-default
(not py-use-local-default))
:help "If `t', py-shell will use `py-shell-local-path' instead
of default Python.
Making switch between several virtualenv's easier,
`python-mode' should deliver an installer, so named-shells pointing to virtualenv's will be available. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-use-local-default]
["Use current dir when execute "
(setq py-use-current-dir-when-execute-p
(not py-use-current-dir-when-execute-p))
:help "When `t', current directory is used by Python-shell for output of `py-execute-buffer' and related commands.
See also `py-execute-directory'Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-use-current-dir-when-execute-p]
["Keep shell dir when execute "
(setq py-keep-shell-dir-when-execute-p
(not py-keep-shell-dir-when-execute-p))
:help "Don't change Python shell's current working directory when sending code.
See also `py-execute-directory'Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-keep-shell-dir-when-execute-p]
["Fileless buffer use default directory "
(setq py-fileless-buffer-use-default-directory-p
(not py-fileless-buffer-use-default-directory-p))
:help "When `py-use-current-dir-when-execute-p' is non-nil and no buffer-file exists, value of `default-directory' sets current working directory of Python output shellUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-fileless-buffer-use-default-directory-p])
("Underscore word syntax"
:help "Toggle `py-underscore-word-syntax-p'"
["Toggle underscore word syntax" toggle-py-underscore-word-syntax-p
:help " `toggle-py-underscore-word-syntax-p'
If `py-underscore-word-syntax-p' should be on or off.
Returns value of `py-underscore-word-syntax-p' switched to. .
Use `M-x customize-variable' to set it permanently"]
["Underscore word syntax on" py-underscore-word-syntax-p-on
:help " `py-underscore-word-syntax-p-on'
Make sure, py-underscore-word-syntax-p' is on.
Returns value of `py-underscore-word-syntax-p'. .
Use `M-x customize-variable' to set it permanently"]
["Underscore word syntax off" py-underscore-word-syntax-p-off
:help " `py-underscore-word-syntax-p-off'
Make sure, `py-underscore-word-syntax-p' is off.
Returns value of `py-underscore-word-syntax-p'. .
Use `M-x customize-variable' to set it permanently"])
["Load pymacs "
(setq py-load-pymacs-p
(not py-load-pymacs-p))
:help "If Pymacs related stuff should be loaded.
Default is nil.
Pymacs has been written by François Pinard and many others.
See original source: http://pymacs.progiciels-bpi.caUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-load-pymacs-p]
["Verbose "
(setq py-verbose-p
(not py-verbose-p))
:help "If functions should report results.
Default is nil. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-verbose-p]
["Empty comment line separates paragraph "
(setq py-empty-comment-line-separates-paragraph-p
(not py-empty-comment-line-separates-paragraph-p))
:help "Consider paragraph start/end lines with nothing inside but comment sign.
Default is non-nilUse `M-x customize-variable' to set it permanently"
:style toggle :selected py-empty-comment-line-separates-paragraph-p]
["Org cycle "
(setq py-org-cycle-p
(not py-org-cycle-p))
:help "When non-nil, command `org-cycle' is available at shift-TAB,
Default is nil. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-org-cycle-p]
["Set pager cat"
(setq py-set-pager-cat-p
(not py-set-pager-cat-p))
:help "If the shell environment variable \$PAGER should set to `cat'.
If `t', use `C-c C-r' to jump to beginning of output. Then scroll normally.
Avoids lp:783828, \"Terminal not fully functional\", for help('COMMAND') in python-shell
When non-nil, imports module `os' Use `M-x customize-variable' to
set it permanently"
:style toggle :selected py-set-pager-cat-p]
["Edit only "
(setq py-edit-only-p
(not py-edit-only-p))
:help "When `t' `python-mode' will not take resort nor check for installed Python executables. Default is nil.
See bug report at launchpad, lp:944093. Use `M-x customize-variable' to set it permanently"
:style toggle :selected py-edit-only-p])))
("Other"
["Boolswitch" py-boolswitch
:help " `py-boolswitch'
Edit the assignment of a boolean variable, revert them.
I.e. switch it from \"True\" to \"False\" and vice versa"]
["Empty out list backward" py-empty-out-list-backward
:help " `py-empty-out-list-backward'
Deletes all elements from list before point."]
["Kill buffer unconditional" py-kill-buffer-unconditional
:help " `py-kill-buffer-unconditional'
Kill buffer unconditional, kill buffer-process if existing."]
["Remove overlays at point" py-remove-overlays-at-point
:help " `py-remove-overlays-at-point'
Remove overlays as set when `py-highlight-error-source-p' is non-nil."]
("Electric"
["Complete electric comma" py-complete-electric-comma
:help " `py-complete-electric-comma'"]
["Complete electric lparen" py-complete-electric-lparen
:help " `py-complete-electric-lparen'"]
["Electric backspace" py-electric-backspace
:help " `py-electric-backspace'
Delete preceding character or level of indentation.
With ARG do that ARG times.
Returns column reached."]
["Electric colon" py-electric-colon
:help " `py-electric-colon'
Insert a colon and indent accordingly.
If a numeric argument ARG is provided, that many colons are inserted
non-electrically.
Electric behavior is inhibited inside a string or
comment or by universal prefix C-u.
Switched by `py-electric-colon-active-p', default is nil
See also `py-electric-colon-greedy-p'"]
["Electric comment" py-electric-comment
:help " `py-electric-comment'
Insert a comment. If starting a comment, indent accordingly.
If a numeric argument ARG is provided, that many \"#\" are inserted
non-electrically.
With C-u \"#\" electric behavior is inhibited inside a string or comment."]
["Electric delete" py-electric-delete
:help " `py-electric-delete'
Delete following character or levels of whitespace.
With ARG do that ARG times."]
["Electric yank" py-electric-yank
:help " `py-electric-yank'
Perform command `yank' followed by an `indent-according-to-mode'"]
["Hungry delete backwards" py-hungry-delete-backwards
:help " `py-hungry-delete-backwards'
Delete the preceding character or all preceding whitespace
back to the previous non-whitespace character.
See also C-c ."]
["Hungry delete forward" py-hungry-delete-forward
:help " `py-hungry-delete-forward'
Delete the following character or all following whitespace
up to the next non-whitespace character.
See also C-c ."]
)
("Abbrevs" :help "see also `py-add-abbrev'"
:filter (lambda (&rest junk)
(abbrev-table-menu python-mode-abbrev-table)) )
["Add abbrev" py-add-abbrev
:help " `py-add-abbrev'
Defines python-mode specific abbrev for last expressions before point.
Argument is how many `py-partial-expression's form the expansion; or zero means the region is the expansion.
Reads the abbreviation in the minibuffer; with numeric arg it displays a proposal for an abbrev.
Proposal is composed from the initial character(s) of the
expansion.
Don't use this function in a Lisp program; use `define-abbrev' instead."]
("Completion"
["Py indent or complete" py-py-indent-or-complete
:help " `py-py-indent-or-complete'"]
["Py shell complete" py-py-shell-complete
:help " `py-py-shell-complete'"]
["Py complete" py-py-complete
:help " `py-py-complete'"]
)))))
;; python-components-foot
(defun py-shell-fontify ()
"Fontifies input in shell buffer. "
;; causes delay in fontification until next trigger
;; (unless (or (member (char-before) (list 32 ?: ?\)))
;; (unless (and (eq last-command 'self-insert-command) (eq (char-before) 32))
;; (< (abs (save-excursion (skip-chars-backward "^ \t\r\n\f"))) 2))
(let* ((pps (parse-partial-sexp (line-beginning-position) (point)))
(start (if (and (nth 8 pps) (nth 1 pps))
(max (nth 1 pps) (nth 8 pps))
(or (nth 1 pps) (nth 8 pps)))))
(when (or start
(setq start (ignore-errors (cdr comint-last-prompt))))
(let* ((input (buffer-substring-no-properties
start (point-max)))
(buffer-undo-list t)
(replacement
(save-current-buffer
(set-buffer py-shell--font-lock-buffer)
(erase-buffer)
(insert input)
;; Ensure buffer is fontified, keeping it
;; compatible with Emacs < 24.4.
(if (fboundp 'font-lock-ensure)
(funcall 'font-lock-ensure)
(font-lock-default-fontify-buffer))
(buffer-substring (point-min) (point-max))))
(replacement-length (length replacement))
(i 0))
;; Inject text properties to get input fontified.
(while (not (= i replacement-length))
(let* ((plist (text-properties-at i replacement))
(next-change (or (next-property-change i replacement)
replacement-length))
(plist (let ((face (plist-get plist 'face)))
(if (not face)
plist
;; Replace FACE text properties with
;; FONT-LOCK-FACE so input is fontified.
(plist-put plist 'face nil)
(plist-put plist 'font-lock-face face)))))
(set-text-properties
(+ start i) (+ start next-change) plist)
(setq i next-change)))))))
(defun py-message-which-python-mode ()
(if (buffer-file-name)
(if (string= "python-mode-el" (buffer-file-name))
(message "%s" "python-mode loaded from python-mode-el")
(message "%s" "python-mode loaded from python-components-mode"))
(message "python-mode loaded from: %s" python-mode-message-string)))
;;;###autoload
(define-derived-mode py-auto-completion-mode python-mode "Pac"
"Run auto-completion"
;; disable company
;; (when company-mode (company-mode))
(if py-auto-completion-mode-p
(progn
(setq py-auto-completion-mode-p nil
py-auto-completion-buffer nil)
(when (timerp py--auto-complete-timer)(cancel-timer py--auto-complete-timer)))
(setq py-auto-completion-mode-p t
py-auto-completion-buffer (current-buffer))
(setq py--auto-complete-timer
(run-with-idle-timer
py--auto-complete-timer-delay
;; 1
t
#'py-complete-auto)))
(force-mode-line-update))
;;;###autoload
(define-derived-mode python-mode prog-mode python-mode-modeline-display
"Major mode for editing Python files.
To submit a problem report, enter `\\[py-submit-bug-report]' from a
`python-mode' buffer. Do `\\[py-describe-mode]' for detailed
documentation. To see what version of `python-mode' you are running,
enter `\\[py-version]'.
This mode knows about Python indentation, tokens, comments and
continuation lines. Paragraphs are separated by blank lines only.
COMMANDS
`py-shell'\tStart an interactive Python interpreter in another window
`py-execute-statement'\tSend statement at point to Python default interpreter
`py-backward-statement'\tGo to the initial line of a simple statement
etc.
See available commands listed in files commands-python-mode at directory doc
VARIABLES
`py-indent-offset' indentation increment
`py-shell-name' shell command to invoke Python interpreter
`py-split-window-on-execute' When non-nil split windows
`py-switch-buffers-on-execute-p' When non-nil switch to the Python output buffer
See available customizations listed in files variables-python-mode at directory doc
\\{python-mode-map}"
:group 'python-mode
;; Local vars
(set (make-local-variable 'electric-indent-inhibit) nil)
(set (make-local-variable 'outline-regexp)
(concat (mapconcat 'identity
(mapcar #'(lambda (x) (concat "^\\s-*" x "\\_>"))
py-outline-mode-keywords)
"\\|")))
(when (eq 0 (string-match "25" emacs-version))
(global-eldoc-mode -1))
(if py-use-font-lock-doc-face-p
(set (make-local-variable 'font-lock-defaults)
'(python-font-lock-keywords nil nil nil nil
(font-lock-syntactic-keywords
. py-font-lock-syntactic-keywords)
(font-lock-syntactic-face-function
. py--font-lock-syntactic-face-function)))
(set (make-local-variable 'font-lock-defaults)
'(python-font-lock-keywords nil nil nil nil
(font-lock-syntactic-keywords
. py-font-lock-syntactic-keywords))))
;; avoid to run py-choose-shell again from `py--fix-start'
(cond ((string-match "ython3" py-python-edit-version)
(font-lock-add-keywords 'python-mode
'(("\\" . 'py-builtins-face)
("\\" . nil))))
(t (font-lock-add-keywords 'python-mode
'(("\\" . 'font-lock-keyword-face)
("\\" . 'py-builtins-face)))))
(set (make-local-variable 'which-func-functions) 'py-which-def-or-class)
(set (make-local-variable 'parse-sexp-lookup-properties) t)
(set (make-local-variable 'comment-use-syntax) t)
(set (make-local-variable 'comment-start) "#")
(set (make-local-variable 'comment-start-skip) "^[ \t]*#+ *")
(if py-empty-comment-line-separates-paragraph-p
(progn
(set (make-local-variable 'paragraph-separate) (concat "\f\\|^[ \t]*$\\|^[ \t]*" comment-start "[ \t]*$\\|^[ \t\f]*:[[:alpha:]]+ [[:alpha:]]+:.+$"))
(set (make-local-variable 'paragraph-start)
(concat "\f\\|^[ \t]*$\\|^[ \t]*" comment-start "[ \t]*$\\|^[ \t\f]*:[[:alpha:]]+ [[:alpha:]]+:.+$"))
(set (make-local-variable 'paragraph-separate)
(concat "\f\\|^[ \t]*$\\|^[ \t]*" comment-start "[ \t]*$\\|^[ \t\f]*:[[:alpha:]]+ [[:alpha:]]+:.+$")))
;; (progn
;; (set (make-local-variable 'paragraph-separate) "\f\\|^[ \t]*$\\|^[ \t]*#[ \t]*$\\|^[ \t\f]*:[[:alpha:]]+ [[:alpha:]]+:.+$")
;; (set (make-local-variable 'paragraph-start) "\f\\|^[ \t]*$\\|^[ \t]*#[ \t]*$\\|^[ \t\f]*:[[:alpha:]]+ [[:alpha:]]+:.+$"))
(set (make-local-variable 'paragraph-separate) "\f\\|^[ \t]*$\\|^[ \t]*#[ \t]*$\\|^[ \t\f]*:[[:alpha:]]+ [[:alpha:]]+:.+$")
(set (make-local-variable 'paragraph-start) "\f\\|^[ \t]*$\\|^[ \t]*#[ \t]*$\\|^[ \t\f]*:[[:alpha:]]+ [[:alpha:]]+:.+$"))
(set (make-local-variable 'comment-column) 40)
(set (make-local-variable 'comment-indent-function) #'py--comment-indent-function)
(set (make-local-variable 'indent-region-function) 'py-indent-region)
(set (make-local-variable 'indent-line-function) 'py-indent-line)
(set (make-local-variable 'hs-hide-comments-when-hiding-all) 'py-hide-comments-when-hiding-all)
(set (make-local-variable 'outline-heading-end-regexp) ":[^\n]*\n")
(set (make-local-variable 'open-paren-in-column-0-is-defun-start) nil)
(set (make-local-variable 'add-log-current-defun-function) 'py-current-defun)
(set (make-local-variable 'fill-paragraph-function) 'py-fill-paragraph)
(set (make-local-variable 'require-final-newline) mode-require-final-newline)
(set (make-local-variable 'tab-width) py-indent-offset)
(set (make-local-variable 'eldoc-documentation-function)
#'py-eldoc-function)
(and py-load-skeletons-p
(py-load-skeletons)
(set (make-local-variable 'skeleton-further-elements)
'((< '(backward-delete-char-untabify (min py-indent-offset
(current-column))))
(^ '(- (1+ (current-indentation)))))))
(and py-guess-py-install-directory-p (py-set-load-path))
(and py-autopair-mode
(load-library "autopair")
(add-hook 'python-mode-hook
#'(lambda ()
(setq autopair-handle-action-fns
(list #'autopair-default-handle-action
#'autopair-python-triple-quote-action))))
(py-autopair-mode-on))
(when py-trailing-whitespace-smart-delete-p
(add-hook 'before-save-hook 'delete-trailing-whitespace nil 'local))
(when py-pdbtrack-do-tracking-p
(add-hook 'comint-output-filter-functions 'py--pdbtrack-track-stack-file))
(cond
(py-complete-function
(add-hook 'completion-at-point-functions
py-complete-function nil 'local))
(py-load-pymacs-p
(add-hook 'completion-at-point-functions
'py-complete-completion-at-point nil 'local))
(t
(add-hook 'completion-at-point-functions
'py-shell-complete nil 'local)))
;; (if py-auto-complete-p
;; (add-hook 'python-mode-hook 'py--run-completion-timer)
;; (remove-hook 'python-mode-hook 'py--run-completion-timer))
;; (when py-auto-complete-p
;; (add-hook 'python-mode-hook
;; (lambda ()
;; (run-with-idle-timer 1 t 'py-shell-complete))))
(if py-auto-fill-mode
(add-hook 'python-mode-hook 'py--run-auto-fill-timer)
(remove-hook 'python-mode-hook 'py--run-auto-fill-timer))
;; caused insert-file-contents error lp:1293172
;; (add-hook 'after-change-functions 'py--after-change-function nil t)
(if py-defun-use-top-level-p
(progn
(set (make-local-variable 'beginning-of-defun-function) 'py-backward-top-level)
(set (make-local-variable 'end-of-defun-function) 'py-end-of-top-level)
(define-key python-mode-map [(control meta a)] 'py-backward-top-level)
(define-key python-mode-map [(control meta e)] 'py-end-of-top-level))
(set (make-local-variable 'beginning-of-defun-function) 'py-backward-def-or-class)
(set (make-local-variable 'end-of-defun-function) 'py-end-of-def-or-class)
(define-key python-mode-map [(control meta a)] 'py-backward-def-or-class)
(define-key python-mode-map [(control meta e)] 'py-end-of-def-or-class))
(when py-sexp-use-expression-p
(define-key python-mode-map [(control meta f)] 'py-forward-expression)
(define-key python-mode-map [(control meta b)] 'py-backward-expression))
(when (and py--imenu-create-index-p
(fboundp 'imenu-add-to-menubar)
(ignore-errors (require 'imenu)))
(setq imenu-create-index-function 'py--imenu-create-index-function)
(setq imenu--index-alist (funcall py--imenu-create-index-function))
;; fallback
(unless imenu--index-alist
(setq imenu--index-alist (py--imenu-create-index-new)))
;; (message "imenu--index-alist: %s" imenu--index-alist)
(imenu-add-to-menubar "PyIndex"))
(when py-hide-show-minor-mode-p (hs-minor-mode 1))
(when py-outline-minor-mode-p (outline-minor-mode 1))
(when (interactive-p)
(py-message-which-python-mode))
(force-mode-line-update))
(defun py--shell-setup-fontification (&optional style)
"Expected values are either nil, 'all or 'input. "
(setq style (or style py-shell-fontify-style))
(if style
(progn
(cond ((eq 'all style)
(remove-hook 'change-major-mode-hook 'font-lock-defontify)
(set (make-local-variable 'py--shell-unfontify) 'py-shell-unfontify-p)
(when py--shell-unfontify
(add-hook 'py-python-shell-mode-hook #'py--run-unfontify-timer (current-buffer)))
(remove-hook 'post-command-hook 'py-shell-fontify t)
(set (make-local-variable 'font-lock-defaults)
'(python-font-lock-keywords nil nil nil nil
(font-lock-syntactic-keywords
. py-font-lock-syntactic-keywords)))
(if (fboundp 'font-lock-ensure)
(funcall 'font-lock-ensure)
(font-lock-default-fontify-buffer)))
;; style is 'input, prepare `py-shell-fontify'
(t (set (make-local-variable 'delay-mode-hooks) t)
(save-current-buffer
;; Prepare the buffer where the input is fontified
(set-buffer (get-buffer-create py-shell--font-lock-buffer))
(font-lock-mode 1)
(python-mode))
;; post-self-insert-hook
(add-hook 'post-command-hook
#'py-shell-fontify nil 'local)))
(force-mode-line-update))
;; no fontification in py-shell
(remove-hook 'py-python-shell-mode-hook 'py--run-unfontify-timer t)
(remove-hook 'post-command-hook 'py-shell-fontify t)))
(defun py--all-shell-mode-setting ()
(py--shell-setup-fontification)
(setenv "PAGER" "cat")
(setenv "TERM" "dumb")
(set-syntax-table python-mode-syntax-table)
(if py-auto-complete-p
(add-hook 'py-shell-mode-hook 'py--run-completion-timer)
(remove-hook 'py-shell-mode-hook 'py--run-completion-timer))
;; comint settings
(set (make-local-variable 'comint-prompt-regexp)
(cond ((string-match "[iI][pP]ython[[:alnum:]*-]*$" py-buffer-name)
(concat "\\("
(mapconcat 'identity
(delq nil (list py-shell-input-prompt-1-regexp py-shell-input-prompt-2-regexp py-ipython-input-prompt-re py-ipython-output-prompt-re py-pdbtrack-input-prompt py-pydbtrack-input-prompt))
"\\|")
"\\)"))
(t (concat "\\("
(mapconcat 'identity
(delq nil (list py-shell-input-prompt-1-regexp py-shell-input-prompt-2-regexp py-pdbtrack-input-prompt py-pydbtrack-input-prompt))
"\\|")
"\\)"))))
(remove-hook 'comint-output-filter-functions 'font-lock-extend-jit-lock-region-after-change t)
(make-local-variable 'comint-output-filter-functions)
;; (set (make-local-variable 'comint-input-filter) 'py--input-filter)
(set (make-local-variable 'comint-input-filter) 'py-history-input-filter)
(set (make-local-variable 'comint-prompt-read-only) py-shell-prompt-read-only)
;; (set (make-local-variable 'comint-use-prompt-regexp) nil)
(set (make-local-variable 'compilation-error-regexp-alist)
py-compilation-regexp-alist)
(set (make-local-variable 'comment-start) "# ")
(set (make-local-variable 'comment-start-skip) "^[ \t]*#+ *")
(set (make-local-variable 'comment-column) 40)
(set (make-local-variable 'comment-indent-function) #'py--comment-indent-function)
(set (make-local-variable 'indent-region-function) 'py-indent-region)
(set (make-local-variable 'indent-line-function) 'py-indent-line)
(set (make-local-variable 'inhibit-point-motion-hooks) t)
(set (make-local-variable 'comint-input-sender) 'py--shell-simple-send))
;;;###autoload
(define-derived-mode py-python-shell-mode comint-mode "Py"
"Major mode for interacting with a Python process.
A Python process can be started with \\[py-shell].
You can send text to the Python process from other buffers
containing Python source.
* \\[py-execute-region] sends the current region to the Python process.
Sets basic comint variables, see also versions-related stuff in `py-shell'.
\\{py-python-shell-mode-map}"
:group 'python-mode
;; (require 'ansi-color) ; for ipython
(setq mode-line-process '(":%s"))
;; (sit-for 0.1)
(when py-verbose-p (message "%s" "Initializing Python shell, please wait"))
(py--all-shell-mode-setting)
(py--python-send-completion-setup-code)
(py--python-send-ffap-setup-code)
(py--python-send-eldoc-setup-code)
(set-process-sentinel (get-buffer-process (current-buffer)) #'shell-write-history-on-exit)
;; (setq comint-input-ring-file-name
;; (cond ((string-match "[iI][pP]ython[[:alnum:]*-]*$" py-buffer-name)
;; (if py-honor-IPYTHONDIR-p
;; (if (getenv "IPYTHONDIR")
;; (concat (getenv "IPYTHONDIR") "/history")
;; py-ipython-history)
;; py-ipython-history))
;; (t
;; (if py-honor-PYTHONHISTORY-p
;; (if (getenv "PYTHONHISTORY")
;; (concat (getenv "PYTHONHISTORY") "/" (py--report-executable py-buffer-name) "_history")
;; py-ipython-history)
;; py-ipython-history)))
;;)
(comint-read-input-ring t)
(compilation-shell-minor-mode 1)
;;
(if py-complete-function
(progn
(add-hook 'completion-at-point-functions
py-complete-function nil 'local)
(push py-complete-function comint-dynamic-complete-functions))
(add-hook 'completion-at-point-functions
'py-shell-complete nil 'local)
(push 'py-shell-complete comint-dynamic-complete-functions))
(when py-sexp-use-expression-p
(define-key py-python-shell-mode-map [(control meta f)] 'py-forward-expression)
(define-key py-python-shell-mode-map [(control meta b)] 'py-backward-expression))
(force-mode-line-update))
;;;###autoload
(define-derived-mode py-ipython-shell-mode comint-mode "IPy"
"Major mode for interacting with a Python process.
A Python process can be started with \\[py-shell].
You can send text to the Python process from other buffers
containing Python source.
* \\[py-execute-region] sends the current region to the Python process.
Sets basic comint variables, see also versions-related stuff in `py-shell'.
\\{py-ipython-shell-mode-map}"
:group 'python-mode
;; (require 'ansi-color) ; for ipython
(setq mode-line-process '(":%s"))
(when py-verbose-p (message "%s" "Initializing IPython shell, please wait"))
(py--all-shell-mode-setting)
(py--python-send-completion-setup-code)
(py--python-send-ffap-setup-code)
(py--python-send-eldoc-setup-code)
(py--ipython-import-module-completion)
(py-set-ipython-completion-command-string (process-name (get-buffer-process (current-buffer))))
(sit-for 0.1 t)
(comint-read-input-ring t)
(compilation-shell-minor-mode 1)
(if py-complete-function
(progn
(add-hook 'completion-at-point-functions
py-complete-function nil 'local)
(push py-complete-function comint-dynamic-complete-functions))
(add-hook 'completion-at-point-functions
'py-shell-complete nil 'local)
(push 'py-shell-complete comint-dynamic-complete-functions))
(sit-for 0.5 t)
(force-mode-line-update))
(defalias 'py-backward-decorator-bol 'py-backward-decorator)
(defalias 'py-beginning-of-block 'py-backward-block)
(defalias 'py-beginning-of-block-bol 'py-backward-block-bol)
(defalias 'py-beginning-of-block-or-clause 'py-backward-block-or-clause)
(defalias 'py-beginning-of-class 'py-backward-class)
(defalias 'py-beginning-of-class-bol 'py-backward-class-bol)
(defalias 'py-beginning-of-clause 'py-backward-clause)
(defalias 'py-beginning-of-clause-bol 'py-backward-clause-bol)
(defalias 'py-beginning-of-comment 'py-backward-comment)
(defalias 'py-beginning-of-declarations 'py-backward-declarations)
(defalias 'py-beginning-of-decorator 'py-backward-decorator)
(defalias 'py-beginning-of-decorator-bol 'py-backward-decorator)
(defalias 'py-beginning-of-def-or-class 'py-backward-def-or-class)
(defalias 'py-beginning-of-expression 'py-backward-expression)
(defalias 'py-beginning-of-line 'py-backward-line)
(defalias 'py-beginning-of-minor-block 'py-backward-minor-block)
(defalias 'py-beginning-of-partial-expression 'py-backward-partial-expression)
(defalias 'py-beginning-of-section 'py-backward-section)
(defalias 'py-beginning-of-statement 'py-backward-statement)
(defalias 'py-beginning-of-statement-bol 'py-backward-statement-bol)
(defalias 'py-beginning-of-top-level 'py-backward-top-level)
(defalias 'py-end-of-block 'py-forward-block)
(defalias 'py-end-of-block-or-clause 'py-forward-block-or-clause)
(defalias 'py-end-of-class 'py-forward-class)
(defalias 'py-end-of-clause 'py-forward-clause)
(defalias 'py-end-of-comment 'py-forward-comment)
(defalias 'py-end-of-decorator 'py-forward-decorator)
(defalias 'py-end-of-def-or-class 'py-forward-def-or-class)
(defalias 'py-end-of-expression 'py-forward-expression)
(defalias 'py-end-of-line 'py-forward-line)
(defalias 'py-end-of-partial-expression 'py-forward-partial-expression)
(defalias 'py-end-of-section 'py-forward-section)
(defalias 'py-end-of-statement 'py-forward-statement)
(defalias 'py-end-of-statement-bol 'py-forward-statement-bol)
(defalias 'py-end-of-top-level 'py-forward-top-level)
(defalias 'py-next-statement 'py-forward-statement)
(defalias 'py-markup-region-as-section 'py-sectionize-region)
(defalias 'py-up 'py-up-block)
;;;
(provide 'python-mode)
;;; python-mode.el ends here
python-mode.el-6.2.3/LICENSE 0000644 0000000 0000000 00000104513 12660433546 015344 0 ustar root root 0000000 0000000 GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program 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.
This program 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 this program. If not, see .
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
.
python-mode.el-6.2.3/INSTALL 0000644 0000000 0000000 00000001037 12660433546 015365 0 ustar root root 0000000 0000000 Put the respective lines into your Emacs initialisation file:
(add-to-list 'load-path "PATH/TO/PYTHON-MODE/")
(setq py-install-directory "PATH/TO/PYTHON-MODE/")
(require 'python-mode)
To change the Python default shell use
M-x customize-variable py-shell-name
or write
(setq py-shell-name "MY-PYTHON")
resp.
(setq py-shell-name "PATH/TO/MY-PYTHON")
IPython users for example may insert "ipython" with
M-x customize-variable py-shell-name
or in init-file
(setq py-shell-name "ipython")
resp.
(setq py-shell-name "PATH/TO/ipython")
python-mode.el-6.2.3/NEWS 0000644 0000000 0000000 00000111261 13035634070 015024 0 ustar root root 0000000 0000000 Python Mode News
================
New in version 6.2.3
---------------------
Commands saying "up" reach one level less indented than start of
current form
New customizable `py-shell-fontify-style' offers some choice
how to fontify py-shell buffer:
"input" will leave previous IN/OUT unfontified.
"all" keeps output fontified too.
Default is nil, no fontification.
New in version 6.2.2
---------------------
Edit-commands will reach beginning-of-line if reasonable
Edit-commands suffixed "-bol" dropped
- Commands
- py-backward-indent
Go to the beginning of a section of equal indent
- py-forward-indent
Go to the end of a section of equal indentation
- py-copy-indent
- py-delete-indent
- py-kill-indent
- py-mark-indent
- py-comment-indent
- py-shift-indent-left
- py-shift-indent-right
- py-hide-indent
- py-show-indent
- Make $PYTHONPATH configurable from Emacs
Emacs doesn't read settings from .bashrc
- py-indent-paren-spanned-multilines-p new default `t'
New in version 6.2.1
---------------------
- Handle PEP 492 async coroutines
- Logic of py-indent-region WRT lp:1426903
In case first line accepts an indent,
keep the remaining lines' relative.
Otherwise lines in region get outmost indent,
same with optional argument
- Commands
- py-match-paren
If at a beginning, jump to end and vice versa.
Matches lists, block, statement, string and comment
- ipython2.7
- ipython3
- py-beginning-of-for-block
- py-beginning-of-for-block-bol
- py-end-of-statement-bol
- py-end-of-top-level-bol
- py-flycheck-mode - toggle `flycheck-mode' from menu "Checks"
- py-execute-section - execute arbitrary chunks of code
- py-execute-section-python
- py-execute-section-python2
- py-execute-section-python3
- py-execute-section-ipython
- py-execute-section-ipython2.7
- py-execute-section-ipython3
- py-execute-section-jython
- py-sectionize-region
- py-backward-section
- py-forward-section
- py-narrow-to-block
- py-narrow-to-block-or-clause
- py-narrow-to-class
- py-narrow-to-clause
- py-narrow-to-def
- py-narrow-to-def-or-class
- py-narrow-to-statement
- New helper functions, like
- py--end-of-block-bol-p
- py--end-of-clause-bol-p
etc.
Functions in a boolean sense just stating if being at an end or
start no longer a command. Renamed as interanal
functions with prefix `py--' now.
- TAB-indent from column zero: go to outmost first, lp:1375122
- (I)Python-shell setup made more reliable
New customizables:
- py-imenu-max-items, default is 99
Sets `imenu-max-items'
- py-python-edit-version, default is ""
When not empty, fontify according to Python version specified.
- py-pdb-executable, default is nil
Indicate PATH/TO/pdb.
- py-update-gud-pdb-history-p, default is t
If pdb should provide suggestions WRT file and pdb-path.
- py-split-window-on-execute-threshold, default is 3
Don't split when max number of displayed windows is reached.
Renamed:
- py-beginning-of-commented-section --> py-beginning-of-comments
- py-narrow-to-defun --> py-narrow-to-def
New in version 6.2.0
---------------------
- Support for large output
new commands py-fast-process, py-fast-...
Fixes: large output makes Emacs freeze, lp:1253907
Python code now might be processed by an
- interactive Python shell (DEFAULT)
- non-interactive Python (`py-fast-process-p', if large output)
Both processes might run in
- session, i.e. start from possible previous state (DEFAULT)
- dedicated, (`py-dedicated-process-p', run in separate process)
- TAB bound to `py-indent-or-complete', completes at EOL.
Calls to `tab-to-tab-stop' removed, as these would conflict.
Use `C-q TAB' to insert a literally TAB-character.
- py-fast-complete
Complete word before point, if any, use `py-fast-process'
- `py-shell-complete-or-indent'
In shell: complete or indent depending on the context.
If cursor is at current-indentation and further indent
seems reasonable, indent. Otherwise try to complete.
- Python specific hide-show
py-hide-region
py-show-region
py-hide-statement
py-show-statement
py-hide-block
py-show-block
py-hide-clause
py-show-clause
py-hide-block-or-clause
py-show-block-or-clause
py-hide-def
py-show-def
py-hide-class
py-show-class
py-hide-expression
py-show-expression
py-hide-partial-expression
py-show-partial-expression
py-hide-line
py-show-line
py-hide-top-level
py-show-top-level
- `py-shell' uses new `py-shell-mode', `py-shell-mode-map'
M-x describe-mode RET mentions edit available commands
Menu "Py-Shell"
- Improved customization of Python2, Python3, IPython executables
receive defaults depending from system
py-python-command - defaults to python2
py-python2-command
py-python3-command
py-ipython-command
py-python-command-args
py-python2-command-args
py-python3-command-args
py-ipython-command-args
- info-lookup-symbol made working with Python
patched python-info.el available at
https://bitbucket.org/andreas_roehler/pydoc-info
See also INSTALL-INFO-FILES
- `py-backward-same-level'
While `py-up' will go upward from beginning of block, this travels
same level, but goes up if no element left in level. If callled
from inside a string or list, go to its beginning.
- `py-kill-shell-unconditional'
With optional argument SHELL, otherwise kill default
(I)Python shell.
- py-info-lookup-symbol ()
Calls `info-lookup-symbol'. Sends help if stuff is missing.
- py-toggle-split-window-function
If window is splitted vertically or horizontally.
Sets customizable variable
`py-split-window-on-execute-function'
Also in menu Python/Customize/Switches/Display/Which split windows
- py-symbol-at-point
Return the Python symbol under cursor
- py-report-comint-variable-setting
Display Py-shell' comint-mode variables of interest.
- variables-state
Diplays state of python-mode variables in an org-mode buffer
- py-kill-buffer-unconditional
Kill buffer unconditional; kill also any buffer-process.
Setting docstring style simplified; a style is all needed.
New commands
-py-set-nil-docstring-style
-py-set-pep-257-nn-docstring-style
-py-set-pep-257-docstring-style
-py-set-django-docstring-style
-py-set-symmetric-docstring-style
-py-set-onetwo-docstring-style
- new indent feature/behavior, lp:1280982
If an empty line was dedented deliberatly, this is
honored by next lines indent
- py-object-reference-face
commonly "self" or "cls", inherits default face
- py-error
In case of error, list messages from Python process
- `py-split-windows-on-execute-p' renamed `py-split-window-on-execute'
Not a boolean any more, new option 'just-two: When code is send to
interpreter, split screen into source-code buffer and current
--maybe reused-- py-shell. When set to `t' --default--, python-mode
will keep existing windows and split only if needed. Alternatively
if a multitude of python-shells/buffers should be visible, open them
manually and set `py-keep-windows-configuration' to `t'.
If `always' split according to settings of `split-height-threshold', `split-width-threshold'; with `t' keep just two windows
- For completeness some commands user might expect
py-execute-statement-dedicated
py-execute-block-dedicated
py-execute-clause-dedicated
py-execute-block-or-clause-dedicated
py-execute-def-dedicated
py-execute-class-dedicated
py-execute-region-dedicated
py-execute-buffer-dedicated
py-execute-expression-dedicated
py-execute-partial-expression-dedicated
py-execute-line-dedicated
py-execute-top-level-dedicated
- `py-unload-python-el'
Normally commands delivered by python.el are usable alongside with
python-mode.el. Some old version of python.el might write skeletons into
python-mode-abbrev-table, which is removed that way.
Internally used functions preferably are prefixed `py--':
py--statement-opens-block-p
py--statement-opens-clause-p ...
New variable `py-ipython-command' - (PATH-TO)-IPython
Boolean `py-set-fill-column-p' renamed `py-auto-fill-mode'
Fill according to `py-docstring-fill-column' and
`py-comment-fill-column'
`py-font-lock-keywords' renamed `python-font-lock-keywords',
lp:1314921
New booleans
- py-fast-process-p
If `t', stuff is executed through `py-fast-...'-
commands, suitable for large output. Result arrives
in py-fast-output-buffer, which is not in comint-mode
- py-shell-manage-windows-p
If `t', open output buffers, split windows according to settings of
`py-split-window-on-execute' and `py-switch-buffers-on-execute-p'.
Removed commands
-toggle-py-nil-docstring-style
-py-nil-docstring-style-on
-py-nil-docstring-style-off
-toggle-py-onetwo-docstring-style
-py-onetwo-docstring-style-on
-py-onetwo-docstring-style-off
-toggle-py-pep-257-docstring-style
-py-pep-257-docstring-style-on
-py-pep-257-docstring-style-off
-toggle-py-pep-257-nn-docstring-style
-py-pep-257-nn-docstring-style-on
-py-pep-257-nn-docstring-style-off
-toggle-py-symmetric-docstring-style
-py-symmetric-docstring-style-on
-py-symmetric-docstring-style-off
-toggle-py-django-docstring-style
-py-django-docstring-style-on
-py-django-docstring-style-off
Some commands not so useful made common functions, like
-py-statement-opens-block-p
-py-statement-opens-clause-p ...
Dropped booleans:
`py-start-run-py-shell',
`py-start-run-ipython-shell',
`py-pylint-offer-current-p'
`py-paragraph-fill-docstring-p'
`py-enforce-output-buffer-p'
`py-cleanup-temporary', as redundant WRT `py-debug-p'
New in version 6.1.3
---------------------
PEP8 indent-alternatives when closing a list implemented
Boolean `py-close-at-start-column-p', default is nil
my_list = [
1, 2, 3,
4, 5, 6,
]
result = some_function_that_takes_arguments(
'a', 'b', 'c',
'd', 'e', 'f',
)
When non-nil, it will be lined up under the first character of the line that starts the multi-line construct, as in:
my_list = [
1, 2, 3,
4, 5, 6,
]
result = some_function_that_takes_arguments(
'a', 'b', 'c',
'd', 'e', 'f',
)
- Keys C-M-a, C-M-e usable for all top-level form, lp:1191078
Boolean `py-defun-use-top-level-p'
If non-nil, beginning- end-of-defun forms will use
`py-beginning-of-top-level', `py-end-of-top-level',
mark-defun marks top-level form at point etc.
Keys C-M-a, C-M-e usable for all top-level form, lp:1191078
- New commands:
py-beginning-of-block-current-column
"Reach the beginning of block which starts at current column "
py-beginning-of-top-level
py-beginning-of-top-level
py-end-of-top-level
py-mark-top-level
py-copy-top-level
py-delete-top-level
py-kill-top-level
py-execute-top-level
py-top-level-form-p
py-comment-top-level
py-beginning-of-top-level-p
- `minor-block' commands added
A minor block is started by a `for', `if', `try' or `with',
while block covers also `def' or `class'
- variable `py-keep-windows-configuration', default is nil
Setting `py-keep-windows-configuration' to `t' will
restore windows-configuration regardless of
`py-switch-buffers-on-execute-p' and
`py-split-windows-on-execute-p' settings. However, if
an error occurs, it's displayed.
To suppres window-changes due to error-signaling
also, set `py-keep-windows-configuration' onto 'force
- boolean empty-line-closes-p, default is nil
When non-nil, dedent after empty line following block
If non-nil, a C-j from empty line would dedent.
if True:
print("Part of the if-statement")
print("Not part of the if-statement")
- boolean py-debug-p, default is nil
When non-nil, keep resp. store information useful for
debugging. Temporary files are not deleted. Other
functions might implement some logging etc.
- heuristic exit
new var `py-max-specpdl-size', default is `max-specpdl-size'
py-end-of-statement will error if number of
`py-max-specpdl-size' loops is completed, thus avoiding
a hang from a possibly eternal loop.
- `py-statement' no longer refferred to `py-copy-statement'
Same with block, def, expression etc. `py-statement' made
own command, which returns statement, a string.
- boolean `py-max-help-buffer-p', default is nil
If "*Python-Help*"-buffer be the only visible.
New in version 6.1.2
---------------------
- simplified menu
- `py-execute-...'-commands return result as string
Controlled by boolean `py-store-result-p', Default is nil
When non-nil, put resulting string of `py-execute-...' into kill-ring, so it might be yanked.
- commands deleting all commented lines:
`py-delete-comments-in-def-or-class'
`py-delete-comments-in-class'
`py-delete-comments-in-block'
`py-delete-comments-in-region'
- boolean `py-indent-paren-spanned-multilines-p, default is nil
If non-nil, indents elements of list a value of `py-indent-offset' to first element:
def foo():
if (foo &&
baz):
bar()
Default lines up with first element:
def foo():
if (foo &&
baz):
bar()
- `py-output-buffer' made customizable
See boolean `py-enforce-output-buffer-p'
- exceptions following executed regions made point to source
- command `py-empty-out-list-backward'
Deletes all elements from list before point
With when cursor after
mystring[0:1]
-------------^
==>
mystring[]
---------^
In result cursor is insided emptied delimited form."
- `py-minor-expression' reconsidered, numeric args dropped
grasps keyword-arguments
- boolean `py-electric-kill-backward-p', default is nil.
If behind a delimited form of braces, brackets or parentheses,
`py-electric-backspace' runs `py-empty-out-list-backward'
- py-flake8-run, flake8 API
- customizable `py-backslashed-lines-indent-offset'
- boolean `py-pylint-offer-current-p'
If current buffers file should be offered for check.
Otherwise `py-pylint-run' looks up filename from history
- boolean `py-prompt-on-changed-p'
When called interactively, ask for save before a
changed buffer is sent to interpreter.
- customizable `py-closing-list-space'
Number of chars, closing parentesis outdent from opening
- customizable `py-uncomment-indents-p'
When non-nil, after uncomment indent lines.
- boolean `py-load-skeletons-p'
If skeleton definitions should be loaded
- boolean `py-if-name-main-permission-p'
Allows execution of code inside blocks started by
if __name__== '__main__'
- boolean `py-highlight-error-source-p', default is nil
When py-execute-... commands raise an error, respective code in source-buffer will be highlighted.
- `py-remove-overlays-at-point', command
Remove overlays as set when `py-highlight-error-source-p' is non-nil.
- `py-which-def-or-class', command, now used `which-function-mode'
- unused variable `py-backspace-function' removed
- Bundled third-party-stuff removed as reported conflicting at emacs-mirror, lp:1153998
affects autopair.el, smart-operator.el
Kept menu switches resp. commands will issue a warning
- dropped `py-paragraph-fill-docstring-p'; just `fill-paragraph' should DTRT
- `py-set-pager-cat-p', default is nil
If non-nil, $PAGER is set to 'cat'
- in directory doc customizable variables are listed:
variables-python-mode.org, variables-python-mode.rst
New in version 6.1.1
---------------------
- comment-related commands:
py-uncomment
py-comment-block, py-comment-clause,
py-comment-block-or-clause, py-comment-def,
py-comment-class, py-comment-def-or-class,
py-comment-statement
- boolean `py-set-fill-column-p'
If `t', enables use Python specific `fill-column' according to
`py-docstring-fill-column', default is 72
and `py-comment-fill-column, default is 79
- boolean `py-tab-shifts-region-p'
when `t', TAB will indent/cycle the region, not just the current line.
- boolean `py-tab-indents-region-p'
when `t', when first TAB doesn't shift, `indent-region' is called
- command from RET customizable via `py-return-key':
`py-newline-and-indent', `newline' or `py-newline-and-dedent'
- boolean `py-use-font-lock-doc-face-p', default is nil
If non-nil, documention strings get `font-lock-doc-face'
- boolean `py-newline-delete-trailing-whitespace-p'
Delete trailing whitespace maybe left by `py-newline-and-indent'
- `py-electric-comment-p' new default nil
- py-up minor API change
If inside a delimited form --string or list-- go to it's beginning
If not at beginning of a statement or block, go to it's beginning
If at beginning of a statement or block, go to beginning one level above of c
- py-down minor API change:
Go to beginning of one level below of compound statement or definition at point.
If no statement or block below, but a delimited form --string or list-- go to it's beginning.
Repeated call from there will behave like down-list.
- commands make underscore syntax changes easier:
toggle-py-underscore-word-syntax-p
py-underscore-word-syntax-p-on
py-underscore-word-syntax-p-off
- py-update-imports removed
Do not maintain a static variable containing needed imports
Determine imports on the fly rather, as it might have changed
- variable `py-fill-docstring-style' renamed `py-docstring-style'
New in version 6.1.0
---------------------
- py-up
Go to beginning one level above of compound statement or definition at point.
- py-down
Go to beginning one level below of compound statement or definition at point.
- Customizable output directory
After checking for a remote shell, the following variables are consulted:
py-use-current-dir-when-execute-p, default t
When `t', current directory is used by Python-shell for output of `py-execute-buffer' and related commands
py-fileless-buffer-use-default-directory-p, default t
When `py-use-current-dir-when-execute-p' is non-nil and no buffer-file exists, value of `default-directory' sets current working directory of Python output shell"
py-keep-shell-dir-when-execute-p, default nil
Don't change Python shell's current working directory when sending code.
`py-execute-directory', default nil
If nothing was set so far, $VIRTUAL_ENV and $HOME are queried.
- Set of commands calling Python3.3
- fill docstrings according to style, commands
py-fill-string-django
py-fill-string-onetwo
py-fill-string-pep-257
py-fill-string-pep-257-nn
py-fill-string-symmetric
Customizable variable `py-fill-docstring-style' provides default value
used by `py-fill-string', `py-fill-paragraph'
DJANGO:
\"\"\"
Process foo, return bar.
\"\"\"
\"\"\"
Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
ONETWO:
\"\"\"Process foo, return bar.\"\"\"
\"\"\"
Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
PEP-257:
\"\"\"Process foo, return bar.\"\"\"
\"\"\"Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
PEP-257-NN:
\"\"\"Process foo, return bar.\"\"\"
\"\"\"Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\"
SYMMETRIC:
\"\"\"Process foo, return bar.\"\"\"
\"\"\"
Process foo, return bar.
If processing fails throw ProcessingError.
\"\"\""
Built upon code seen at python.el, thanks Fabian
- `py-down-statement', `py-up-statement'
- toggle-py-split-windows-on-execute-p
- py-split-windows-on-execute-p-off
- py-split-windows-on-execute-p-on
- toggle-py-switch-buffers-on-execute-p
- py-switch-buffers-on-execute-p-on
- py-switch-buffers-on-execute-p-off
- `py-shell-switch-buffers-on-execute-p' renamed `py-switch-buffers-on-execute-p'
New in version 6.0.12
---------------------
- py-sexp-function,
When set, it's value is called instead of `forward-sexp', `backward-sexp
Choices are py-partial-expression, py-expression, default nil
- `py-partial-expression' reconsidered.
Beside common moves like `defun', `statement' specific Python-mode edits are delivered:
`py-expression' and `py-partial-expression'.
Statement below is considered composed of two `py-expression'
a = ['spam', 'eggs', 100, 1234]
|_| |_________________________|
Assigment operator and all inside comments is ignored.
`py-partial-expression' would match six sections
a = ['spam', 'eggs', 100, 1234]
|_| |_____| |____| |__| |__|
|_________________________|
When traversing code, `py-partial-expression' climbs down and up
all levels encountered, i.e. at opening `[' `py-expression' would return ['spam', 'eggs', 100, 1234], while one char behind at `''
it yields `'spam','
- `py-find-definition' also detects non-imported definition in current buffer
- Choice between `py-imenu-create-index-new' and series 5.
py-imenu-create-index-function made easier.
Customizable variable `py-imenu-create-index-function' provided, see also
command in PyTools
- New commands addressing BOL as start/end:
py-beginning-of-block-bol
py-end-of-block-bol
py-mark-block-bol
py-copy-block-bol
py-kill-block-bol
py-delete-block-bol
py-end-of-clause-bol
etc.
- While commands "py-beginning..." resp. "py-end..." compute the context,
selecting the corresponding beginning or end,
new "py-up...", "py-down..." jump regexp-based to the
next element in buffer.
See also menu PyEdit.
New in version 6.0.11
---------------------
- improved Pymacs based code completion:
- Completion of symbols from imported modules, functions, classes,
module/class-level data members and instance variables in the current
buffer. The information for this completion is updated whenever the file
is saved.
- Completion of local variables and function parameters.
- Type deduction from constructor calls and literals.
- Show help for modules, classes and functions.
- Go to definition of modules, classes and functions.
- Show signature of functions.
- Support for auto-complete and company.
- remote shell support
- extended version of smart-operator added
original smart-operator.el authored by
William Xu
Url: http://xwl.appspot.com/ref/smart-operator.el
- py-electric-colon extended
if `py-electric-colon-newline-and-indent-p' is non-nil,
`py-electric-colon' calls `newline-and-indent'
- boolean `py-no-completion-calls-dabbrev-expand-p'
If completion function should call dabbrev-expand
when no completion found. Default is `t'
- boolean `py-shell-prompt-read-only', default t
sets `comint-prompt-read-only', avoid unintentional edits
- customizable history variables/files
py-python-history defaults to "~/.python_history"
py-ipython-history defaults to "~/.ipython/history"
If py-honor-PYTHONHISTORY-p is `t', $PYTHONHISTORY takes precedence, default is nil
If py-honor-IPYTHONDIR-p is `t', $IPYTHONHISTORY precedes, default is nil
- customizable boolean `py-trailing-whitespace-smart-delete-p'
Default is nil. Some commands may delete trailing
whitespaces by the way. When editing other peoples
code, this may produce a larger diff than expected
New in version 6.0.10
--------------------
addresses bugs and speed issues
New in version 6.0.9
--------------------
- autopair-mode delivered
Credits to Joao Tavora http://autopair.googlecode.com
see README-AUTOPAIR.org for details
- Syntax highlighting in Python-shell buffers enabled
boolean `py-fontify-shell-buffer-p', default is nil
- py-add-abbrev, new command
Similar to `add-mode-abbrev', but uses
`py-partial-expression' before point for expansion to
store, not `word'. Also provides a proposal for new
abbrevs.
Proposal for an abbrev is composed from the downcased
initials of expansion - provided they are of char-class
[:alpha:]
For example code below would be recognised as a
`py-expression' composed by three
py-partial-expressions.
OrderedDict.popitem(last=True)
Putting the curser at the EOL, M-3 M-x py-add-abbrev
would prompt "op" for an abbrev to store, as first
`py-partial-expression' beginns with a "(", which is
not taken as proposal.
- py-edit-abbrevs
Jumps to `python-mode-abbrev-table'
- modeline enhanced
when a path/to/my/favoured/Python is given with `py-shell-name'
the Python-shell buffer before would display
*ND path/to/my/favoured/Python*
now:
*ptmfP Python*
boolean `py-modeline-display-full-path-p'
boolean `py-modeline-acronym-display-home-p'
If the modeline acronym should contain chars indicating the home-directory.
- mode-line indicates "Py" by default
customize `python-mode-modeline-display'
- Pymacs intergration dropped from trunk
conflicts with classic install being reported
New in version 6.0.8
--------------------
- `py-pep8-run', new command checking formatting
`py-pep8-help'
- `py-pyflake-run', new command
Pyflakes is a simple program which checks Python
source files for errors. - It is similar to
PyChecker in scope, but differs in - that it does
not execute the modules to check them.
`py-pyflake-help'
- `py-pylint-run', new command calls Pylint,
a Python source code analyzer which looks for
programming errors, helps enforcing a coding standard
and sniffs for some code smells (as defined in Martin
Fowler's Refactoring book) .
Pylint checks length of lines of code, if variable
names are well-formed according to your coding
standard, if declared interfaces are truly
implemented, and much more. Additionally, it is
possible to write plugins.
`py-pylint-doku', `py-pylint-help'
- py-pyflakespep8-run, combines calls to pyflakes and pep8
- respective flymake-modes,
`pyflakespep8-flymake-mode', `pylint-flymake-mode'
etc. See meny PyTools
New in version 6.0.7
--------------------
- make every Python shell acces its own history-file
.python3_history
.python_history
.ipython_history etc.
- related to shell used
`toggle-force-py-shell-name-p'
`force-py-shell-name-p-on'/off
making it easier to enforce default py-shell upon execution
`toggle-force-local-shell'
`py-force-local-shell-on'/off
If locally indicated Python shell should be taken and
enforced upon sessions execute commands, lp:988091
- specific completion:
py-python2-shell-complete, py-python3-shell-complete,
py-python2-script-complete, py-python3-script-complete
New in version 6.0.6
--------------------
- files inside a virtual machine made visible for pdbtrack
- new commands `py-toggle-split-windows-on-execute', ...-on, ...-off
`py-toggle-shell-switch-buffers-on-execute', ...-on, ...-off
allow `py-execute-buffer' etc. to split/not-split windows,
move cursor onto output or not
- Behavior of C-u M-x `py-shell' closer to common shell
C-u 4 prompts for a buffer,
i.e. when a "*Python*" shell is running,
C-u M-x `py-shell' opens a "*Python<2>*" per default
C-u 2 M-x py-shell promts for command-arguments as known from 5th-series
- `py-intend-tabs-mode' sets default of `indent-tabs-mode', lp:953765
-- New boolean variable `py-intend-tabs-mode'
Permits value independent from Emacs-wide `indent-tabs-mode'
Commands `py-toggle-indent-tabs-mode', ...-on, ...-off
menu PyTools "Toggle indent-tabs-mode"
- Extended py-execute-... forms provided for "line"
- new commands py-beginning/end-of-line
while introduced for internal reasons --because of it's
return values-- they allow repeats, i.e. when already
at end-of-line, jumping to next end etc.
- new boolean `py-force-py-shell-name-p'
When `t', execution with Python specified in `py-shell-name' is en forced, shebang will have no effect. Default is nil.
- customizable `py-separator-char', a string, see report lp:975539
Precedes guessing when not empty, is returned by
function `py-separator-char'
- nicer `org-cycle' behavior: when new `py-org-cycle-p' it `t',
command `org-cycle' is available at shift-TAB,
New in version 6.0.5
--------------------
- Menu reworked and extended
- extended commands combine executing statement/block... with dedidi cated/switch... etc. This may remove some need of customization.
- local environments support started
If calls to common `py-shell' should use local executable
instead of default system Python set
`py-use-local-default' alongside with
`py-shell-local-path'
- `py-toggle-shells' alias of more powerful `py-switch-shells'
Toggles between the interpreter customized in `py-shell-toggle-1' resp. `py-shell-toggle-2'. Was hard-coded CPython and Jython in earlier versions, now starts with Python2 and Python3 by default.
- `py-shell-name' accepts PATH/TO/EXECUTABLE
in addition to name of an installed default Python-Shell.
Permits installing commands like
(defun python-XYZ-shell (&optional argprompt)
"Start an Python-XYZ interpreter ... "
(interactive)
(let ((py-shell-name "PATH/TO/PYTHON-XYZ"))
(py-shell argprompt)))
- new commands `indent-tabs-mode', `toggle-indent-tabs-mode',
`indent-tabs-mode-on', `indent-tabs-mode-off'
feature after a request at Stack Exchange asked Jul
13 '11 at 13:23 saying
`tab-width' now follows `py-indent-offset'
- new command `py-execute-region-default' forces the
systems default Python interpreter to execute, ignores
shebang
related functions redesigned, `async' argument dropped
`py-execute-region' now reads:
(defun py-execute-region (start end &optional shell dedicated)
"Send the region to a Python interpreter.
When called with \\[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
When called with \\[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.
When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument. "
[ ... ]
- new `py-number-face',
visible only when customized and `py-use-number-face-p' is `t',
inherits default face
With large files fontifying numbers may cause a delay
Credits to github.com/fgallina/python.el/issues42
- new boolean `py-verbose-p'
if `t', reached indent level etc. is messaged
- new commands py-execute-buffer-dedicated, py-execute-buffer-switch -dedicated
- `toggle-py-smart-indentation' new command
also `py-smart-indentation-on', -off
New in version 6.0.4
--------------------
- Python shell starts with `python-mode'
that's needed by completion for now
boolean customizable `py-start-run-py-shell'
- outline-(minor-)mode enabled providing regular
expressions. Customize `py-outline-minor-mode-p' to
switch it on with python-mode
- Hook delivered to start hs-minor-mode from python-mode
Customize `py-hide-show-minor-mode-p'
Key setting example:
(global-set-key [(super s)] 'hs-hide-all)
(global-set-key [(super S)] 'hs-show-all)
- Listing of available commands in org-mode and reST
format in directory "doc"
- Python shells and executing forms may be called as
dedicated process. See commands available \w suffix
"-dedicated".
- completion fixed: M-TAB completes in Python buffer, TAB
completes in Python shells
- py-down-FORM-lc commands
Goto beginning of line following end of FORM.
\"-lc\" stands for \"left-corner\" - a complementary command travelling left, whilst `py-end-of-FORM' stops at right corner.
Implemented forms are "block", "clause", "def", "class", "statement".
- py-down-FORM commands
like py-down-block introduced in version 6.0.3,
implemented also for "clause", "def", "class",
"statement".
Go to the beginning of next block below
current level.
New in version 6.0.3
--------------------
- ipython integration started
- commands `ipython', `python2', `python3', `jython', `python'
opening a respective python shell
- py-shift-block-left, py-shift-block-right etc.
Implemented forms that way are
"paragraph" "block" "clause" "def" "class" "line" "statement"
- py-dedent
Dedent line according to `py-indent-offset'. With
arg, do it that many times. If point is between
indent levels, dedent to next level. Stops at BOL.
Returns column reached, if dedent done, nil otherwise.
- py-indent-forward-line
Indent line and move one line forward. If
`py-kill-empty-line' is non-nil, delete an empty
line. When closing a form, use py-close-block et al,
which will move and indent likewise. Returns position.
- py-close-block, -clause, -def, class
Set indent level to that of beginning of definition.
If final line isn't empty and
`py-close-block-provides-newline' non-nil, insert a
newline. Returns column.
- new commands specifying the shell override
`py-shell-name' for execution
implemented shells are "python" "python2" "python2.7"
"python3" "python3.2" "jython"
available with default, -switch and -no-switch
option, i.e.
py-execute-region-python3.2
py-execute-region-python3.2-switch
py-execute-region-python3.2-no-switch etc.
Docstring of py-execute-region-python3.2-switch for
example: "Send the region to a common shell calling the
python3.2 interpreter. Ignores setting of
`py-shell-switch-buffers-on-execute', output-buffer
will being switched to."
- Declarations
Deal with assigments resp. statements in current
level which don't open blocks. Provides common edit
functions as copy, mark, kill, goto beg/end.
Functions will be used typically to grasp
initialisations resp. assignements of variables
between the definition of a class or method and it's
body, likewise global stuff at the head of a file.
- column-marker.el
Commands `column-marker-1', `column-marker-2', and
`column-marker-3' each highlight a given column
(using different background colors by default).
M-x column-marker-1 highlights the column where the
cursor is, in face `column-marker-1'.
C-u 70 M-x column-marker-2 highlights column 70 in
face `column-marker-2'.
C-u 70 M-x column-marker-3 highlights column 70 in
face `column-marker-3'. The face `column-marker-2'
highlighting no longer shows.
C-u M-x column-marker-3 turns off highlighting for
column-marker-3, so face `column-marker-2'
highlighting shows again for column 70.
C-u C-u M-x column-marker-1 (or -2 or -3) erases all
column highlighting.
;;
Thanks a lot to it's author Rick Bielawski ,
to Drew Adams for his care and Emacs Wiki hosting it.
New in version 6.0.2
--------------------
- py-electric-comment
"Insert a comment. If starting a comment, indent
accordingly. If a numeric argument ARG is provided,
that many colons are inserted non-electrically. With
universal-prefix-key C-u a \"#\" Electric behavior
is inhibited inside a string or comment."
- New commands `py-partial-expression':
"." operators delimit a partial-expression on it's
level.
Given the function below, `py-partial-expression'
called at pipe symbol would copy and return:
def usage():
print """Usage: %s
....""" % (
os.path.basename(sys.argv[0]))
------------|-------------------------
==> path
os.path.basename(sys.argv[0]))
------------------|-------------------
==> basename(sys.argv[0]))
os.path.basename(sys.argv[0]))
--------------------------|-----------
==> sys
os.path.basename(sys.argv[0]))
------------------------------|-------
==> argv[0]
while `py-expression' would copy and return
(
os.path.basename(sys.argv[0]))
;;;;;
Also for existing commands a shorthand is defined:
(defalias 'py-statement 'py-copy-statement)
which will mark, copy and return.
- Commands implementing a behavior which customizing of
`py-shell-switch-buffers-on-execute' would do:
py-execute-buffer-no-switch
py-execute-buffer-switch
py-execute-region-no-switch
py-execute-region-switch
- Several bugfixes.
New in version 6.0.1
--------------------
- New commands py-expression:
py-copy-expression
py-mark-expression
py-beginning-of-expression
py-end-of-expression
py-kill-expression
Also several of bugfixes are done.
New in version 6.0
--------------------
- Finer grained commands, core re-write.
As shown below for the `mark'-command, delete,
copy, jump to beginning and end of the respective
programming-expressions:
py-mark-statement
py-mark-block
py-mark-block-or-clause
py-mark-def
py-mark-def-or-class
py-mark-class
py-mark-clause
- Also a couple of bugfixes are done.
New in version 5.2.1
--------------------
- Syntax highlight as a keyword "lambda:" just like "lambda x:". Given by Dan
Davison.
- Add "python3" as a key for python-mode in interpreter-mode-alist and
auto-mode-alist.
New in version 5.2.0
--------------------
- Fixed filling of triple-quoted strings.
- Add new font-lock faces for class names and exception names.
- Do not fill when calling fill-paragraph with point in a region of code.
- Fixed font-locking of exception names in parenthesized lists.
- Fixed font-locking of decorators with arguments.
- Fixed font-locking of triple-quoted strings; single quotes appearing in
triple-quoted strings no longer upset font-locking.
- Fixed the stack-entry regexp used by pdbtrack so that it now works with
module-level frames.
- Do not bind C-c C-h; `py-help-at-point' is now on C-c C-e by default.
- hide-show mode is now supported.
- When shifting regions right and left, keep the region active in Emacs.
python-mode.el-6.2.3/INSTALL-INFO-FILES 0000644 0000000 0000000 00000001775 12660433546 016767 0 ustar root root 0000000 0000000 Wilfred Hughes provides a tool which seems to permit
building info docu for any Python version.
Source here:
http://github.com/wilfred/python-info
After unpacking, either follow the recipes in README.md
or, when aiming for an info of a different Python
version, edit the Makefile in directory build. Replace
the hard-coded Python-version by the one you need:
Worked nicely here with Python 3.3.0
This will create `build/python.texi`.
Afterwards run `makeinfo' at the texi-file.
In order to get them recognised by Emacs info-reader,
maybe copy the info-files into a known info-directory
and edit the "dir" file there - the head of newly
created info-files containes a line, which must appear
in file "dir".
At Linux that directory which keeps the info-files
should appear in $INFOPATH.
######
`info-lookup-symbol' needs patched python-info.el available at
http://bitbucket.org/andreas_roehler/pydoc-info
Thanks Jonathan Waltman providing the original python-info.el:
http://bitbucket.org/jonwaltman/pydoc-info
python-mode.el-6.2.3/PKG-INFO 0000644 0000000 0000000 00000000613 13037475064 015430 0 ustar root root 0000000 0000000 Metadata-Version: 1.1
Name: python-mode.el
Version: 6.2.3
Summary: Major mode for editing Python programs
Home-page: http://launchpad.net/python-mode
Author: python-mode.el developers
Author-email: andreas.roehler@online.de
License: GNU GPLv3, Python License
Download-URL: http://launchpad.net/python-mode/trunk/6.2.3/+download/python-mode.el-6.2.3.tar.gz
Description: UNKNOWN
Platform: UNKNOWN
python-mode.el-6.2.3/completion/ 0000755 0000000 0000000 00000000000 13037475064 016504 5 ustar root root 0000000 0000000 python-mode.el-6.2.3/completion/pycomplete.el 0000644 0000000 0000000 00000043020 12660433546 021206 0 ustar root root 0000000 0000000 ;;; Complete symbols at point using Pymacs.
;; Copyright (C) 2007 Skip Montanaro
;; Original Author: Skip Montanaro
;; Maintainer: Urs Fleisch
;; Created: Oct 2004
;; Keywords: python pymacs emacs
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;; Along with pycomplete.py this file allows programmers to complete Python
;; symbols within the current buffer. See pycomplete.py for the Python side
;; of things and a short description of what to expect.
;; BAW 2012-09-28: pymacs may not be installed on Debian.
(condition-case nil
(require 'pymacs)
(file-error nil))
(eval-when-compile (require 'cl))
(pymacs-load "pycomplete")
(defcustom py-complete-set-keymap-p nil
"If keys shall be defined when calling `py-complete-initialize'.
Default is nil.
See also `py-complete-set-keymap'"
:type 'boolean
:group 'python-mode)
(defvar py-complete-variable-index nil
"An alist with mappings of local variable names to types.")
(defvar py-complete-variable-index-position 0
"The line-beginning-position when py-complete-variable-index was last updated.
This can be used to skip updating the index when still on the same line.")
(defun py-complete-type-for-value (val)
"Return name of type for variable assignment value.
If the type cannot be deduced, nil is returned."
(let ((firstchar (string-to-char val))
(case-fold-search nil))
(cond
((or (equal 0 firstchar) (string= val "None")) nil)
((equal ?\[ firstchar) "list")
((equal ?{ firstchar) "dict")
((or (equal ?' firstchar) (equal ?\" firstchar)) "str")
((string-match "^[rR]['\"]" val) "str")
((string-match "^[uU][rR]?['\"]" val) "unicode")
((or (string= val "True") (string= val "False")) "bool")
((string-match "^[+\\-]?[0-9]+$" val) "int")
((string-match "^[+\\-]?[0-9]+[lL]$" val) "long")
((string-match "^[+\\-]?[0-9]+\\(?:\\.[0-9]+\\)?" val) "float")
((string-match "^\\(\\(?:[[:word:]\\.]+\\.\\)?_?[A-Z][A-Za-z0-9]+\\)($" val)
(match-string-no-properties 1 val))
((string= "(" (substring-no-properties val -1))
(concat "_PYCFRT(" (substring-no-properties val 0 -1) ")")))))
(defun py-complete-variables-in-def (&optional limit)
"Return an alist with mappings of local variable names to types.
Local variable assignments and parameters of the current function are
parsed. If limit is given, it limits the size of the returned alist."
(let ((pos (point))
(i 0)
(beg 0)
candidates
(variable-assignment-re (concat "^[ \t]+\\(\\w+\\)[ \t]*\\(?:=\\|+=\\|*=\\|%=\\|&=\\|^=\\|<<=\\|-=\\|/=\\|**=\\||=\\|>>=\\|//=\\)[ \t]*\\([({[]\\|[rRuU]*['\"]\\|[+\\-]?[[:word:].]+(?\\)")))
(save-excursion
;; First get the current def and its parameters
(py-backward-def)
(when (looking-at (concat py-def-re " *\\([^( ]+\\) *\\(([^:]+\\) *:"))
(setq beg (match-end 0))
(let ((params (replace-regexp-in-string
"[ )]+$" ""
(replace-regexp-in-string
"^[ (]+" ""
(match-string-no-properties 3)))))
(dolist (param (split-string params "[ \t\r\n]*,[ \t\r\n]*"))
;; Transform param into an assignment string
(setq param (concat " " param
(unless (memq ?= (string-to-list param))
"=None")))
(if (string-match variable-assignment-re param)
(push `(,(match-string-no-properties 1 param) .
,(py-complete-type-for-value (match-string-no-properties 2 param)))
candidates)))))
;; Search backward
(goto-char pos)
(while (and (or (not (integerp limit)) (< i limit))
(re-search-backward variable-assignment-re nil t)
(> (point) beg))
(let* ((candidate (match-string-no-properties 1))
(entry (assoc candidate candidates)))
(cond ((null entry)
(push `(,(match-string-no-properties 1) .
,(py-complete-type-for-value (match-string-no-properties 2)))
candidates)
(incf i))
((not (cdr entry))
(setcdr entry (py-complete-type-for-value (match-string-no-properties 2)))))))
(nreverse candidates))))
(defun py-complete-update-variable-index (&optional limit)
"Update py-complete-variable-index from the local variables of the current
function. An update is only performed if point was on a different line for
the last update. If limit is given, it limits the size of the index."
(unless (local-variable-p 'py-complete-variable-index)
(make-local-variable 'py-complete-variable-index))
(unless (local-variable-p 'py-complete-variable-index-position)
(make-local-variable 'py-complete-variable-index-position))
(let ((linebeg (line-beginning-position)))
(unless (eq linebeg py-complete-variable-index-position)
(setq py-complete-variable-index (py-complete-variables-in-def limit))
(setq py-complete-variable-index-position linebeg))))
(defun py-complete-variable-completions-for-symbol (sym)
"Get completions for local variables in current def.
If sym is an empty string, all local variables are returned,
else those starting with sym."
(when (and (stringp sym) (string-match "^\\w*$" sym))
(py-complete-update-variable-index)
(let ((symlen (length sym)))
(if (zerop symlen)
(mapcar 'car py-complete-variable-index)
(remove-if-not
#'(lambda (s) (and (>= (length s) symlen) (string= sym (substring s 0 symlen))))
(mapcar 'car py-complete-variable-index))))))
(defun py-complete-which-class ()
"Return current class name based on point.
If no class name is found, return nil."
(interactive)
(let (classname)
(save-excursion
(save-restriction
(py-backward-class)
(when (looking-at (concat py-class-re " *\\([^( ]+\\)"))
(setq classname (match-string-no-properties 2))
(if (interactive-p)
(message "%s" classname)))))
classname))
(defun py-complete-type-before-dotexpr (&optional pos)
"Get type for expression before dot expression.
The character after pos (point if omitted) must be a dot.
Returns list, str or dict if such an expression is before
the dot, else nil."
(let ((dotchar (char-after pos)))
(if (and dotchar (char-equal ?. dotchar))
(save-excursion
(if pos
(goto-char pos))
(cond
((looking-back "\\(\\[\\|,[^[]*\\)\\]") "list")
((looking-back "['\"]") "str")
((looking-back "}") "dict"))))))
(defun py-complete-substitute-type-for-var (word)
"Substitute the type for the variable starting the dot-expression word.
Returns the word with replaced variable if known, else the unchanged word."
(let* (type
(firstsym (car (split-string word "\\.")))
(firstlen (length firstsym)))
(if (string= firstsym "self")
(setq type (py-complete-which-class))
(py-complete-update-variable-index)
(setq type (cdr (assoc firstsym py-complete-variable-index))))
(if (stringp type)
(concat type (substring word firstlen))
word)))
(defun py-complete-python-dotexpr-begin nil
(re-search-backward "[^a-zA-Z_0-9\\.]")
(forward-char))
(defun py-complete-python-dotexpr-end nil
(re-search-forward "[a-zA-Z_0-9\\.]*"))
(put 'python-dotexpr 'beginning-op 'py-complete-python-dotexpr-begin)
(put 'python-dotexpr 'end-op 'py-complete-python-dotexpr-end)
(defun py-complete-enhanced-dotexpr-at-point ()
"Enhanced (thing-at-point 'python-dotexpr).
The returned word starts with a type if an expression is found before the dot
or if the dot-expression starts with a variable for which the type is known."
(require 'thingatpt)
(let ((bounds (bounds-of-thing-at-point 'python-dotexpr)))
(if bounds
(let* ((beg (car bounds))
(end (cdr bounds))
(word (buffer-substring-no-properties beg end))
(prefix (py-complete-type-before-dotexpr beg)))
(if prefix
(concat prefix word)
(py-complete-substitute-type-for-var word))))))
(defun py-complete-enhanced-symbol-before-point ()
"Return the dotted python symbol before point.
The returned word starts with a type if an expression is found before the dot
or if the dot-expression starts with a variable for which the type is known."
(let* (prefix
(word (buffer-substring-no-properties
(save-excursion
(skip-chars-backward "a-zA-Z0-9_.")
(setq prefix (py-complete-type-before-dotexpr))
(point))
(point))))
(if prefix
(concat prefix word)
(py-complete-substitute-type-for-var word))))
;; Not used anymore
(defun py-find-global-imports ()
"Find Python import statements in buffer."
(save-excursion
(let (first-class-or-def imports)
(goto-char (point-min))
(setq first-class-or-def
(re-search-forward "^ *\\(def\\|class\\) " nil t))
(goto-char (point-min))
(setq imports nil)
(while (re-search-forward
"^\\(import \\|from \\([A-Za-z_\\.][A-Za-z_0-9\\.]*\\) import \\).*"
first-class-or-def t)
(setq imports (cons (buffer-substring-no-properties
(match-beginning 0)
(match-end 0))
imports)))
(nreverse imports))))
(defun py-complete ()
"Complete symbol before point using Pymacs. "
(interactive)
(setq py-last-window-configuration
(current-window-configuration))
(let ((symbol (py-complete-enhanced-symbol-before-point)))
(if (string= "" symbol)
(tab-to-tab-stop)
(let ((completions
(py-complete-completions-for-symbol symbol)))
(if completions
(let* (completion
(lastsym (car (last (split-string symbol "\\."))))
(lastlen (length lastsym)))
(cond ((null (cdr completions))
(setq completion (car completions)))
(t
(setq completion (try-completion lastsym completions))
(message "Making completion list...")
(with-output-to-temp-buffer "*PythonCompletions*"
(display-completion-list completions))
(message "Making completion list...%s" "done")))
(when (and (stringp completion)
(> (length completion) lastlen))
(insert (substring completion lastlen))))
(message "Can't find completion for \"%s\"" symbol)
(ding))))))
(defun py-complete-completions-for-symbol (sym &optional imports)
"Get possible completions for symbol using statements given in imports."
(let ((pymacs-forget-mutability t))
(append
(py-complete-variable-completions-for-symbol sym)
(pycomplete-pycompletions
sym (buffer-file-name)
imports))))
(defun py-complete-docstring-for-symbol (sym &optional imports)
"Get docstring for symbol using statements given in imports."
(let ((pymacs-forget-mutability t))
(pycomplete-pydocstring
sym (buffer-file-name)
imports)))
(defun py-complete-completions ()
"Get possible completions for current statement."
(py-complete-completions-for-symbol
(py-complete-enhanced-symbol-before-point)))
(defun py-complete-completion-at-point ()
"Return a (start end collection) list, so that this function
can be used as a hook for completion-at-point-functions."
(setq py-last-window-configuration
(current-window-configuration))
(let ((symbol (py-complete-enhanced-symbol-before-point)))
(when (not (string= "" symbol))
(let ((completions (py-complete-completions-for-symbol symbol)))
(when completions
(when (> (length completions) 1)
;; this-command is changed to avoid the following situation:
;; This function is invoked via indent-for-tab-command (because
;; tab-always-indent is complete) and there is a "Complete, but
;; not unique" case (e.g. "for" is completed and the next TAB key
;; press shall display a list with "for", "format"). In such a
;; case, py-indent-line would detect a repeated indentation
;; request and thus change the indentation. The changed
;; indentation would then prevent indent-for-tab-command
;; from calling the completion function.
(setq this-command 'py-complete-completion-at-point))
(list (- (point) (length (car (last (split-string symbol "\\.")))))
(point)
completions))))))
(defun py-complete-show (string)
(display-message-or-buffer string "*PythonHelp*"))
(defun py-complete-help (string)
"get help on a python expression"
(interactive "sHelp: ")
(let* ((pymacs-forget-mutability t)
(help-string
(pycomplete-pyhelp string (buffer-file-name))))
(if (and help-string (> (length help-string) 300))
(with-output-to-temp-buffer "*Python Help*"
(princ help-string))
(py-complete-show help-string))))
(defun py-complete-help-thing-at-point nil
(interactive)
(let ((sym (py-complete-enhanced-dotexpr-at-point)))
(if sym
(py-complete-help sym))))
(set 'py-complete-current-signature nil)
(defun py-complete-signature (function)
"get signature of a python function or method"
(let ((pymacs-forget-mutability t))
(set 'py-complete-current-signature
(pycomplete-pysignature function (buffer-file-name)))))
(defun py-complete-signature-show nil
(let ((sym (py-complete-enhanced-dotexpr-at-point)))
(if sym
(progn
(py-complete-show (py-complete-signature sym))))))
(defun py-complete-signature-expr nil
(interactive)
(let ((dotexpr (read-string "signature on: "
(py-complete-enhanced-dotexpr-at-point))))
(if dotexpr
(py-complete-show
(py-complete-signature dotexpr)))))
(defun py-complete-electric-lparen nil
"electricly insert '(', and try to get a signature for the stuff to the left"
(interactive)
(py-complete-signature-show)
(self-insert-command 1))
(defun py-complete-electric-comma nil
"electricly insert ',', and redisplay latest signature"
(interactive)
(self-insert-command 1)
(if py-complete-current-signature
(py-complete-show (format "%s" py-complete-current-signature))))
(defun py-complete-location (sym)
"Get definition location of sym in cons form (FILE . LINE)."
(let ((location (pycomplete-pylocation sym (buffer-file-name))))
(when (and location (vectorp location) (= (length location) 2))
(cons (aref location 0) (aref location 1)))))
(defun py-complete-goto-definition nil
"Got to definition of Python function."
(interactive)
(let ((sym (py-complete-enhanced-dotexpr-at-point)))
(if sym
(let ((location
(pycomplete-pylocation sym (buffer-file-name))))
(if (and location (vectorp location) (= (length location) 2))
(progn
(find-file (aref location 0))
(goto-line (aref location 1)))
(message "Cannot find the definition!"))))))
(defun py-complete-parse-source ()
"Parse source code of Python file to get imports and completions."
(let ((errstr (pycomplete-pyparse (buffer-file-name) t)))
(if errstr
(message "%s" errstr))))
(defun py-complete-set-keymap ()
"Define key map with pycomplete functions."
(interactive)
(define-key python-mode-map [C-tab] 'py-complete)
(define-key python-mode-map [f1] 'py-complete-help-thing-at-point)
(define-key python-mode-map "(" 'py-complete-electric-lparen)
(define-key python-mode-map "," 'py-complete-electric-comma)
(define-key python-mode-map [S-f1] 'py-complete-signature-expr)
(define-key python-mode-map [f2] 'py-complete-goto-definition)
(define-key python-mode-map [f3] 'py-complete-help))
(defun py-complete-initialize ()
"Initialize pycomplete hooks.
Should be called from python-mode-hook. Keys are set when
`py-complete-set-keymap-p' is non-nil."
(interactive)
(when py-set-complete-keymap-p
(py-complete-set-keymap))
(when py-complete-set-keymap-p
(py-complete-set-keymap))
;; Parse source file after it is saved
(add-hook 'after-save-hook 'py-complete-parse-source nil 'local)
;; Set up auto-complete or company if enabled
(cond
((fboundp 'auto-complete-mode)
(require 'auto-complete-pycomplete)
(setq ac-sources
(if (boundp 'py-complete-ac-sources)
py-complete-ac-sources
'(ac-source-pycomplete))))
((fboundp 'company-mode)
(company-mode t)
(require 'company-pycomplete)
(set (make-local-variable 'company-backends)
'((company-pycomplete))))
((or py-set-complete-keymap-p py-complete-set-keymap-p)
(set (make-local-variable 'tab-always-indent) 'complete)
(define-key python-mode-map [tab] 'indent-for-tab-command))))
(provide 'pycomplete)
python-mode.el-6.2.3/completion/company-pycomplete.el 0000644 0000000 0000000 00000005473 12660433546 022664 0 ustar root root 0000000 0000000 ;;; company-pycomplete.el --- a company-mode completion back-end for pycomplete.el
;; Copyright (C) 2012 Urs Fleisch
;; Author: Urs Fleisch
;; Keywords: languages, processes, python, oop
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;; The backend can be enabled using
;; (setq company-backends '((company-pycomplete)))
;;; Code:
(require 'pycomplete)
(require 'company)
(defun company-pycomplete--grab-symbol ()
;; stolen from company-pysmell--grab-symbol
(let ((symbol (company-grab-symbol)))
(when symbol
(cons symbol
(save-excursion
(let ((pos (point)))
(goto-char (- (point) (length symbol)))
(while (eq (char-before) ?.)
(goto-char (1- (point)))
(skip-syntax-backward "w_"))
(- pos (point))))))))
(defun company-pycomplete-doc-buffer (candidate)
"Return buffer with docstring of CANDIDATE if it is available."
(let* ((full-prefix (py-complete-enhanced-symbol-before-point))
(full-symbol (concat full-prefix (company-strip-prefix candidate)))
(doc (py-complete-docstring-for-symbol full-symbol)))
(when (and (stringp doc) (> (length doc) 0))
(with-current-buffer (company-doc-buffer)
(insert doc)
(current-buffer)))))
(defun company-pycomplete-location (candidate)
"Return location of CANDIDATE in cons form (FILE . LINE) if it is available."
(let* ((full-prefix (py-complete-enhanced-symbol-before-point))
(full-symbol (concat full-prefix (company-strip-prefix candidate))))
(py-complete-location full-symbol)))
(defun company-pycomplete (command &optional arg &rest ignored)
"A `company-mode' completion back-end for pycomplete."
(interactive (list 'interactive))
(case command
('interactive (company-begin-backend 'company-pycomplete))
('prefix (and (derived-mode-p 'python-mode)
(not (company-in-string-or-comment))
(company-pycomplete--grab-symbol)))
('candidates (py-complete-completions))
('doc-buffer (company-pycomplete-doc-buffer arg))
('location (company-pycomplete-location arg))))
(provide 'company-pycomplete)
;;; company-pycomplete.el ends here
python-mode.el-6.2.3/completion/test_pycomplete.py 0000644 0000000 0000000 00000022237 12660433546 022304 0 ustar root root 0000000 0000000 #!/usr/bin/env python
import os, sys
import linecache
import tempfile
from pycomplete import *
def test_signature():
assert pysignature('') == ''
assert pysignature('os.path.join') == 'join: (a, *p)'
assert pysignature('json.dump').startswith(
'dump: (obj, fp, skipkeys=False, ensure_ascii=True, ')
assert pysignature('json.JSONEncoder.encode') == 'encode: (self, o)'
assert pysignature('json.JSONEncoder').startswith(
'__init__: (self, skipkeys=False, ensure_ascii=True, ')
assert pysignature('xml.dom.minidom.parse') == \
'parse: (file, parser=None, bufsize=None)'
assert pysignature('csv.reader') == \
'csv_reader = reader(iterable [, dialect=\'excel\']'
assert pysignature('super') in (
'super(type) -> unbound super object',
'super() -> same as super(__class__, )',
'super(type, obj) -> bound super object; requires isinstance(obj, type)')
def test_help():
assert pyhelp('os.path.join').startswith('Help on function join')
assert pyhelp('logging', imports=('import logging',)).startswith(
'Help on package logging:\n\nNAME\n logging\n')
assert pyhelp('csv', imports=('import csv',)).startswith(
'Help on module csv:\n\nNAME\n csv - CSV parsing and writing.\n')
assert pyhelp('import').startswith(
('The ``import`` statement\n************************\n',
'The "import" statement\n**********************\n'))
assert pyhelp('pydoc.help').startswith(
'Help on class Helper in module pydoc')
assert pyhelp('') == ''
def test_complete():
assert pycomplete('') == ''
assert pycomplete('sys.getd') == ['getdefaultencoding', 'getdlopenflags']
assert pycomplete('set') == ['set', 'setattr']
assert pycomplete('settr') is None
assert pycomplete('settr', imports=['from sys import settrace']) == [
'ace']
# Test with cached imports
assert pycomplete('settr') == ['ace']
# Not cached for other files
fpath = os.path.abspath(__file__)
assert pycomplete('settr', fname=fpath) is None
assert pycomplete('settr', fname=fpath,
imports=['from sys import settrace']) == ['ace']
assert pycomplete('foo.') is None
assert pycomplete('JSONEnc') is None
assert pycomplete('JSONEnc', imports=['from json import *']) == ['oder']
assert pycomplete('A') == [
'ArithmeticError', 'AssertionError', 'AttributeError']
def test_completions():
all_completions = pycompletions('')
assert all_completions[0] == 'ArithmeticError'
assert all_completions[-1] == 'zip'
assert pycompletions('os.path.jo') == ['join']
assert pycompletions('settr', imports=['']) == []
assert pycompletions('settr',
imports=['from sys import settrace']) == ['settrace']
# Check if imports are still cached.
assert pycompletions('settr', imports=None) == ['settrace']
# Change list of imports, so that cache is invalidated.
assert pycompletions('settr', imports=['']) == []
def test_location():
fn, line = pylocation('os.path.join')
assert os.path.exists(fn)
assert linecache.getline(fn, line).startswith('def join')
assert pylocation('io.StringIO') is None
fn, line = pylocation('json')
assert os.path.exists(fn)
assert pylocation('for') is None
def test_docstring():
assert pydocstring('os.path.abspath') == 'Return an absolute path.'
assert pydocstring('os.path').startswith(
'Common operations on Posix pathnames.\n')
assert pydocstring('json.JSONEncoder.encode').startswith(
'Return a JSON string representation of a Python data structure.\n')
assert pydocstring('yield') == ''
assert pydocstring('numbers.Real.real') == \
'Real numbers are their real component.'
assert pydocstring('notexisting') == ''
assert pydocstring('re.IGNORECASE') == ''
def test_parse_source():
tmp_file = tempfile.NamedTemporaryFile(suffix='.py', mode='w')
name = tmp_file.name
with tmp_file.file as fh:
assert pyparse('not_existing', only_reload=True) == None
assert pyparse('not_existing') == \
"[Errno 2] No such file or directory: 'not_existing'"
assert pyparse(name) is None
# Nothing imported so far
assert pycompletions('dat' , name) == []
src = """
"Doc for module."
from __future__ import print_function
import sys, os, io, re
from datetime import date, \
time
import argparse
if os.getenv('LC'):
import linecache
modvar = 1
mod_re = re.compile(r'^test')
def testfunc():
"Doc for testfunc."
import urllib
def emptyfunc():
"Function with only docstring."
class TestClass(date):
"Doc for TestClass."
CONST1 = 7
CONST2 = 'abc'
CONST3 = ['a', ]
def __init__(self):
self._member1 = 'string member'
self._member2 = None
self.__member3 = [ None, open('not_existing') ]
self.member4 = argparse.ArgumentParser()
self.member4 = None
self.member5 = open('not_existing')
self.member6 = self.member7 = { 'multiple': 'targets' }
self.member8, self.member9 = 'tuple', 'assignment'
self.member10 = [ n for n in range(3) ]
self.member11 = SyntaxError()
self.member12 = testfunc()
def testmeth(self, arg1=modvar):
"Doc for testmeth."
sys.stdout.write('From testmeth %d' % arg1)
if arg1 == 2:
self._member1 = None
@staticmethod
def teststaticmeth(arg1=2):
"Doc for teststaticmeth."
sys.stdout.write('From teststaticmeth %d' % arg1)
@classmethod
def testclassmeth(cls, arg1=3):
"Doc for testclassmeth."
open('not_existing')
@property
def testprop(self):
"Doc for testprop."
return 4 * 8
if __name__ == '__main__':
testfunc()
"""
num_src_lines = len(src.splitlines())
fh.write(src)
fh.flush()
assert pyparse(name) == None
# Check if only global imports are visible
assert pycompletions('dat' , name) == ['date']
assert pycompletions('tim' , name) == ['time']
assert pycompletions('url' , name) == []
assert pycompletions('line' , name) == ['linecache']
assert pycompletions('os' , name) == ['os']
# Check for definitions in local file
assert pycompletions('test' , name) == ['testfunc']
assert pycompletions('TestClass.CO' , name) == \
['CONST1', 'CONST2', 'CONST3']
assert pycompletions('TestClass.test' , name) == \
['testclassmeth', 'testmeth', 'testprop', 'teststaticmeth']
# Check for instance members
assert pycompletions('TestClass._mem', name) == \
['_member1', '_member2']
assert pycompletions('TestClass.__mem', name) == ['__member3']
assert pycompletions('TestClass._member1.start', name) == \
['startswith']
assert pycompletions('TestClass._member2.', name) == []
assert pycompletions('TestClass.__member3.ext', name) == \
['extend']
if sys.version_info[0] < 3:
assert pycompletions('TestClass.member4.prin', name) == \
['print_help', 'print_usage', 'print_version']
assert pycompletions('TestClass.member5.writel', name) == \
['writelines']
assert pycompletions('TestClass.member6.from', name) == \
['fromkeys']
assert pycompletions('TestClass.member7.from', name) == \
['fromkeys']
assert pycompletions('TestClass.member10.ext', name) == \
['extend']
assert pycompletions('TestClass.member11.ar', name) == \
['args']
assert pycompletions('modvar.num', name) == ['numerator']
assert pycompletions('mod_re.ma', name) == ['match']
assert pydocstring('TestClass._member1', name) == ''
assert pydocstring('TestClass._member2', name) == ''
assert pydocstring('TestClass.__member3', name) == ''
# Check for super class
assert pycompletions('TestClass.week' , name) == ['weekday']
assert pycompletions('TestClass.utc' , name) == []
# Check signature, documentation and location
assert pysignature('TestClass.testmeth', name) == \
'testmeth: (self, arg1=1)'
assert pydocstring('testfunc', name) == \
'Doc for testfunc.'
assert pylocation('TestClass.testclassmeth', name) == \
(name, num_src_lines - 10)
# Verify that loaded symbols are not affected by transient
# syntax error
fh.write('while')
fh.flush()
assert pyparse(name) == \
'invalid syntax (%s, line %d)' % (os.path.basename(name),
num_src_lines + 1)
assert pycompletions('dat' , name) == ['date']
# Replace file contents and check new imports
fh.seek(0)
fh.truncate(0)
fh.write('import urllib\n')
fh.flush()
assert pyparse(name) == None
assert pycompletions('dat' , name) == []
assert pycompletions('url' , name) == ['urllib']
def run_tests():
test_complete()
test_completions()
test_help()
test_signature()
test_location()
test_docstring()
test_parse_source()
if __name__ == "__main__":
run_tests()
python-mode.el-6.2.3/completion/pycomplete.py 0000644 0000000 0000000 00000073471 12660433546 021253 0 ustar root root 0000000 0000000 """
Python dot expression completion using Pymacs.
This almost certainly needs work, but if you add
(require 'pycomplete)
to your init.el file and have Pymacs installed, when you hit M-TAB it will
try to complete the dot expression before point. For example, given this
import at the top of the file:
import time
typing "time.cl" then hitting M-TAB should complete "time.clock".
This is unlikely to be done the way Emacs completion ought to be done, but
it's a start. Perhaps someone with more Emacs mojo can take this stuff and
do it right.
See pycomplete.el for the Emacs Lisp side of things.
Most of the public functions in this module have the signature
(s, fname=None, imports=None)
where s is the symbol to complete, fname is the file path and imports
the list of import statements to use. The fname parameter is used as a
key to cache the global and local context and the symbols imported or
evaluated so far. The cache for an fname is cleared when its imports
are changed. When not passing a list of imports (or None), the currently
used imports are preserved. The caching should make subsequent operations
(e.g. another completion or signature lookup after a completion) less
expensive.
"""
# Original Author: Skip Montanaro
# Maintainer: Urs Fleisch
# Created: Oct 2004
# Keywords: python pymacs emacs
# This software is provided as-is, without express or implied warranty.
# Permission to use, copy, modify, distribute or sell this software, without
# fee, for any purpose and by any individual or organization, is hereby
# granted, provided that the above copyright notice and this paragraph
# appear in all copies.
# Along with pycomplete.el this file allows programmers to complete Python
# symbols within the current buffer.
import sys
import types
import inspect
import keyword
import os
import pydoc
import ast
import re
if sys.version_info[0] >= 3: # Python 3
import io
else: # Python 2
import StringIO
try:
x = set
except NameError:
from sets import Set as set
else:
del x
class _PyCompleteDocument(object):
"""Completion data for Python source file."""
if sys.version_info[0] >= 3: # Python 3
_helpout = io.StringIO
@staticmethod
def is_num_or_str(obj):
return isinstance(obj, (int, float, str))
@staticmethod
def is_class_type(obj):
return type(obj) == type
@staticmethod
def get_unbound_function(unbound):
return unbound
@staticmethod
def get_method_function(meth):
return meth.__func__
@staticmethod
def get_function_code(func):
return func.__code__
@staticmethod
def update_with_builtins(keys):
import builtins
keys.update(dir(builtins))
else: # Python 2
_helpout = StringIO.StringIO
@staticmethod
def is_num_or_str(obj):
return isinstance(obj, (int, long, float, basestring))
@staticmethod
def is_class_type(obj):
return type(obj) in (types.ClassType, types.TypeType)
@staticmethod
def get_unbound_function(unbound):
return unbound.im_func
@staticmethod
def get_method_function(meth):
return meth.im_func
@staticmethod
def get_function_code(func):
return func.func_code
@staticmethod
def update_with_builtins(keys):
import __builtin__
keys.update(dir(__builtin__))
_sre_SRE_Pattern = type(re.compile(''))
_sre_SRE_Match = type(re.match('', ''))
# Class name in CapCase, as suggested by PEP8 Python style guide
_class_name_re = re.compile(r'(?:^|\.)_?[A-Z][A-Za-z0-9]+$')
_return_type_of_func = {
'bin': 'str',
'bytearray': 'bytearray',
'bytes': 'bytes',
'compile': 'types.CodeType',
'complex': 'complex',
'dict': 'dict',
'frozenset': 'frozenset',
'oct': 'str',
'open': 'io.BufferedIOBase' if sys.version_info[0] >= 3 else 'file',
'list': 'list',
'repr': 'str',
'set': 'set',
'sorted': 'list',
'str': 'str',
'tuple': 'tuple',
'vars': 'dict',
're.compile': '_PyCompleteDocument._sre_SRE_Pattern',
're.escape': 'str',
're.findall': 'list',
're.match': '_PyCompleteDocument._sre_SRE_Match',
're.search': '_PyCompleteDocument._sre_SRE_Match',
're.split': 'list',
're.sub': 'str',
're.subn': 'tuple',
'datetime.datetime': 'datetime.datetime',
'datetime.date': 'datetime.date',
'datetime.time': 'datetime.time',
'datetime.timedelta': 'datetime.timedelta',
'sys.exc_info': 'tuple',
'os.getcwd': 'str',
'os.getenv': 'str',
'os.urandom': 'bytes',
'os.path.abspath': 'str',
'os.path.basename': 'str',
'os.path.commonprefix': 'str',
'os.path.dirname': 'str',
'os.path.expanduser': 'str',
'os.path.expandvars': 'str',
'os.path.join': 'str',
'os.path.normcase': 'str',
'os.path.normpath': 'str',
'os.path.realpath': 'str',
'os.path.relpath': 'str',
'os.path.split': 'tuple',
'os.path.splitdrive': 'tuple',
'os.path.splitext': 'tuple',
'collections.defaultdict': 'collections.defaultdict',
'collections.deque': 'collections.deque',
'collections.namedtuple': 'collections.namedtuple',
'socket.socket': 'socket.socket',
'csv.excel': 'csv.excel',
'csv.excel_tab': 'csv.excel_tab'
}
@staticmethod
def _get_type_for_function(funcname):
typename = _PyCompleteDocument._return_type_of_func.get(funcname)
if not typename and \
_PyCompleteDocument._class_name_re.search(funcname):
typename = funcname
return typename
@staticmethod
def _replace_pycfrt_with_typename(s):
"""Replace _PYCFRT(..) expressions with function return type.
The names of variables assigned from function calls can be replaced by
_PYCFRT(name.of.function). This function tries to replace such expressions
with the corresponding function return type (PYCFRT = pycomplete function
return type). If no such expression can be found, s is returned unchanged.
If the type cannot be deduced, None is returned, else the substituted
string."""
pycfrt_re = re.compile(r'_PYCFRT\(([^()]+)\)')
return pycfrt_re.sub(lambda m: _PyCompleteDocument._get_type_for_function(m.group(1)), s)
class ImportExtractor(ast.NodeVisitor):
"""NodeVisitor to extract the top-level import statements from an AST.
To generate code containing all imports in try-except statements,
call get_import_code(node), where node is a parsed AST.
"""
def visit_FunctionDef(self, node):
# Ignore imports inside functions or methods.
pass
def visit_ClassDef(self, node):
# Ignore imports inside classes.
pass
def generic_visit(self, node):
# Store import statement nodes.
if isinstance(node, (ast.Import, ast.ImportFrom)):
self._import_nodes.append(node)
ast.NodeVisitor.generic_visit(self, node)
def get_import_code(self, node, fname=''):
"""Get compiled code of all top-level import statements found in the
AST of node."""
self._import_nodes = []
self.visit(node)
body = []
for imp_node in self._import_nodes:
if isinstance(imp_node, ast.ImportFrom) and \
imp_node.module == '__future__':
# 'SyntaxError: from __future__ imports must occur at the
# beginning of the file' is raised if a 'from __future__ import'
# is wrapped in try-except, so use only the import statement.
body.append(imp_node)
else:
if sys.version_info[0] >= 3: # Python 3
body.append(ast.Try(body=[imp_node], handlers=[
ast.ExceptHandler(type=None, name=None, body=[ast.Pass()])],
orelse=[], finalbody=[]))
else:
body.append(ast.TryExcept(body=[imp_node], handlers=[
ast.ExceptHandler(type=None, name=None, body=[ast.Pass()])],
orelse=[]))
node = ast.Module(body=body)
ast.fix_missing_locations(node)
code = compile(node, fname, 'exec')
return code
class CodeRemover(ast.NodeTransformer):
"""NodeTransformer which replaces function statements with 'pass'
and keeps only safe assignments, so that the resulting code can
be used for code completion.
To reduce the code from the node of a parsed AST, call
get_transformed_code(node).
"""
def visit_FunctionDef(self, node):
# Replace all function statements except doc string by 'pass'.
if node.body:
if isinstance(node.body[0], ast.Expr) and \
isinstance(node.body[0].value, ast.Str):
# Keep doc string.
first_stmt = node.body[1] if len(node.body) > 1 else node.body[0]
node.body = [node.body[0]]
else:
first_stmt = node.body[0]
node.body = []
node.body.append(ast.copy_location(ast.Pass(), first_stmt))
return node
return None
def visit_Expr(self, node):
# Remove all expressions except strings to keep doc strings.
if isinstance(node.value, ast.Str):
return node
return None
@staticmethod
def _get_type_node_for_function_node(node):
# Convert node to dot expression
attrs = []
while isinstance(node, ast.Attribute):
attrs.insert(0, node.attr)
node = node.value
if isinstance(node, ast.Name):
attrs.insert(0, node.id)
funcname = '.'.join(attrs)
typename = _PyCompleteDocument._get_type_for_function(funcname)
if typename:
# Convert dot expression to node
attrs = typename.split('.')
node = None
if attrs:
node = ast.Name(id=attrs.pop(0), ctx=ast.Load())
while attrs:
node = ast.Attribute(value=node, attr=attrs.pop(0),
ctx=ast.Load())
return node
return None
@staticmethod
def replace_unsafe_value(node, replace_self=None):
"""Modify value from assignment if unsafe.
If replace_self is given, only assignments starting with 'self.' are
processed, the assignment node is returned with 'self.' replaced by
the value of replace_self (typically the class name).
For other assignments, None is returned."""
for i, target in enumerate(node.targets):
if not isinstance(target, (ast.Name, ast.Attribute)):
# Only process assignments to names and attributes,
# not tuples.
return None
if replace_self:
if isinstance(target, ast.Attribute) and \
isinstance(target.value, ast.Name) and \
target.value.id == 'self' and \
isinstance(target.value.ctx, ast.Load):
node.targets[i].value.id = replace_self
if target.attr == '__name__':
node.value = ast.copy_location(ast.Str(s=''),
node.value)
elif target.attr in ('__dict__', '__class__', '__bases__',
'__doc__'):
return None
else:
return None
elif isinstance(target, ast.Name) and \
isinstance(target.ctx, ast.Store):
if target.id == '__metaclass__':
# Do not modify __metaclass__ assignments
return node
elif target.id == '__slots__':
node.value = ast.copy_location(
ast.List(elts=[], ctx=ast.Load()), node.value)
if isinstance(node.value, (ast.Str, ast.Num)):
pass
elif isinstance(node.value, (ast.List, ast.Tuple)):
node.value.elts = []
elif isinstance(node.value, ast.Dict):
node.value.keys = []
node.value.values = []
elif isinstance(node.value, ast.ListComp):
node.value = ast.copy_location(ast.List(elts=[], ctx=ast.Load()), node.value)
elif isinstance(node.value, ast.Call):
type_node = _PyCompleteDocument.CodeRemover._get_type_node_for_function_node(node.value.func)
if type_node:
# Wrap class lookup in try-except because it is not fail-safe.
node.value = ast.copy_location(type_node, node.value)
if sys.version_info[0] >= 3: # Python 3
node = ast.copy_location(ast.Try(body=[node], handlers=[
ast.ExceptHandler(type=None, name=None, body=[ast.Pass()])],
orelse=[], finalbody=[]), node)
else:
node = ast.copy_location(ast.TryExcept(body=[node], handlers=[
ast.ExceptHandler(type=None, name=None, body=[ast.Pass()])],
orelse=[]), node)
ast.fix_missing_locations(node)
else:
node.value = ast.copy_location(
ast.Name(id='None', ctx=ast.Load()), node.value)
else:
node.value = ast.copy_location(ast.Name(id='None', ctx=ast.Load()), node.value)
return node
def visit_Assign(self, node):
# Replace unsafe values of assignements by None.
return self.replace_unsafe_value(node)
def visit_Name(self, node):
# Pass names for bases in ClassDef.
return node
def visit_Attribute(self, node):
# Pass attributes for bases in ClassDef.
return node
def visit_ClassDef(self, node):
# Visit nodes of class.
# Store instance member assignments to be added later to generated code.
self_assignments = {}
for child in ast.walk(node):
if isinstance(child, ast.Assign):
new_child = self.replace_unsafe_value(child,
replace_self=node.name)
if new_child:
new_var = child.targets[0].attr
old_assign = self_assignments.get(new_var)
if not old_assign or (
isinstance(old_assign, ast.Assign) and
isinstance(old_assign.value, ast.Name) and
old_assign.value.id == 'None'):
self_assignments[new_var] = new_child
self._class_assignments.extend(list(self_assignments.values()))
return ast.NodeTransformer.generic_visit(self, node)
def visit_Module(self, node):
# Visit nodes of module
return ast.NodeTransformer.generic_visit(self, node)
def generic_visit(self, node):
# Remove everything which is not handled by the methods above
return None
def get_transformed_code(self, node, fname=''):
"""Get compiled code containing only empty functions and methods
and safe assignments found in the AST of node."""
self._class_assignments = []
node = self.visit(node)
# The self members are added as attributes to the class objects
# rather than included as class variables inside the class definition
# so that names starting with '__' are not mangled.
node.body.extend(self._class_assignments)
code = compile(node, fname, 'exec')
return code
_stdout = sys.stdout
_instances = {}
def __init__(self, fname=None):
"""Constructor for internal use.
The factory method instance() shall be used instead.
"""
self._fname = fname
self._imports = None
self._globald = globals().copy()
self._symnames = []
self._symobjs = {}
self._parse_source_called = False
@classmethod
def instance(cls, fname):
"""Get _PyCompleteDocument object for fname.
If no object for this file name exists, a new object is created and
registered.
"""
obj = cls._instances.get(fname)
if obj is None:
obj = _PyCompleteDocument(fname)
cls._instances[fname] = obj
return obj
def _import_modules(self, imports):
"""Import modules using the statements in imports.
If the imports are the same as in the last call, the methods
immediately returns, also if imports is None.
"""
if imports is None and not self._parse_source_called:
self.parse_source()
if imports is None or imports == self._imports:
return
# changes to where the file is
if self._fname:
os.chdir(os.path.dirname(self._fname))
self._globald = globals().copy()
self._symnames = []
self._symobjs = {}
for stmt in imports:
try:
exec(stmt, self._globald)
except TypeError:
raise TypeError('invalid type: %s' % stmt)
except Exception:
continue
self._imports = imports
def _collect_symbol_names(self):
"""Collect the global, local, builtin symbols in _symnames.
If _symnames is already set, the method immediately returns.
"""
if not self._symnames:
keys = set(keyword.kwlist)
keys.update(list(self._globald.keys()))
self.update_with_builtins(keys)
self._symnames = list(keys)
self._symnames.sort()
def _get_symbol_object(self, s):
"""Get a symbol by evaluating its name or importing a module
or submodule with the name s.
"""
sym = self._symobjs.get(s)
if sym is not None:
return sym
# changes to where the file is
if self._fname:
os.chdir(os.path.dirname(self._fname))
try:
sym = eval(s, self._globald)
except NameError:
try:
sym = __import__(s, self._globald)
self._globald[s] = sym
except ImportError:
pass
except AttributeError:
try:
sym = __import__(s, self._globald)
except ImportError:
pass
except SyntaxError:
pass
if sym is not None:
self._symobjs[s] = sym
return sym
def _load_symbol(self, s, strict=False):
"""Get a symbol for a dotted expression.
Returns the last successfully found symbol object in the
dotted chain. If strict is set True, it returns True as
soon as a symbol is not found. Therefore strict=True can
be used to find exactly the symbol for s, otherwise a
symbol for a parent can be returned, which may be enough
if searching for help on symbol.
"""
s = self._replace_pycfrt_with_typename(s)
sym = self._symobjs.get(s)
if sym is not None:
return sym
dots = s.split('.')
if not s or len(dots) == 1:
sym = self._get_symbol_object(s)
else:
for i in range(1, len(dots) + 1):
s = '.'.join(dots[:i])
if not s:
continue
sym_i = self._get_symbol_object(s)
if sym_i is not None:
sym = sym_i
elif strict:
return None
return sym
def _get_help(self, s, imports=None):
"""Return string printed by help function."""
if not s:
return ''
if s == 'pydoc.help':
# Prevent pydoc from going into interactive mode
s = 'pydoc.Helper'
obj = None
if not keyword.iskeyword(s):
try:
self._import_modules(imports)
obj = self._load_symbol(s, strict=False)
except Exception as ex:
return '%s' % ex
if not obj:
obj = str(s)
out = self._helpout()
try:
sys.stdout = out
pydoc.help(obj)
finally:
sys.stdout = self._stdout
return out.getvalue()
@staticmethod
def _find_constructor(class_ob):
"""Given a class object, return a function object used for the
constructor (ie, __init__() ) or None if we can't find one."""
try:
return _PyCompleteDocument.get_unbound_function(class_ob.__init__)
except AttributeError:
for base in class_ob.__bases__:
rc = _PyCompleteDocument._find_constructor(base)
if rc is not None:
return rc
return None
def get_all_completions(self, s, imports=None):
"""Return contextual completion of s (string of >= zero chars).
If given, imports is a list of import statements to be executed
first.
"""
self._import_modules(imports)
s = self._replace_pycfrt_with_typename(s)
last_dot_pos = s.rfind('.')
if last_dot_pos == -1:
self._collect_symbol_names()
if s:
return [k for k in self._symnames if k.startswith(s)]
else:
return self._symnames
sym = self._load_symbol(s[:last_dot_pos], strict=True)
if sym is not None:
s = s[last_dot_pos + 1:]
return [k for k in dir(sym) if k.startswith(s)]
return []
def complete(self, s, imports=None):
"""Complete symbol if unique, else return list of completions."""
if not s:
return ''
completions = self.get_all_completions(s, imports)
if len(completions) == 0:
return None
else:
dots = s.split(".")
prefix = os.path.commonprefix([k for k in completions])
if len(completions) == 1 or len(prefix) > len(dots[-1]):
return [prefix[len(dots[-1]):]]
return completions
def help(self, s, imports=None):
"""Return help on object."""
try:
return self._get_help(s, imports)
except Exception as ex:
return '%s' % ex
def get_docstring(self, s, imports=None):
"""Return docstring for symbol s."""
if s and not keyword.iskeyword(s):
try:
self._import_modules(imports)
obj = self._load_symbol(s, strict=True)
if obj and not self.is_num_or_str(obj):
doc = inspect.getdoc(obj)
if doc:
return doc
except:
pass
return ''
def get_signature(self, s, imports=None):
"""Return info about function parameters."""
if not s or keyword.iskeyword(s):
return ''
obj = None
sig = ""
try:
self._import_modules(imports)
obj = self._load_symbol(s, strict=False)
except Exception as ex:
return '%s' % ex
if self.is_class_type(obj):
# Look for the highest __init__ in the class chain.
ctr = self._find_constructor(obj)
if ctr is not None and type(ctr) in (
types.MethodType, types.FunctionType, types.LambdaType):
obj = ctr
elif type(obj) == types.MethodType:
# bit of a hack for methods - turn it into a function
# but we drop the "self" param.
obj = self.get_method_function(obj)
if type(obj) in [types.FunctionType, types.LambdaType]:
try:
(args, varargs, varkw, defaults) = inspect.getargspec(obj)
sig = ('%s: %s' % (obj.__name__,
inspect.formatargspec(args, varargs, varkw,
defaults)))
except ValueError:
try:
(args, varargs, varkw, defaults, kwonlyargs,
kwonlydefaults, annotations) = inspect.getfullargspec(obj)
sig = ('%s: %s' % (
obj.__name__, inspect.formatargspec(
args, varargs, varkw, defaults, kwonlyargs,
kwonlydefaults, annotations)))
except AttributeError:
pass
doc = getattr(obj, '__doc__', '')
if doc and not sig:
doc = doc.lstrip()
pos = doc.find('\n')
if pos < 0 or pos > 70:
pos = 70
sig = doc[:pos]
return sig
def get_location(self, s, imports=None):
"""Return file path and line number of symbol, None if not found."""
if not s or keyword.iskeyword(s):
return None
try:
self._import_modules(imports)
obj = self._load_symbol(s, strict=False)
if obj is not None:
if self.is_class_type(obj):
obj = obj.__init__
if type(obj) == types.MethodType:
obj = self.get_method_function(obj)
if type(obj) in [types.FunctionType, types.LambdaType]:
code = self.get_function_code(obj)
return (os.path.abspath(code.co_filename), code.co_firstlineno)
# If not found, try using inspect.
return (inspect.getsourcefile(obj), inspect.getsourcelines(obj)[1])
except:
pass
return None
def parse_source(self, only_reload=False):
"""Parse source code to get imports and completions.
If this method is called, the imports parameter for the other methods
must be omitted (or None), so that the imports are taken from the
parsed source code. If only_reload is True, the source is only parsed
if it has been parsed before.
None is returned if OK, else a string describing the error.
"""
if only_reload and not self._parse_source_called:
return None
self._parse_source_called = True
if not self._fname:
return None
try:
with open(self._fname) as fh:
src = fh.read()
except IOError as ex:
return '%s' % ex
# changes to where the file is
os.chdir(os.path.dirname(self._fname))
try:
node = ast.parse(src, self._fname)
import_code = self.ImportExtractor().get_import_code(node, self._fname)
except (SyntaxError, TypeError) as ex:
return '%s' % ex
old_globald = self._globald.copy()
self._globald = globals().copy()
try:
exec(import_code, self._globald)
except Exception as ex:
self._globald = old_globald
return '%s' % ex
self._symnames = []
self._symobjs = {}
reduced_code = self.CodeRemover().get_transformed_code(node, self._fname)
try:
exec(reduced_code, self._globald)
except Exception as ex:
return '%s' % ex
return None
def pycompletions(s, fname=None, imports=None):
"""Get a list of possible completions for s.
The completions extend the expression s after the last dot.
"""
return _PyCompleteDocument.instance(fname).get_all_completions(
s, imports)
def pycomplete(s, fname=None, imports=None):
"""Complete the Python expression s.
If multiple completions are found, a list of possible completions
(names after the last dot) is returned.
If one completion is found, a list with a string containing the
remaining characters is returned.
If no completion is found, None is returned.
"""
return _PyCompleteDocument.instance(fname).complete(s, imports)
def pyhelp(s, fname=None, imports=None):
"""Return help on object s."""
return _PyCompleteDocument.instance(fname).help(s, imports)
def pydocstring(s, fname=None, imports=None):
"""Return docstring of symbol."""
return _PyCompleteDocument.instance(fname).get_docstring(s, imports)
def pysignature(s, fname=None, imports=None):
"""Return info about function parameters."""
return _PyCompleteDocument.instance(fname).get_signature(s, imports)
def pylocation(s, fname=None, imports=None):
"""Return file path and line number of symbol, None if not found."""
return _PyCompleteDocument.instance(fname).get_location(s, imports)
def pyparse(fname, only_reload=False):
"""Parse source code to get imports and completions.
If this function is called, the imports parameter for the other functions
must be omitted (or None), so that the imports are taken from the
parsed source code. If only_reload is True, the source is only parsed if
it has been parsed before.
"""
return _PyCompleteDocument.instance(fname).parse_source(only_reload)
# Local Variables :
# pymacs-auto-reload : t
# End :
python-mode.el-6.2.3/completion/auto-complete-pycomplete.el 0000644 0000000 0000000 00000003221 12660433546 023761 0 ustar root root 0000000 0000000 ;;; auto-complete-pycomplete.el --- an auto-complete source for pycomplete.el
;; Copyright (C) 2012 Urs Fleisch
;; Author: Urs Fleisch
;; Keywords: languages, processes, python, oop
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;; The ac-source can be enabled solely using
;; (setq ac-sources '(ac-source-pycomplete))
;; or before the other sources using
;; (add-to-list 'ac-sources 'ac-source-pycomplete).
;;; Code:
(require 'pycomplete)
(require 'auto-complete)
(defun ac-pycomplete-document (symbol)
(let* ((full-prefix (py-complete-enhanced-symbol-before-point))
(full-symbol (concat (substring full-prefix 0 (- (length ac-prefix))) symbol)))
(py-complete-docstring-for-symbol full-symbol)))
(defun ac-pycomplete-candidates ()
(py-complete-completions-for-symbol
(py-complete-enhanced-symbol-before-point)))
(ac-define-source pycomplete
'((candidates . ac-pycomplete-candidates)
(document . ac-pycomplete-document)))
(provide 'auto-complete-pycomplete)
;;; auto-complete-pycomplete.el ends here
python-mode.el-6.2.3/setup.py 0000600 0000000 0000000 00000000756 13037472717 016047 0 ustar root root 0000000 0000000 #! /usr/bin/env python
# -*- coding: utf-8 -*-
from distutils.core import setup
setup(name='python-mode.el',
version='6.2.3',
url='http://launchpad.net/python-mode',
maintainer_email='andreas.roehler@online.de',
maintainer='python-mode.el developers',
description='Major mode for editing Python programs',
download_url='http://launchpad.net/python-mode/trunk/6.2.3/+download/python-mode.el-6.2.3.tar.gz',
license='GNU GPLv3, Python License',
)
python-mode.el-6.2.3/test/ 0000755 0000000 0000000 00000000000 13037475064 015312 5 ustar root root 0000000 0000000 python-mode.el-6.2.3/test/py-ert-forward-tests.el 0000644 0000000 0000000 00000021322 13005712272 021644 0 ustar root root 0000000 0000000 ;;; py-ert-forward-tests.el --- Just some more tests
;; Copyright (C) 2015-2016 Andreas Röhler
;; Author: Andreas Röhler
;; Keywords: languages, convenience
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;; This file is generated by function from python-mode-utils.el - see in
;; directory devel. Edits here might not be persistent.
;;; Code:
;;This file is generated by function from python-mode-utils.el - see in
;; directory devel. Edits here might not be persistent.
(ert-deftest py-ert-forward-block-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "if")
(py-forward-block)
(should (eq (char-before) ?s))))
(ert-deftest py-ert-forward-block-or-clause-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "elif")
(py-forward-block-or-clause)
(should (eq (char-before) ?s))))
(ert-deftest py-ert-forward-class-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "if")
(py-forward-class)
(should (eq (char-before) ?2))))
(ert-deftest py-ert-forward-clause-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "elif")
(py-forward-clause)
(should (eq (char-before) ?s))))
(ert-deftest py-ert-forward-def-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "if")
(py-forward-def)
(should (eq (char-before) ?2))))
(ert-deftest py-ert-forward-def-or-class-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "if")
(py-forward-def-or-class)
(should (eq (char-before) ?2))))
(ert-deftest py-ert-forward-elif-block-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "elif")
(py-forward-elif-block)
(should (eq (char-before) ?s))))
(ert-deftest py-ert-forward-else-block-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "else")
(py-forward-else-block)
(should (eq (char-before) ?s))))
(ert-deftest py-ert-forward-except-block-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "except")
(py-forward-except-block)
(should (eq (char-before) ?2))))
(ert-deftest py-ert-forward-expression-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "if")
(py-forward-expression)
(should (eq (char-before) ?:))))
(ert-deftest py-ert-forward-for-block-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "for")
(py-forward-for-block)
(should (eq (char-before) ?)))))
(ert-deftest py-ert-forward-if-block-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "if")
(py-forward-if-block)
(should (eq (char-before) ?s))))
(ert-deftest py-ert-forward-minor-block-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "if")
(py-forward-minor-block)
(should (eq (char-before) ?s))))
(ert-deftest py-ert-forward-partial-expression-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "Python")
(py-forward-partial-expression)
(should (eq (char-before) ?n))))
(ert-deftest py-ert-forward-section-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "if")
(py-forward-section)
(should (eq (char-before) ?}))))
(ert-deftest py-ert-forward-statement-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "if")
(py-forward-statement)
(should (eq (char-before) ?:))))
(ert-deftest py-ert-forward-top-level-test ()
(py-test-with-temp-buffer-point-min
py-forward-text
(search-forward "if")
(py-forward-top-level)
(should (eq (char-before) ?2))))
(ert-deftest py-ert-forward-try-block-test ()
(py-test-with-temp-buffer
py-up-text
(goto-char (point-min))
(search-forward "try")
(py-forward-try-block)
(should (eq (char-before) ?1))))
(ert-deftest py-ert-forward-block-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in b:
pass
except:
block2
"
(goto-char 103)
(py-forward-block-bol)
(should (eq (point) 140))))
(ert-deftest py-ert-forward-clause-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in b:
pass
except:
block2
"
(goto-char 103)
(py-forward-clause-bol)
(should (bolp))))
(ert-deftest py-ert-forward-block-or-clause-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in b:
pass
except:
block2
"
(goto-char 103)
(py-forward-block-or-clause-bol)
(should (eq (point) 140))))
(ert-deftest py-ert-forward-def-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in b:
pass
except:
block2
"
(goto-char 103)
(py-forward-def-bol)
(should (eq (point) 175))))
(ert-deftest py-ert-forward-class-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in b:
pass
except:
block2
"
(goto-char 103)
(py-forward-class-bol)
(should (eq (point) 175))))
(ert-deftest py-ert-forward-def-or-class-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in b:
pass
except:
block2
"
(goto-char 103)
(py-forward-def-or-class-bol)
(should (eq (point) 175))))
(ert-deftest py-ert-forward-if-block-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in b:
pass
except:
block2
"
(goto-char 103)
(py-forward-if-block-bol)
(should (eq (point) 140))))
(ert-deftest py-ert-forward-try-block-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in b:
pass
except:
block2
"
(goto-char 103)
(py-forward-try-block-bol)
(should (eq (point) 140))))
(ert-deftest py-ert-forward-minor-block-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in b:
pass
except:
block2
"
(goto-char 103)
(py-forward-minor-block-bol)
(should (eq (point) 140))))
(ert-deftest py-ert-forward-for-block-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in b:
pass
except:
block2
"
(goto-char 103)
(py-forward-for-block-bol)
(should (eq (point) 140))))
(ert-deftest py-ert-forward-top-level-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in b:
pass
except:
block2
"
(goto-char 103)
(py-forward-top-level-bol)
(should (eq (point) 175))))
(ert-deftest py-ert-forward-statement-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in b:
pass
except:
block2
"
(goto-char 103)
(py-forward-statement-bol)
(should (eq (point) 115))))
(provide 'py-ert-forward-tests)
;;; py-ert-forward-tests.el ends here
python-mode.el-6.2.3/test/py-ert-execute-block-test.el 0000644 0000000 0000000 00000004740 13011652223 022550 0 ustar root root 0000000 0000000 ;;; py-ert-execute-block-test.el --- py-execute-block tests
;; Copyright (C) 2015 Andreas Röhler
;; Author: Andreas Röhler
;; Keywords: languages, convenience
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;; This file is generated by function from python-mode-utils.el - see in
;; directory devel. Edits here might not be persistent.
;;; Code:
(ert-deftest py-ert-execute-block-python-test ()
(let ((buffer (py--choose-buffer-name "python")))
(py-test-with-temp-buffer
"if True:
print(\"one\")
print(\"two\")"
(py-execute-block-python)
(set-buffer buffer)
(should (search-backward "two")))))
(ert-deftest py-ert-execute-block-python2-test ()
(let ((buffer (py--choose-buffer-name "python2")))
(py-test-with-temp-buffer
"if True:
print(\"one\")
print(\"two\")"
(py-execute-block-python2)
(set-buffer buffer)
(should (search-backward "two")))))
(ert-deftest py-ert-execute-block-python3-test ()
(let ((buffer (py--choose-buffer-name "python3")))
(py-test-with-temp-buffer
"if True:
print(\"one\")
print(\"two\")"
(py-execute-block-python3)
(set-buffer buffer)
(should (search-backward "two")))))
(ert-deftest py-ert-execute-block-ipython-test ()
(let ((buffer (py--choose-buffer-name "ipython")))
(py-test-with-temp-buffer
"if True:
print(\"one\")
print(\"two\")"
(py-execute-block-ipython)
(set-buffer buffer)
(should (search-backward "two")))))
(ert-deftest py-ert-execute-block-ipython3-test ()
(let ((buffer (py--choose-buffer-name "ipython3")))
(py-test-with-temp-buffer
"if True:
print(\"one\")
print(\"two\")"
(py-execute-block-ipython3)
(set-buffer buffer)
(should (search-backward "two")))))
(provide 'py-ert-execute-block-test)
;;; py-ert-execute-block-test.el here
python-mode.el-6.2.3/test/py-ert-tests-1.el 0000644 0000000 0000000 00000107670 13035634070 020355 0 ustar root root 0000000 0000000 ;; py-ert-tests.el --- Tests, some adapted from python.el -*- lexical-binding: t; -*-
;; Copyright (C) 2013 Free Software Foundation, Inc.
;; Copyright (C) 2014-2015 Andreas Röhler,
;; 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 .
;;; Commentary:
;;; Code:
;; (require 'ert)
;; tests are expected to run from directory test
(defvar py-def-and-class-test-string "class kugel(object):
zeit = time.strftime('%Y%m%d--%H-%M-%S')
# zeit = time.strftime('%Y-%m-%d--%H-%M-%S')
spiel = []
gruen = [0]
rot = [1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36]
def pylauf(self):
\"\"\"Eine Doku fuer pylauf\"\"\"
ausgabe = [\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \", \" \"]
ausgabe[0] = treffer
fertig = ''
# print \"treffer, schwarz, gruen, rot, pair, impair, passe, manque, spiel\"
if treffer in gruen:
# print \"0, Gruen\"
ausgabe[1] = treffer
ausgabe[2] = treffer
elif treffer in schwarz:
# print \"%i, Schwarz\" % (treffer)
ausgabe[1] = treffer
if __name__ == \"__main__\":
main()
")
(setq ert-test-default-buffer "*Python*")
(add-to-list 'load-path default-directory)
(ert-deftest py-ert-electric-kill-backward-bracket-test ()
(let ((py-electric-kill-backward-p t))
(py-test-with-temp-buffer
"mystring[0:1]"
(py-electric-backspace 1)
(should (eq ?\] (char-after))))))
(ert-deftest py-ert-electric-kill-backward-region-test ()
(let ((py-electric-kill-backward-p t)
(delete-active-region t)
(transient-mark-mode t))
(py-test-with-temp-buffer
"mystring[0:1] "
(skip-chars-backward " \t\r\n\f")
(set-mark (point))
(goto-char (point-max))
(py-electric-backspace 1)
(should (eq ?\] (char-before))))))
(ert-deftest py-ert-electric-delete-eob-test ()
(let ((py-electric-kill-backward-p t)
(delete-active-region t)
(transient-mark-mode t))
(py-test-with-temp-buffer
"mystring[0:1] "
(skip-chars-backward " \t")
(set-mark (point))
(skip-chars-forward " \t")
(py-electric-delete)
(should (eobp)))))
(ert-deftest py-ert-electric-delete-test ()
(let ((py-electric-kill-backward-p t)
(delete-active-region t)
(transient-mark-mode t))
(py-test-with-temp-buffer
"mystring[0:1] "
(set-mark (point))
(skip-chars-backward " \t\r\n\f")
(py-electric-delete)
(should (eobp)))))
(ert-deftest py-ert-electric-kill-backward-paren-test ()
(let ((py-electric-kill-backward-p t))
(py-test-with-temp-buffer
"mystring(\"asdf\")"
(py-electric-backspace 1)
(should (eq ?\) (char-after)))
)))
(ert-deftest py-ert-electric-kill-backward-brace-test ()
(let ((py-electric-kill-backward-p t))
(py-test-with-temp-buffer
"mystring{0 . 1}"
(py-electric-backspace 1)
(should (eq ?\} (char-after))))))
(ert-deftest py-ert-indent-dedenters-1 ()
"Check all dedenters."
(py-test-with-temp-buffer-point-min
"
def foo(a, b, c):
if a:
print (a)
elif b:
print (b)
else:
try:
print (c.pop())
except (IndexError, AttributeError):
print (c)
finally:
print ('nor a, nor b are true')
"
(search-forward "if a:")
(should (= (py-compute-indentation) 4))
(search-forward "print (a)")
(should (= (py-compute-indentation) 8))
(search-forward "elif b:")
(should (= (py-compute-indentation) 4))
(search-forward "print (b)")
(should (= (py-compute-indentation) 8))
(search-forward "else:")
(should (= (py-compute-indentation) 4))
(search-forward "try:")
(should (= (py-compute-indentation) 8))
(search-forward "print (c.pop())")
(should (= (py-compute-indentation) 12))
(search-forward "except (IndexError, AttributeError):")
(should (= (py-compute-indentation) 8))
(search-forward "print (c)")
(should (= (py-compute-indentation) 12))
(search-forward "finally:")
(should (= (py-compute-indentation) 8))
(search-forward "print ('nor a, nor b are true')")
(should (= (py-compute-indentation) 12))))
(ert-deftest py-ert-indent-after-backslash-lp-852052-1 ()
"The most common case."
(py-test-with-temp-buffer-point-min
"
from foo.bar.baz import something, something_1 \\
something_2 something_3, \\
something_4, something_5
"
(search-forward "from foo.bar.baz import something, something_1")
(should (= (py-compute-indentation) 0))
(search-forward "something_2 something_3,")
(should (= (py-compute-indentation) 5))
(search-forward "something_4, something_5")
(should (= (py-compute-indentation) 5))))
(ert-deftest py-ert-indent-closing ()
""
(py-test-with-temp-buffer-point-min
"
my_list = [
1, 2, 3,
4, 5, 6,
]
result = some_function_that_takes_arguments(
'a', 'b', 'c',
'd', 'e', 'f',
)
"
(goto-char 40)
(should (eq 4 (py-compute-indentation)))
(goto-char 129)
(should (eq 4 (py-compute-indentation)))))
(setq py-ert-moves-text "class OrderedDict1(dict):
\"\"\"
This implementation of a dictionary keeps track of the order
in which keys were inserted.
\"\"\"
def __init__(self, d={}):
self._keys = d.keys()
dict.__init__(self, d)
def f():
\"\"\"
class for in 'for in while with blah'
\"\"\"
if a:
ar_atpt_python_list_roh = ([
'python-expression',
# def ar_thingatpt_write_lists (&optional datei):
'python-partial-expression',
'python-statement',
])
elif b:
pass
else b:
pass
''' asdf' asdf asdf asdf asdf asdfasdf asdfasdf a asdf asdf asdf asdfasdfa asdf asdf asdf asdf asdf' asdf asdf asdf asdf asdfasdf asdfasdf a asdf asdf asdf asdfasdfa asdf asdf asdf asdf
'''
")
(ert-deftest py-ert-moves-up-class-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(should (eq 1 (py-up-class-bol)))))
(ert-deftest py-ert-moves-up-def-or-class-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(py-up-def-or-class)
(should (looking-at "class"))))
(ert-deftest py-ert-moves-up-minor-block-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(py-up-minor-block-bol)
(should (bobp))))
(ert-deftest py-ert-moves-up-block-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(py-up-block-bol)
(should (looking-at " +def f():"))))
(ert-deftest py-ert-moves-up-block-2 ()
(py-test-with-temp-buffer
py-ert-moves-text
(search-backward "pass")
(py-up-block)
(should (looking-at "def f():"))))
(ert-deftest py-ert-moves-up-minor-block-bol-2 ()
(py-test-with-temp-buffer
"class OrderedDict1(dict):
\"\"\"
This implementation of a dictionary keeps track of the order
in which keys were inserted.
\"\"\"
def __init__(self, d={}):
self._keys = d.keys()
dict.__init__(self, d)
def f():
\"\"\"
class for in 'for in while with blah'
\"\"\"
if a:
# if c
if b:
pass
"
(py-up-minor-block)
(should (looking-at "if a:"))))
(ert-deftest py-ert-moves-up-block-bol-2 ()
(py-test-with-temp-buffer
py-ert-moves-text
(search-backward "pass")
(py-up-block-bol)
(should (looking-at " +def f"))))
(ert-deftest py-ert-moves-up-def-bol-2 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(py-up-def-bol)
(should (bobp))))
(ert-deftest py-ert-moves-up-class-bol-2 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(should (eq 1 (py-up-class)))))
(ert-deftest py-ert-moves-up-def-or-class-bol-2 ()
(py-test-with-temp-buffer
py-ert-moves-text
(search-backward "pass")
(py-up-def-or-class)
(should (looking-at "class"))))
(ert-deftest py-ert-moves-down-block-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 264)
(py-down-block-bol)
(should (bolp))))
(ert-deftest py-ert-moves-down-def-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char (point-min))
(should (eq 142 (py-down-def-bol)))))
(ert-deftest py-ert-down-class-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(should (not (py-down-class-bol)))))
(ert-deftest py-ert-moves-down-def-or-class-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char (point-min))
(should (eq 142 (py-down-def-or-class-bol)))))
(ert-deftest py-ert-moves-down-block-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 264)
(py-down-block)
(should (looking-at "if"))))
(ert-deftest py-ert-moves-down-block-bol-2 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 264)
(py-down-block-bol)
(should (looking-at "^ +if"))))
(ert-deftest py-ert-moves-down-minor-block-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 264)
(should (eq 325 (py-down-minor-block)))))
(ert-deftest py-ert-moves-down-minor-block-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 264)
(should (eq 317 (py-down-minor-block-bol)))))
(ert-deftest py-ert-moves-down-def-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char (point-min))
(should (eq 146 (py-down-def)))))
(ert-deftest py-ert-moves-down-class-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(should (not (py-down-class)))))
(ert-deftest py-ert-moves-down-def-or-class-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char (point-min))
(should (eq 146 (py-down-def-or-class)))))
(ert-deftest py-ert-moves-backward-statement-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(should (eq 332 (py-backward-statement-bol)))))
(ert-deftest py-ert-moves-backward-block-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(indent-to 8)
(should (eq 317 (py-backward-block-bol)))))
(ert-deftest py-ert-moves-backward-clause-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(indent-to 8)
(should (eq 317 (py-backward-clause-bol)))))
(ert-deftest py-ert-moves-backward-block-or-clause-bol-1 ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(indent-to 8)
(should (eq 317 (py-backward-block-or-clause-bol)))))
(ert-deftest py-ert-moves-backward-class-bol ()
(py-test-with-temp-buffer
py-ert-moves-text
(should (eq 1 (py-backward-class-bol)))))
(ert-deftest py-ert-moves-backward-def-or-class-bol ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 410)
(indent-to 4)
(py-backward-def-or-class-bol)
(should (looking-at "^ +def"))))
(ert-deftest py-ert-moves-forward-clause-bol ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 576)
(should (eq 594 (py-forward-clause-bol)))))
(ert-deftest py-ert-moves-forward-block-or-clause-bol ()
(py-test-with-temp-buffer-point-min
py-ert-moves-text
(goto-char 576)
(should (eq 594 (py-forward-block-or-clause-bol)))))
(ert-deftest py-ert-moves-up-position-tests-4 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "else:")
(should (eq 190 (py--beginning-of-minor-block-position)))))
(ert-deftest py-ert-moves-up-position-tests-5 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "else:")
(end-of-line)
(should (eq 362 (py--beginning-of-clause-position)))))
(ert-deftest py-ert-moves-up-position-tests-6 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "else:")
(should (eq 362 (py--beginning-of-clause-position)))))
(ert-deftest py-ert-moves-up-position-tests-7 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "else:")
(should (eq 445 (py--end-of-clause-position)))))
(ert-deftest py-ert-moves-up-position-tests-8 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "else:")
(end-of-line)
(should (eq 362 (py--beginning-of-block-or-clause-position)))))
(ert-deftest py-ert-moves-up-position-tests-9 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "else:")
(should (eq 445 (py--end-of-block-or-clause-position)))))
(ert-deftest py-ert-moves-up-position-tests-10 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "se:")
(should (eq 445 (py--end-of-block-or-clause-position)))))
(ert-deftest py-ert-moves-up-position-tests-11 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "se:")
(should (eq 71 (py--beginning-of-def-position)))))
(ert-deftest py-ert-moves-up-position-tests-12 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "self")
(end-of-line)
(py-forward-statement)
(should (eq (char-before) ?\]))))
(ert-deftest py-ert-moves-up-position-tests-13 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "se:")
(should (eq 445 (py--end-of-def-position)))))
(ert-deftest py-ert-moves-up-position-tests-14 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "se:")
(should (eq 1 (py--beginning-of-class-position)))))
(ert-deftest py-ert-moves-up-position-tests-15 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "se:")
(should (eq 445 (py--end-of-class-position)))))
(ert-deftest py-ert-moves-up-position-tests-16 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "se:")
(should (eq 71 (py--beginning-of-def-or-class-position)))))
(ert-deftest py-ert-moves-up-position-tests-17 ()
(interactive)
(py-test-with-temp-buffer
py-kugel-text
(search-backward "se:")
(should (eq 445 (py--end-of-def-or-class-position)))))
(ert-deftest py-ert-moves-up-position-tests-18 ()
(interactive)
(py-test-with-temp-buffer-point-min
py-kugel-text
(search-forward "#")
(should (eq 223 (py--beginning-of-comment-position)))))
(ert-deftest py-ert-moves-up-position-tests-19 ()
(interactive)
(py-test-with-temp-buffer-point-min
py-kugel-text
(search-forward "#")
(should (eq 241 (py--end-of-comment-position)))))
(ert-deftest py-ert-moves-up-copy-statement-test ()
(interactive)
(py-test-with-temp-buffer-point-min
"from foo.bar.baz import something
"
(py-copy-statement)
(should (string-match "from foo.bar.baz import something" (car kill-ring)))))
(ert-deftest py-ert-moves-up-honor-dedent-lp-1280982 ()
(py-test-with-temp-buffer
"def foo():
def bar():
asdf
"
(py-newline-and-indent)
(py-electric-backspace)
(py-newline-and-indent)
(should (eq 42 (point)))))
(ert-deftest py-ert-moves-up-fill-paragraph-lp-1286318 ()
(py-test-with-temp-buffer-point-min
"# r1416
def baz():
\"\"\"Hello there.
This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy.
\"\"\"
return 7
# The last line of the docstring is longer than fill-column (set to
# 78 = for me). Put point on the 'T' in 'This' and hit M-q= . Nothing
# happens.
#
# Another example:
#
def baz():
\"\"\"Hello there.
This is a multiline
function definition.
Don't worry, be happy.
Be very very happy.
Very. happy.
\"\"\"
return 7
# All of those lines are shorter than fill-column. Put point anywhere
# = in that paragraph and hit M-q. Nothing happens.
#
# In both cases I would expect to end up with:
#
def baz():
\"\"\"Hello there.
This is a multiline function definition. Don= 't worry, be happy. Be very
very happy. Very. happy.
\"\"\"
return 7
"
(goto-char 49)
(sit-for 0.1 t)
(fill-paragraph)
(end-of-line)
(should (<= (current-column) 72))
(goto-char 409)
(fill-paragraph)
(end-of-line)
(should (<= (current-column) 72))
(goto-char 731)
(fill-paragraph)
(end-of-line)
(should (<= (current-column) 72))
(search-forward "\"\"\"")
(forward-line -1)
(sit-for 0.1 t)
(should (not (empty-line-p)))
))
(ert-deftest py-ert-moves-up-fill-paragraph-pep-257-nn-1 ()
(let ((py-docstring-style 'pep-257-nn))
(py-test-with-temp-buffer-point-min
"# r1416
def baz():
\"\"\"Hello there. This is a multiline function definition. Don= 't wor ry, be happy. Be very very happy. Very. happy. This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy. This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy.
This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy.
\"\"\"
return 7
"
(goto-char 49)
(py-fill-string)
(end-of-line)
(sit-for 0.1 t)
(should (<= (current-column) 72))
(forward-line 2)
(end-of-line)
(should (<= (current-column) 72))
(forward-line 1)
(end-of-line)
(should (<= (current-column) 72))
(forward-line 1)
(end-of-line)
(should (<= (current-column) 72))
(search-forward "\"\"\"")
(forward-line -1)
(fill-paragraph)
(end-of-line)
(sit-for 0.1 t)
(should (<= (current-column) 72))
)))
(ert-deftest py-ert-moves-up-fill-paragraph-pep-257 ()
(let ((py-docstring-style 'pep-257))
(py-test-with-temp-buffer-point-min
"# r1416
def baz():
\"\"\"Hello there. This is a multiline function definition. Don= 't wor ry, be happy. Be very very happy. Very. happy. This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy. This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy.
This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy.
\"\"\"
return 7
"
(font-lock-fontify-buffer)
(goto-char 49)
(fill-paragraph)
(end-of-line)
(should (<= (current-column) 72))
(forward-line 2)
(end-of-line)
(should (<= (current-column) 72))
(forward-line 1)
(end-of-line)
(should (<= (current-column) 72))
(forward-line 1)
(end-of-line)
(should (<= (current-column) 72))
(search-forward "\"\"\"")
(forward-line -1)
(should (empty-line-p))
)))
(ert-deftest py-ert-moves-up-fill-paragraph-onetwo ()
(let ((py-docstring-style 'onetwo))
(py-test-with-temp-buffer-point-min
"# r1416
def baz():
\"\"\"Hello there. This is a multiline function definition. Don= 't wor ry, be happy. Be very very happy. Very. happy. This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy. This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy.
This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy.
\"\"\"
return 7
"
(font-lock-fontify-buffer)
(goto-char 49)
(fill-paragraph)
(search-backward "\"\"\"")
(goto-char (match-end 0))
(eolp)
(forward-line 1)
(end-of-line)
(should (<= (current-column) 72))
(search-forward "\"\"\"")
(forward-line -1)
(should (empty-line-p)))))
(ert-deftest py-ert-moves-up-fill-paragraph-django-2 ()
(let ((py-docstring-style 'django))
(py-test-with-temp-buffer-point-min
"# r1416
def baz():
\"\"\"Hello there. This is a multiline function definition. Don't wor ry, be happy. Be very very happy. Very. happy. This is a multiline function definition. Don't worry, be happy. Be very very happy. Very. happy. This is a multiline function definition. Don't worry, be happy. Be very very happy. Very. happy.
This is a multiline function definition. Don't worry, be happy. Be very very happy. Very. happy.
\"\"\"
return 7
"
(goto-char 49)
(fill-paragraph)
(search-forward "\"\"\"")
(forward-line -2)
(should (empty-line-p)))))
(ert-deftest py-ert-moves-up-fill-paragraph-symmetric ()
(let ((py-docstring-style 'symmetric))
(py-test-with-temp-buffer-point-min
"# r1416
def baz():
\"\"\"Hello there. This is a multiline function definition. Don= 't wor ry, be happy. Be very very happy. Very. happy. This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy. This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy.
This is a multiline function definition. Don= 't worry, be happy. Be very very happy. Very. happy.
\"\"\"
return 7
"
(font-lock-fontify-buffer)
(goto-char 49)
(fill-paragraph)
(search-backward "\"\"\"")
(goto-char (match-end 0))
(eolp)
(forward-line 1)
(end-of-line)
(should (<= (current-column) 72))
(search-forward "\"\"\"")
(forward-line -1)
(should (not (empty-line-p))))))
(ert-deftest py-partial-expression-test-1 ()
(py-test-with-temp-buffer-point-min
"foo=1"
(and (should (string= "foo" (py-partial-expression)))
(py-kill-buffer-unconditional (current-buffer)))))
(ert-deftest py-partial-expression-test-2 ()
(py-test-with-temp-buffer-point-min
"print(root.getchildren()[0])"
(search-forward "getchildren")
(and (should (string= "getchildren()[0]" (py-partial-expression)))
(py-kill-buffer-unconditional (current-buffer)))))
(ert-deftest py-ert-moves-up-execute-statement-test ()
(py-test-with-temp-buffer-point-min
"print(\"I'm the py-execute-statement-test\")"
(let ((py-shell-name "python2"))
(py-execute-statement)
(set-buffer "*Python2*")
(goto-char (point-max))
(sit-for 0.3 t)
(and (should (search-backward "py-execute-statement-test" nil t 1))
(sit-for 0.1 t)
(py-kill-buffer-unconditional (current-buffer))))))
(ert-deftest indent-region-lp-997958-lp-1426903-no-arg-1-test ()
"Indent line-by-line as first line is okay "
(py-test-with-temp-buffer-point-min
"#! /usr/bin/env python
# -*- coding: utf-8 -*-
def foo ():
if True:
print(123)
with file(\"foo\" + zeit + \".ending\", 'w') as datei:
for i in range(anzahl):
bar.dosomething()
datei.write(str(baz[i]) + \"\\n\")
"
(search-forward "True")
(save-excursion
(py-indent-region (line-beginning-position) (point-max)))
(should (eq 4 (current-indentation)))
(search-forward "with file")
(should (eq 8 (current-indentation)))
(search-forward "for i ")
(should (eq 12 (current-indentation)))
(search-forward "bar.")
(should (eq 16 (current-indentation)))
(search-forward "datei.write")
(should (eq 16 (current-indentation)))))
(ert-deftest indent-region-lp-997958-lp-1426903-no-arg-2-test ()
"Keep indent of remaining block as first line was fixed. "
(py-test-with-temp-buffer-point-min
"#! /usr/bin/env python
# -*- coding: utf-8 -*-
def foo ():
if True:
print(123)
with file(\"foo\" + zeit + \".ending\", 'w') as datei:
for i in range(anzahl):
bar.dosomething()
datei.write(str(baz[i]) + \"\\n\")
"
(search-forward "for i ")
(save-excursion
(py-indent-region (line-beginning-position) (point-max)))
(should (eq 4 (current-indentation)))
(search-forward "bar.")
(should (eq 8 (current-indentation)))
(search-forward "datei.write")
(should (eq 8 (current-indentation)))))
(ert-deftest indent-region-lp-997958-lp-1426903-arg-1-test ()
(py-test-with-temp-buffer
"#! /usr/bin/env python
# -*- coding: utf-8 -*-
def foo ():
print(123)
with file(\"foo\" + zeit + \".ending\", 'w') as datei:
for i in range(anzahl):
bar.dosomething()
datei.write(str(baz[i]) + \"\\n\")
"
(py-indent-region 48 (point-max))
(goto-char (point-min))
(search-forward "print(123)")
(should (eq 4 (current-indentation)))
(search-forward "with file")
(should (eq 4 (current-indentation)))
(search-forward "for i ")
(should (eq 8 (current-indentation)))
(search-forward "bar.")
(should (eq 12 (current-indentation)))
(search-forward "datei.write")
(should (eq 12 (current-indentation)))))
(ert-deftest indent-region-lp-997958-lp-1426903-arg-2-test ()
"Indent line-by-line as first line is okay "
(py-test-with-temp-buffer-point-min
"#! /usr/bin/env python
# -*- coding: utf-8 -*-
with file(\"foo\" + zeit + \".ending\", 'w') as datei:
for i in range(anzahl):
bar.dosomething()
# called from correct first line
# wrong indent should to be fixed
datei.write(str(baz[i]) + \"\\n\")
"
(search-forward "with file")
(save-excursion
(py-indent-region (line-beginning-position) (point-max)))
(should (eq 0 (current-indentation)))
(search-forward "for i ")
(should (eq 4 (current-indentation)))
(search-forward "bar.")
(should (eq 8 (current-indentation)))
(search-forward "datei.write")
(should (eq 8 (current-indentation)))))
(ert-deftest py--pdb-versioned-test ()
(py-test-with-temp-buffer
""
(let ((py-shell-name "python3"))
(should (string= "pdb3" (py--pdb-versioned))))
(let ((py-shell-name "python"))
(should (string= "pdb" (py--pdb-versioned))))))
(ert-deftest py-ert-moves-up-forward-expression-test ()
(py-test-with-temp-buffer-point-min
py-def-and-class-test-string
(py-forward-expression)
(should (eq (char-before) ?s))
(py-forward-expression)
(should (eq (char-before) ?:))
(py-forward-expression)
(should (eq (char-before) ?t))
(py-forward-expression)
(should (eq (char-before) ?\)))
(py-forward-expression)
(should (eq (char-before) ?l))
(py-forward-expression)
(should (eq (char-before) ?\]))
(py-forward-expression)
(should (eq (char-before) ?n))
(py-forward-expression)
(should (eq (char-before) ?\]))
(py-forward-expression)
(should (eq (char-before) ?t))
(py-forward-expression)
(should (eq (char-before) ?\]))
(py-forward-expression)
(should (eq (char-before) ?f))
(py-forward-expression)
(should (eq (char-before) ?:))
(py-forward-expression)
(should (eq (char-before) ?\"))
(search-forward "fertig")
(py-forward-expression)
(should (eq (char-before) ?'))
(py-forward-expression)
(should (eq (char-before) ?f))
(search-forward "__name__")
(py-forward-expression)
(should (eq (char-before) ?:))
(py-forward-expression)
(should (eq (char-before) ?\)))
))
(ert-deftest py-ert-moves-up-backward-expression-test ()
(py-test-with-temp-buffer
py-def-and-class-test-string
(py-backward-expression)
(should (eq (char-after) ?m))
(py-backward-expression)
(should (eq (char-after) ?\"))
(py-backward-expression)
(should (eq (char-after) ?_))
(py-backward-expression)
(should (eq (char-after) ?i))
(py-backward-expression)
(should (eq (char-after) ?t))
(py-backward-expression)
(should (eq (char-after) ?a))
(py-backward-expression)
(should (eq (char-after) ?s))
(py-backward-expression)
(should (eq (char-after) ?i))
(beginning-of-line)
(search-backward "if")
(py-backward-expression)
(should (eq (char-after) ?'))
(search-backward "ausgabe")
(py-backward-expression)
(should (eq (char-after) ?\[))))
(ert-deftest py-ert-which-def-or-class-test-1 ()
(py-test-with-temp-buffer-point-min
py-def-and-class-test-string
(search-forward "kugel")
(should (string-match "kugel" (py-which-def-or-class)))
(search-forward "pylauf")
(should (string-match "kugel.pylauf" (py-which-def-or-class)))))
(ert-deftest py-ert-which-def-or-class-test-2 ()
(py-test-with-temp-buffer
"except AttributeError:
# To fix reloading, force it to create a new foo
if hasattr(threading.currentThread(), '__decimal_foo__'):
del threading.currentThread().__decimal_foo__
def setfoo(foo):
\"\"\"Set this thread's foo to foo.\"\"\"
if foo in (DefaultContext, BasicContext, ExtendedContext):
foo = foo.copy()
foo.clear_flags()
threading.currentThread().__decimal_foo__ = foo
def getfoo():
\"\"\"Returns this thread's foo.
If this thread does not yet have a foo, returns
\"\"\"
try:
return threading.currentThread().__decimal_foo__
except AttributeError:
foo = Context()
threading.currentThread().__decimal_foo__ = foo
return foo
else:
"
(should (string= "???" (py-which-def-or-class)))
(forward-line -3)
(should (string= "getfoo" (py-which-def-or-class)))))
(ert-deftest py-ert-which-def-or-class-test-3 ()
(py-test-with-temp-buffer
"class kugel(object):
zeit = time.strftime('%Y%m%d--%H-%M-%S')
# zeit = time.strftime('%Y-%m-%d--%H-%M-%S')
spiel = []
gruen = [0]
rot = [1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36]
schwarz = [2, 4, 6, 8, 10, 11, 13, 15, 17, 20, 22, 24, 26, 28, 29, 31, 33, 35]
ausgabe = []
treffer = None
fertig = ''
treffer = random.randint(0, 36)
def foo():
bar
def pylauf(self):
"
(forward-line -2)
(should (string= "kugel.foo" (py-which-def-or-class)))))
(ert-deftest py-ert-match-paren-test-1 ()
(py-test-with-temp-buffer
"if __name__ == \"__main__\":
main()"
(forward-char -1)
(py-match-paren)
(should (eq (char-after) ?\())))
(ert-deftest py-ert-match-paren-test-2 ()
(py-test-with-temp-buffer
"if __name__ == \"__main__\":
main()"
(forward-char -2)
(py-match-paren)
(should (eq (char-after) ?\)))))
(ert-deftest py-ert-match-paren-test-4 ()
(py-test-with-temp-buffer
"if __name__ == \"__main__\":
main()
"
(py-match-paren)
(should (eq (char-after) ?m))))
(ert-deftest py-ert-match-paren-test-5 ()
(py-test-with-temp-buffer-point-min
"if __name__ == \"__main__\":
main()
"
(py-match-paren)
(should (bolp))))
(ert-deftest py-ert-match-paren-test-7 ()
(py-test-with-temp-buffer
py-def-and-class-test-string
(skip-chars-backward "^\]")
(forward-char -1)
(py-match-paren)
(should (eq (char-after) ?\[))
(py-match-paren)
(should (eq (char-after) ?\]))))
(ert-deftest py-ert-match-paren-test-8 ()
(py-test-with-temp-buffer
py-def-and-class-test-string
(skip-chars-backward "^:")
(py-match-paren)
(should (eq (char-after) ?i))))
(ert-deftest py-ert-match-paren-test-9 ()
(py-test-with-temp-buffer
py-def-and-class-test-string
(search-backward "pylauf")
(py-match-paren)
(should (eq (char-after) ?\"))
(py-match-paren)
(should (eq (char-after) ?\"))
))
(ert-deftest py-ert-match-paren-nonempty-test-1 ()
(py-test-with-temp-buffer
"def main():
if len(sys.argv) == 1:
usage()
sys.exit()
#"
(search-backward "if")
(py-match-paren)
(should (eq 4 (current-column)))
(py-match-paren)
(should (eq (char-after) ?i))))
(ert-deftest py-ert-match-paren-nonempty-test-2 ()
(py-test-with-temp-buffer
"def main():
if len(sys.argv) == 1:
usage()
sys.exit()
#"
(search-backward "if")
(py-match-paren)
(should (and
(eq (char-after) 32)
(eq (current-column) 4)))))
(ert-deftest py-ert-match-paren-nonempty-test-3 ()
(py-test-with-temp-buffer-point-min
"def main():
if len(sys.argv) == 1:
usage()
sys.exit()
#"
(py-match-paren)
(should (and
(eq (char-after) 32)
(eq (current-column) 0)))))
(ert-deftest py-ert-match-paren-nonempty-test-4 ()
(py-test-with-temp-buffer
"def main():
if len(sys.argv) == 1:
usage()
sys.exit()
class asdf(object):
zeit = time.strftime('%Y%m%d--%H-%M-%S')
"
(search-backward "if")
(py-match-paren)
(should (eq (current-column) 4))
(should (eq (char-before) 32))))
(ert-deftest py-ert-match-paren-nonempty-test-5 ()
(py-test-with-temp-buffer-point-min
"import re
import sys
import os
"
(py-match-paren)
(should (looking-at "import sys"))
(setq last-command 'py-match-paren)
(py-match-paren)
(should (looking-at "import re"))))
(ert-deftest py-ert-match-paren-nonempty-test-6 ()
(py-test-with-temp-buffer
"def main():
if len(sys.argv) == 1:
usage()
sys.exit()
class asdf(object):
zeit = time.strftime('%Y%m%d--%H-%M-%S')
def Utf8_Exists(filename):
return os.path.exists(filename.encode('utf-8'))
"
(search-backward "class")
(py-match-paren)
(should (empty-line-p))
(should (eq 4 (current-column)))
))
(ert-deftest py-ert-match-paren-nonempty-test-7 ()
(py-test-with-temp-buffer
"try:
anzahl = int(args[1])
except:
print \"Setze anzahl auf 1\"
"
(search-backward "arg")
(py-match-paren)
(should (eq (char-after) ?\())))
(ert-deftest py-ert-match-paren-nonempty-test-8 ()
(py-test-with-temp-buffer
"try:
anzahl = int(args[1])
except:
print \"Setze anzahl auf 1\"
"
(search-backward " int")
(py-match-paren)
(should (eq (char-after) ?a))
(py-match-paren)
(should (eq (char-before) 32))
(should (empty-line-p))
(should (eq 4 (current-column)))))
(ert-deftest py-ert-match-paren-test-9 ()
(py-test-with-temp-buffer
"if __name__ == \"__main__\":
main()
"
(py-match-paren)
(should (eq (char-after) ?i))))
(ert-deftest py-ert-moves-up-match-paren-test-2 ()
(py-test-with-temp-buffer
py-def-and-class-test-string
(forward-line -3)
(indent-to 12)
(py-match-paren)
(should (eq (char-after) ?a))))
(ert-deftest py-ert-moves-up-match-paren-test-10 ()
(py-test-with-temp-buffer
py-def-and-class-test-string
(forward-line -3)
(indent-to 8)
(py-match-paren)
(should (eq (char-after) ?e))
(forward-line 3)
(should (eolp))))
(ert-deftest py-ert-backward-def-or-class-1 ()
(py-test-with-temp-buffer
"class _Simple(object):
# emulate something
def foo(self, element, tag, namespaces=None):
pass
def bar(self, element, tag, namespaces=None):
return list(self.iterfind(element, tag, namespaces))"
(forward-line -1)
(end-of-line)
(py-backward-def-or-class)
(should (char-equal ?d (char-after)))))
(ert-deftest py-ert-backward-def-or-class-2 ()
(py-test-with-temp-buffer
"class _Simple(object):
# emulate something
def foo(self, element, tag, namespaces=None):
pass
def bar(self, element, tag, namespaces=None):
return list(self.iterfind(element, tag, namespaces))"
(search-backward "pass")
(py-backward-def-or-class)
(should (char-equal ?d (char-after)))))
(ert-deftest py-ert-backward-def-or-class-3 ()
(py-test-with-temp-buffer
"class _Simple(object):
# emulate something
def foo(self, element, tag, namespaces=None):
pass
def bar(self, element, tag, namespaces=None):
return list(self.iterfind(element, tag, namespaces))"
(search-backward "def" nil t 2)
(py-backward-def-or-class)
(should (char-equal ?c (char-after)))))
(provide 'py-ert-tests-1)
;;; py-ert-tests-1.el ends here
python-mode.el-6.2.3/test/py-ert-execute-region-test.el 0000644 0000000 0000000 00000005771 13011652223 022746 0 ustar root root 0000000 0000000 ;;; py-ert-execute-region-test.el --- py-execute-region tests
;; Copyright (C) 2015 Andreas Röhler
;; Author: Andreas Röhler
;; Keywords: languages, convenience
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;; This file is generated by function from python-mode-utils.el - see in
;; directory devel. Edits here might not be persistent.
;;; Code:
(ert-deftest py-ert-execute-region-python-test ()
(let ((buffer (py--choose-buffer-name "python")))
(py-test-with-temp-buffer
"
print(\"one\")
print(\"two\")"
(py-execute-region-python (point-min) (point-max))
(sit-for 0.5 t)
(set-buffer buffer)
(should (search-backward "two")))))
(ert-deftest py-ert-execute-region-python2-test ()
(let ((buffer (py--choose-buffer-name "python2")))
(py-test-with-temp-buffer
"
print(\"one\")
print(\"two\")"
(py-execute-region-python2 (point-min) (point-max))
(sit-for 0.5 t)
(set-buffer buffer)
(should (search-backward "two")))))
(ert-deftest py-ert-execute-region-python3-test ()
(let ((buffer (py--choose-buffer-name "python3")))
(py-test-with-temp-buffer
"
print(\"one\")
print(\"two\")"
(py-execute-region-python3 (point-min) (point-max))
(sit-for 0.5 t)
(set-buffer buffer)
(should (search-backward "two")))))
(ert-deftest py-ert-execute-region-ipython-test ()
(let ((buffer (py--choose-buffer-name "ipython")))
(py-test-with-temp-buffer
"
print(\"one\")
print(\"two\")"
(py-execute-region-ipython (point-min) (point-max))
(sit-for 0.5 t)
(set-buffer buffer)
(should (search-backward "two")))))
(ert-deftest py-ert-execute-region-ipython3-test ()
(let ((buffer (py--choose-buffer-name "ipython3")))
(py-test-with-temp-buffer
"
print(\"one\")
print(\"two\")"
(py-execute-region-ipython3 (point-min) (point-max))
(sit-for 0.5 t)
(set-buffer buffer)
(should (search-backward "two")))))
(ert-deftest py-ert-execute-region-jython-test ()
(let ((buffer (py--choose-buffer-name "jython")))
(py-test-with-temp-buffer
"
print(\"one\")
print(\"two\")"
(py-execute-region-jython (point-min) (point-max))
(sit-for 0.5 t)
(set-buffer buffer)
(should (search-backward "two")))))
(provide 'py-ert-execute-region-test)
;;; py-ert-execute-region-test.el here
python-mode.el-6.2.3/test/test-triple-strings.py 0000644 0000000 0000000 00000003160 12660433546 021627 0 ustar root root 0000000 0000000 # Source:
# http://launchpadlibrarian.net/22565844/test-triple-strings.py
# Author: Ed Loper
# This file tests python-mode's ability to handle triple-quoted
# string. Here's how to tell if python-mode's doing the right thing:
#
# - All dashes (-) should *not* be marked as strings.
# - All Os, Xs, s should be marked as strings.
# - None of the quote marks around O's should be marked as strings.
# - Quote marks that are between angle brackets (<...>) should be
# marked as strings. Think of "X" as a pair of angle brackets
# right next to one another. Also, quotes to the left of >s
# and the right of with other characters should not affect
# the fontificatin any; these characters were just used to make it
# easier to see what the intended colorization is.)
# Some easy cases:
"O" 'O' "<'>" '<">'
"O" 'O' "<'>" '<">'
" O " ' O ' " < ' > " ' < " > '
"""O""" '''O''' "<<<'>>>" '''<">'''
# Some harder cases:
"""<">""" '''<'>'''
# Some tricky cases with backslashes.
'''<'>''' '''<\'''>''' '''<\\'''
# Some tricky cases with more than 3 quotes in a row.
"O""" "O"
"""">"""
"""">>"""
""""X">"""
""""X"">"""
"""O""""O" ""
"""O""""" "O"
"""O""""""<">"""
"""O"""""""X">"""
"""O""""""""X">"""
"""O""" "<<<>>>>"
"""""""""O""" "O"
"""O""""O""O""O"""
"""">""" """">>""" """">>>"""
""""">""" """"">>""" """"">>>"""
""""">>>""""O" """"">>>"""""
"""""""""<""X"X"">"""
# One version had a bug with comments ending in string markers: "
"""O"""
"" ""
"""<">""" '''<'>'''
# Spanning multiple lines:
"<
>"
'<
>'
"""
<
<
<
<
'
X
X
X
"
>
>
"""
python-mode.el-6.2.3/test/py-ert-tests-4.el 0000644 0000000 0000000 00000003306 13037412056 020347 0 ustar root root 0000000 0000000 ;;; py-interactive-tests.el --- Tests expected to succeed interactively -*- lexical-binding: t; -*-
;; Copyright (C) 2015 Andreas Röhler
;; Author: Andreas Röhler
;; Keywords: lisp
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;;
;;; Code:
(defun py-shell-complete-test (&optional arg load-branch-function)
(interactive "p")
(let ((teststring (concat py-test-shebang "
# -*- coding: utf-8 -*-
impo")))
(py-bug-tests-intern 'py-shell-complete-base arg teststring)))
(defun py-shell-complete-base ()
(when (and (interactive-p) py-debug-p) (switch-to-buffer (current-buffer))
(font-lock-fontify-buffer))
(sit-for 0.1 t)
(py-shell-complete)
(sit-for 0.1)
(assert (looking-back "import") nil "py-shell-complete-test failed"))
(ert-deftest py-ert-fast-complete-1 ()
(py-test-with-temp-buffer
"pri"
(let ((py-return-result-p t)
py-result py-store-result-p)
(when py-debug-p (switch-to-buffer (current-buffer)))
(py-fast-complete)
(should (eq (char-before) 40)))))
(provide 'py-interactive-tests)
;;; py-interactive-tests.el ends here
python-mode.el-6.2.3/test/py-execute-region-commandp-test.el 0000644 0000000 0000000 00000011626 13011652223 023746 0 ustar root root 0000000 0000000 ;;; py-execute-region-commandp-test.el --- Test execute region forms
;; Copyright (C) 2015 Andreas Röhler
;; Author: Andreas Röhler
;; Keywords: languages, convenience
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;; This file is generated by function from python-mode-utils.el - see in
;; directory devel. Edits here might not be persistent.
;;; Code:
(ert-deftest py-execute-region-commandp-test ()
(should (commandp 'py-execute-region)))
(ert-deftest py-execute-region-switch-commandp-test ()
(should (commandp 'py-execute-region-switch)))
(ert-deftest py-execute-region-no-switch-commandp-test ()
(should (commandp 'py-execute-region-no-switch)))
(ert-deftest py-execute-region-dedicated-commandp-test ()
(should (commandp 'py-execute-region-dedicated)))
(ert-deftest py-ert-execute-region-python-commandp-test ()
(should (commandp 'py-execute-region-python)))
(ert-deftest py-ert-execute-region-python-switch-commandp-test ()
(should (commandp 'py-execute-region-python-switch)))
(ert-deftest py-ert-execute-region-python-no-switch-commandp-test ()
(should (commandp 'py-execute-region-python-no-switch)))
(ert-deftest py-ert-execute-region-python-dedicated-commandp-test ()
(should (commandp 'py-execute-region-python-dedicated)))
(ert-deftest py-ert-execute-region-python2-commandp-test ()
(should (commandp 'py-execute-region-python2)))
(ert-deftest py-ert-execute-region-python2-switch-commandp-test ()
(should (commandp 'py-execute-region-python2-switch)))
(ert-deftest py-ert-execute-region-python2-no-switch-commandp-test ()
(should (commandp 'py-execute-region-python2-no-switch)))
(ert-deftest py-ert-execute-region-python2-dedicated-commandp-test ()
(should (commandp 'py-execute-region-python2-dedicated)))
(ert-deftest py-ert-execute-region-python3-commandp-test ()
(should (commandp 'py-execute-region-python3)))
(ert-deftest py-ert-execute-region-python3-switch-commandp-test ()
(should (commandp 'py-execute-region-python3-switch)))
(ert-deftest py-ert-execute-region-python3-no-switch-commandp-test ()
(should (commandp 'py-execute-region-python3-no-switch)))
(ert-deftest py-ert-execute-region-python3-dedicated-commandp-test ()
(should (commandp 'py-execute-region-python3-dedicated)))
(ert-deftest py-ert-execute-region-ipython-commandp-test ()
(should (commandp 'py-execute-region-ipython)))
(ert-deftest py-ert-execute-region-ipython-switch-commandp-test ()
(should (commandp 'py-execute-region-ipython-switch)))
(ert-deftest py-ert-execute-region-ipython-no-switch-commandp-test ()
(should (commandp 'py-execute-region-ipython-no-switch)))
(ert-deftest py-ert-execute-region-ipython-dedicated-commandp-test ()
(should (commandp 'py-execute-region-ipython-dedicated)))
(ert-deftest py-ert-execute-region-ipython2.7-commandp-test ()
(should (commandp 'py-execute-region-ipython2.7)))
(ert-deftest py-ert-execute-region-ipython2.7-switch-commandp-test ()
(should (commandp 'py-execute-region-ipython2.7-switch)))
(ert-deftest py-ert-execute-region-ipython2.7-no-switch-commandp-test ()
(should (commandp 'py-execute-region-ipython2.7-no-switch)))
(ert-deftest py-ert-execute-region-ipython2.7-dedicated-commandp-test ()
(should (commandp 'py-execute-region-ipython2.7-dedicated)))
(ert-deftest py-ert-execute-region-ipython3-commandp-test ()
(should (commandp 'py-execute-region-ipython3)))
(ert-deftest py-ert-execute-region-ipython3-switch-commandp-test ()
(should (commandp 'py-execute-region-ipython3-switch)))
(ert-deftest py-ert-execute-region-ipython3-no-switch-commandp-test ()
(should (commandp 'py-execute-region-ipython3-no-switch)))
(ert-deftest py-ert-execute-region-ipython3-dedicated-commandp-test ()
(should (commandp 'py-execute-region-ipython3-dedicated)))
(ert-deftest py-ert-execute-region-jython-commandp-test ()
(should (commandp 'py-execute-region-jython)))
(ert-deftest py-ert-execute-region-jython-switch-commandp-test ()
(should (commandp 'py-execute-region-jython-switch)))
(ert-deftest py-ert-execute-region-jython-no-switch-commandp-test ()
(should (commandp 'py-execute-region-jython-no-switch)))
(ert-deftest py-ert-execute-region-jython-dedicated-commandp-test ()
(should (commandp 'py-execute-region-jython-dedicated)))
(provide 'py-execute-region-commandp-test)
;;; py-execute-region-commandp-test.el ends here
python-mode.el-6.2.3/test/py-extra-tests.el 0000644 0000000 0000000 00000007207 13037412056 020543 0 ustar root root 0000000 0000000 (ert-deftest py-ert-execute-block-fast-2 ()
(py-test-with-temp-buffer-point-min
"try:
a
except NameError:
a=1
finally:
a+=1
print(a)"
(let ((py-fast-process-p t)
(py-return-result-p t)
(py-debug-p t)
py-result)
(py-execute-block)
(when py-debug-p (message "py-ert-execute-block-fast, py-result: %s" py-result))
(should (numberp (string-to-number (car (split-string py-result))))))))
(ert-deftest py-ert-kill-statements-test ()
(py-test-with-temp-buffer
"with file(\"roulette-\" + zeit + \".csv\", 'w') as datei:
for i in range(anzahl):
klauf.pylauf()
datei.write(str(spiel[i]) + \"\\n\")
datei.write(\"treffer; schwarz; gruen; rot; pair; impair; passe; manque; spiel\\n\")
print(''' asdf' asdf asdf asdf asdf asdfasdf asdfasdf a asdf asdf asdf asdfasdfa asdf asdf asdf asdf
''')"
;; (when py-debug-p (switch-to-buffer (current-buffer))
;; (font-lock-fontify-buffer))
(forward-line -2)
(back-to-indentation)
(py-kill-statements)
(sit-for 0.1)
(should (eobp))))
(ert-deftest py-ert-moves-up-execute-statement-python3-dedicated-test ()
(py-test-with-temp-buffer-point-min
"print(\"I'm the py-execute-statement-python3-dedicated-test\")"
(let ((py-debug-p t)
py-store-result-p
erg)
(call-interactively 'py-execute-statement-python3-dedicated)
(sit-for 0.1 t)
(set-buffer py-buffer-name)
(goto-char (point-min))
(should (search-forward "py-execute-statement-python3-dedicated-test" nil t 1)))))
(ert-deftest py-ert-execute-block-fast-3 ()
(py-test-with-temp-buffer-point-min
"if True:
a = 1
print(a)"
(let ((py-fast-process-p t)
(py-return-result-p t)
(py-debug-p t)
py-result)
(py-execute-block)
(when py-debug-p (message "py-ert-execute-block-fast, py-result: %s" py-result))
(sit-for 0.1 t)
(should (string= "1" py-result)))))
(ert-deftest py-ert-exception-name-face-lp-1294742 ()
(py-test-with-temp-buffer
"ArithmeticError"
(forward-char -1)
(should (eq 'py-exception-name-face (get-char-property (point) 'face)))))
(ert-deftest py-ert-execute-block-jython-test ()
(let ((buffer (py--choose-buffer-name "jython")))
(py-test-with-temp-buffer
"if True:
print(\"one\")
print(\"two\")"
(py-execute-block-jython)
(sit-for 0.1)
(set-buffer buffer)
(goto-char (point-max))
(or
(should (search-backward "two"))
(should (search-forward "two"))))))
(ert-deftest py-shell-complete-in-dedicated-shell ()
(let (erg
;; py-split-window-on-execute
py-switch-buffers-on-execute-p)
(with-temp-buffer
(python-mode)
(setq erg (python-dedicated))
(with-current-buffer erg
(goto-char (point-max))
;; (when py-debug-p (switch-to-buffer (current-buffer)))
;; (switch-to-buffer (current-buffer))
(insert "pri")
(sit-for 1 t)
(call-interactively 'py-indent-or-complete)
(sit-for 0.1 t)
(should (or (eq 40 (char-before))
;; python may just offer print(
(buffer-live-p (get-buffer "*Python Completions*"))))
(py-kill-buffer-unconditional erg)))))
(ert-deftest py-ert-execute-statement-fast-1 ()
(py-test-with-temp-buffer-point-min
"print(1)"
(let ((py-fast-process-p t)
(py-return-result-p t)
py-result py-store-result-p)
(py-execute-statement)
(should (string= "1" py-result)))))
(ert-deftest py-ert-execute-statement-fast-2 ()
(py-test-with-temp-buffer-point-min
"print(2)"
(let ((py-fast-process-p t)
(py-return-result-p t)
py-result py-store-result-p)
(py-execute-statement-fast)
(should (string= "2" py-result)))))
python-mode.el-6.2.3/test/py-ert-tests-2.el 0000644 0000000 0000000 00000070077 13015361233 020352 0 ustar root root 0000000 0000000 ;; py-ert-tests.el --- Tests, some adapted from python.el -*- lexical-binding: t; -*-
;; Copyright (C) 2014 Andreas Röhler,
;; 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 .
;;; Commentary:
;;; Code:
;; tests are expected to run from directory test
(add-to-list 'load-path default-directory)
(load "py-ert-tests-1.el" nil t)
;; (require 'python-mode-test)
;;;
(ert-deftest py-ert-keyword-face-lp-1294742 ()
(py-test-with-temp-buffer-point-min
" and as assert break continue del elif else except exec finally for global if in is lambda not or pass raise return while with yield"
(font-lock-fontify-buffer)
(while (and (not (eobp))(< 0 (skip-chars-forward " ")))
(should (eq 'font-lock-keyword-face (get-char-property (point) 'face)))
(skip-chars-forward "^ \n"))))
(ert-deftest py-ert-builtins-face-lp-1294742 ()
(let ((py-shell-name "python3"))
(py-test-with-temp-buffer-point-min
"_ __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"
(font-lock-fontify-buffer)
(when py-debug-p (switch-to-buffer (current-buffer)))
;; (when py-debug-p (switch-to-buffer (current-buffer)))
(should (eq 'py-builtins-face (get-char-property (point) 'face))))))
(ert-deftest py-ert-pseudo-keyword-face-lp-1294742 ()
(py-test-with-temp-buffer-point-min
" Ellipsis True False None __debug__ NotImplemented"
(font-lock-fontify-buffer)
(while (and (not (eobp))(< 0 (skip-chars-forward " ")))
(should (eq 'py-pseudo-keyword-face (get-char-property (point) 'face)))
(skip-chars-forward "^ \n"))))
(ert-deftest py-ert-object-reference-face-lp-1294742 ()
(py-test-with-temp-buffer-point-min
" self cls"
(font-lock-fontify-buffer)
(while (and (not (eobp))(< 0 (skip-chars-forward " ")))
(should (eq 'py-object-reference-face (get-char-property (point) 'face)))
(skip-chars-forward "^ \n"))))
(ert-deftest py-ert-borks-all-lp-1294820 ()
(py-test-with-temp-buffer-point-min
"# M-q within some code (not in= a docstring) completely borks all previous
# code in the file:
#
# E.g. here, if I M-q within the last function:
def foo(self):
some_actual_code()
def bar(self):
some_actual_code()
def baz(self):
some_actual_code()
# def foo(self): some_actual_code() def bar(self): some_actual_code() def
# baz(self):
# some_actual_code()
"
(font-lock-fontify-buffer)
(search-forward "def baz(self):")
(fill-paragraph)
(forward-line -1)
(should (eq (char-after) ?\n))))
(ert-deftest py-ert-respect-paragraph-1294829 ()
(py-test-with-temp-buffer-point-min
"# py-fill-paragraph doesn';t respect existing paragraph breaks when
# reflowing the docstring, e.g.
def foo(self)
\"\"\"First one-line summary.
Some other stuff which I don't want a paragraph break inserted into
the middle of.
And another para hjkdfgh fdjkg hfdjkg hdfjk ghdfk ghjkdf
ghjkdf ghjdf ghjdkf k
\"\"\"
def foo(self)
\"\"\"Second one-line summary. Some other stuff which I don't want a
paragraph
break inserted into the middle of. And another para hjkdfgh
fdjkg
hfdjkg hdfjk ghdfk ghjkdf ghjkdf ghjdf ghjdkf k \"\"\"
# I feel it would be better if it didn't attempt to
# reflow the whole docstring, rather just reflow the
# particular paragraph within it which the point is
# positioned in.
# It would also be good if it could avoid mangling parameter
# descriptions like this:
def foo(self):
\"\"\"Summary line.
Foo bar fhgdjkfd hgjfd hgjkfd ghjkdf ghjkdf hgjdf ghjkdf
hgjdf hjgk dfhjkg dfhjkg dfhjkg fdhjkg hjfdkg
Parameters
----------
endog : array-like
1-d endogenous response variable. The dependent variable.
exog : array-like
A nobs x k array where `nobs` is the number of
observations and `k`
is the number of regressors. An interecept is not
included by default
and should be added by the user. See
`statsmodels.tools.add_constant`.\"\"\"
def foo(self):
\"\"\"Summary line. Foo bar fhgdjkfdhgjfd hgjkfd ghjkdf ghjkdf
hgjdf
ghjkdf hgjdf hjgk dfhjkg dfhjkg dfhjkg fdhjkghjfdkg
Parameters
---------- endog : array-like 1-d endogenous response
variable. The
dependent variable. exog : array-like A nobs x karray where
`nobs`
is the number of observations and `k` is the number of
regressors.
An interecept is not included by default and should be added
by the
user. See `statsmodels.tools.add_constant`.
\"\"\"
# Failing that though, if I can at least choose to
# reflow individual paragraphs in the docstring and
# leave others intact, I can format these things
# manually while still being able to flow other
# paragraphs using M-q.
"
(when py-debug-p (switch-to-buffer (current-buffer)))
(font-lock-fontify-buffer)
(search-forward "Some other" nil t 1)
(sit-for 0.1 t)
(fill-paragraph)
(forward-line -2)
(should (not (empty-line-p)))
(forward-line 1)
(should (eq (char-after) ?\n))
(search-forward "one-line summary." nil t 1)
(when py-debug-p (message "fill-column: %s" fill-column))
(fill-paragraph)
(forward-line 1)
(sit-for 0.1 t)
(should (empty-line-p))
(search-forward "Foo bar" nil t 1)
(fill-paragraph)
(forward-line 2)
(should (eq (char-after) ?\n))))
(ert-deftest py-ert-backward-same-level-test ()
(py-test-with-temp-buffer-point-min
"def foo():
if True:
def bar():
pass
elif False:
def baz():
pass
else:
try:
1 == 1
except True:
def foo1():
if True:
def bar1():
pass
elif False:
def baz1():
pass
else:
try:
1 == 1
except True:
pass
else:
pass
finally:
pass
else True:
pass
finally:
pass
"
(font-lock-fontify-buffer)
(goto-char 632)
(py-backward-same-level)
(should (looking-at "except"))
(py-backward-same-level)
(should (looking-at "try"))))
(ert-deftest py-ert-up-level-test-2 ()
(py-test-with-temp-buffer-point-min
"def foo():
if True:
def bar():
pass
elif False:
def baz():
pass
else:
try:
1 == 1
except True:
def foo1():
if True:
def bar1():
pass
elif False:
def baz1():
pass
else:
try:
1 == 1
except True:
pass
else True:
pass
finally:
pass
else True:
pass
finally:
pass
"
(goto-char 632)
(py-up-block)
(should (looking-at "else:"))))
(ert-deftest py-ert-deletes-too-much-lp:1300270 ()
(py-test-with-temp-buffer "
x = {'abc':'def',
'ghi':'jkl'}
"
;; (when py-debug-p (switch-to-buffer (current-buffer)))
(goto-char 24)
(py-electric-delete)
(should (eq 5 (current-indentation)))))
(ert-deftest py-ert-mark-expression-test ()
"Avoid infinite loop"
(py-test-with-temp-buffer
"assert pycompletions('TestClass.test' , name) == \
['testclassmeth', 'testmeth', 'testprop', 'teststaticmeth']"
(forward-char -1)
(py-mark-expression)
(should (eq 119 (mark)))
(goto-char 44)
(py-mark-expression)
(should (eq 46 (mark)))))
(ert-deftest py-dedicated-shell-test ()
""
(let ((erg (py-shell nil t "python")))
(should (< 8 (length erg)))
(should (eq 0 (string-match "^*Python" erg)))))
(ert-deftest py-python-shell-test ()
""
(let ((erg (python)))
(should (bufferp (get-buffer erg)))
(should (get-buffer-process erg))))
(ert-deftest py-python2-shell-test ()
""
(let ((erg (python2)))
(should (bufferp (get-buffer erg)))
(should (get-buffer-process erg))))
(ert-deftest py-python3-shell-test ()
""
(let ((erg (python3)))
(should (bufferp (get-buffer erg)))
(should (get-buffer-process erg))))
(ert-deftest py-keep-windows-configuration-test ()
(py-test-with-temp-buffer
"print('py-keep-windows-configuration-test-string')"
(delete-other-windows)
(let ((py-keep-windows-configuration t)
(py-split-window-on-execute t)
(full-height (window-height)))
(py-execute-statement)
(should (eq (window-height) full-height)))))
(ert-deftest py-compute-indentation-after-import-test ()
(py-test-with-temp-buffer
"import pdb
"
(should (eq 0 (py-compute-indentation)))))
(ert-deftest py-compute-indentation-bob-test ()
(py-test-with-temp-buffer-point-min
" def foo():
if True:
pass
else:
pass
"
(should (eq 0 (py-compute-indentation)))))
(ert-deftest py-indentation-lp-1375122-test ()
(py-test-with-temp-buffer
"def foo():
if True:
pass
"
(forward-line -1)
(call-interactively 'py-indent-or-complete)
(sit-for 0.1 t)
(should (eq 8 (current-column)))
(beginning-of-line)
(delete-horizontal-space)
(indent-to 4)
(call-interactively 'py-indent-or-complete)
(sit-for 0.1 t)
(should (eq 8 (current-column)))
;;
;; (call-interactively 'py-indent-or-complete)
;; (call-interactively 'py-indent-or-complete)
;; (sit-for 0.1 t)
;; (should (eq 4 (current-column)))
;; (py-indent-or-complete)
;; (sit-for 0.1 t)
;; (should (eq 8 (current-column)))
))
(ert-deftest py-shell-python-lp-1398530-test ()
(when (buffer-live-p (get-buffer "*Python*"))(py-kill-buffer-unconditional "*Python*"))
(py-test-with-temp-buffer
""
(when py-debug-p (switch-to-buffer (current-buffer)))
(let ((py-shell-name "python"))
(py-shell)
(sit-for 0.1 t)
(should (buffer-live-p (get-buffer "*Python*"))))))
(ert-deftest py-shell-python3-lp-1398530-test ()
(when (buffer-live-p (get-buffer "*Python3*"))(py-kill-buffer-unconditional "*Python3*"))
(py-test-with-temp-buffer
""
(let ((py-shell-name "python3"))
(py-shell)
(sit-for 0.1 t)
(should (buffer-live-p (get-buffer "*Python3*"))))))
(ert-deftest py-shell-python2-lp-1398530-test ()
(when (buffer-live-p (get-buffer "*Python2*"))(py-kill-buffer-unconditional "*Python2*"))
(py-test-with-temp-buffer
""
(when py-debug-p (switch-to-buffer (current-buffer)))
(let ((py-shell-name "python2"))
(py-shell)
(sit-for 0.1 t)
(should (buffer-live-p (get-buffer "*Python2*"))))))
(ert-deftest py-backward-statement-test-1 ()
(py-test-with-temp-buffer
(let ((py-return-result-p t)
py-result py-store-result-p)
"# -*- coding: utf-8 -*-
print dir()
c = Cat()
c.hello() #causes error, but emacs tracking fails
import sys, os; os.remove('do/something/nasty') # lp:1025000
def foo(*args):2
\"\"\"
ASDF
\"\"\"
# ABD
args = \"asdf\"
")
(py-backward-statement)
(should (eq (char-after) ?a))
(py-backward-statement)
(should (eq (char-after) ?d))
(py-backward-statement)
(should (eq (char-after) ?o))
(py-backward-statement)
(should (eq (char-after) ?i))
(py-backward-statement)
(should (eq (char-after) ?c))
(py-backward-statement)
(should (eq (char-after) ?c))
(py-backward-statement)
(should (eq (char-after) ?p))
(py-backward-statement)
(should (bobp))))
(ert-deftest py-ert-backward-except-block-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(py-backward-except-block)
(should (eq (char-after) ?e))))
(ert-deftest py-ert-backward-except-block-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(py-backward-except-block-bol)
(should (eq (char-after) ?\ ))))
;; (and (bufferp (get-buffer "*Python*"))(buffer-live-p (get-buffer "*Python*"))(py-kill-buffer-unconditional "*Python*"))
;; (and (bufferp (get-buffer "*IPython*"))(buffer-live-p (get-buffer "*IPython*"))(py-kill-buffer-unconditional "*IPython*")))
(defun nested-dictionaries-indent-lp:328791-test (&optional arg)
"With ARG greater 1 keep test buffer open.
If no `load-branch-function' is specified, make sure the appropriate branch is loaded. Otherwise default python-mode will be checked. "
(interactive "p")
(let ((teststring "
# hanging
asdf = {
'a':{
'b':3,
'c':4
}
}
# closing
asdf = {
'a':{
'b':3,
'c':4
}
}
data = {
'key':
{
'objlist': [
{
'pk': 1,
'name': 'first',
},
{
'pk': 2,
'name': 'second',
}
]
}
}
"))
(py-bug-tests-intern 'nested-dictionaries-indent-lp:328791-base arg teststring)))
(ert-deftest py-ert-nested-dictionaries-indent-lp:328791-test ()
(py-test-with-temp-buffer-point-min
"
# hanging
asdf = {
'a':{
'b':3,
'c':4
}
}
# closing
asdf = {
'a':{
'b':3,
'c':4
}
}
data = {
'key':
{
'objlist': [
{
'pk': 1,
'name': 'first',
},
{
'pk': 2,
'name': 'second',
}
]
}
}
"
(let ((py-indent-honors-multiline-listing t)
py-closing-list-dedents-bos)
(search-forward "'a':{")
(should (eq 4 (py-compute-indentation)))
(search-forward "}")
(should (eq 8 (py-compute-indentation)))
(search-forward "}")
(should (eq 4 (py-compute-indentation)))
;; py-closing-list-dedents-bos
(setq py-closing-list-dedents-bos t)
(search-forward "'a':{")
(should (eq 4 (py-compute-indentation)))
(search-forward "}")
(should (eq 4 (py-compute-indentation)))
(search-forward "}")
(should (eq 0 (py-compute-indentation)))
(search-forward "}" nil nil 2)
(should (eq 12 (py-compute-indentation)))
(search-forward "]")
(should (eq 8 (py-compute-indentation)))
(search-forward "}")
(should (eq 4 (py-compute-indentation)))
(search-forward "}")
(should (eq 0 (py-compute-indentation))))))
(ert-deftest py-ert-flexible-indentation-lp-328842-test-1 ()
(py-test-with-temp-buffer-point-min
"\(long, sequence, of_items,
that, needs, to_be, wrapped) = input_list
packed_entry = (long, sequence, of_items,
that, needs, to_be, wrapped)
\( whitespaced, long, sequence, of_items,
that, needs, to_be, wrapped) = input_list
"
(let ((py-indent-honors-multiline-listing t))
(search-forward "(long")
(forward-char -1)
;; (goto-char 6)
(should (eq nil (get-char-property (point) 'face))))))
(ert-deftest py-ert-flexible-indentation-lp-328842-test-2 ()
(py-test-with-temp-buffer-point-min
"\(long, sequence, of_items,
that, needs, to_be, wrapped) = input_list
packed_entry = (long, sequence, of_items,
that, needs, to_be, wrapped)
\( whitespaced, long, sequence, of_items,
that, needs, to_be, wrapped) = input_list
"
(let ((py-indent-honors-multiline-listing t)
py-indent-paren-spanned-multilines-p)
(goto-char 33)
(assert (eq 1 (py-compute-indentation)) nil "flexible-indentation-lp-328842-test failed")
(goto-char 115)
(assert (eq 16 (py-compute-indentation)) nil "flexible-indentation-lp-328842-test failed")
(goto-char 202)
(assert (eq 2 (py-compute-indentation)) nil "flexible-indentation-lp-328842-test failed"))))
(ert-deftest py-ert-flexible-indentation-lp-328842-test-3 ()
(py-test-with-temp-buffer-point-min
"\(long, sequence, of_items,
that, needs, to_be, wrapped) = input_list
packed_entry = (long, sequence, of_items,
that, needs, to_be, wrapped)
\( whitespaced, long, sequence, of_items,
that, needs, to_be, wrapped) = input_list
"
(let ((py-indent-honors-multiline-listing t)
(py-indent-paren-spanned-multilines-p t))
(goto-char 33)
(assert (eq 5 (py-compute-indentation)) nil "flexible-indentation-lp-328842-test failed")
(goto-char 115)
(assert (eq 20 (py-compute-indentation)) nil "flexible-indentation-lp-328842-test failed")
(goto-char 202)
(assert (eq 6 (py-compute-indentation)) nil "flexible-indentation-lp-328842-test failed"))))
(ert-deftest py-ert-indent-in-arglist-test ()
(py-test-with-temp-buffer
"def foo (a,
):"
(let (py-indent-paren-spanned-multilines-p)
(should (eq 9 (py-compute-indentation))))
(let ((py-indent-paren-spanned-multilines-p t))
(should (eq 13 (py-compute-indentation))))))
(ert-deftest py-complete-in-python-shell-test ()
(let ((py-shell-name "python")
(py-switch-buffers-on-execute-p t))
(py-kill-buffer-unconditional "*Python*")
(python)
(goto-char (point-max))
(insert "pri")
(py-indent-or-complete)
(forward-word -1)
(should (eq ?p (char-after)))))
(ert-deftest py-complete-in-python3-shell-test ()
(let ((py-shell-name "python3")
(py-switch-buffers-on-execute-p t))
(py-kill-buffer-unconditional "*Python3*")
(python3)
(should (eq (current-buffer) (get-buffer "*Python3*")))
(goto-char (point-max))
(insert "pri")
(py-indent-or-complete)
(forward-word -1)
(should (eq ?p (char-after)))))
(ert-deftest py-complete-empty-string-result-test ()
(let ((py-shell-name "python3")
(py-switch-buffers-on-execute-p t))
(py-kill-buffer-unconditional "*Python3*")
(python3)
(goto-char (point-max))
(insert "foo")
(py-indent-or-complete)
(should (looking-back "foo"))))
(ert-deftest py-ert-close-block-test ()
(py-test-with-temp-buffer-point-min
"# -*- coding: utf-8 -*-
def main():
if len(sys.argv)==1:
usage()
sys.exit()
if __name__==\"__main__\":
main()
"
(search-forward "exit()")
(should (eq 4 (py-close-block)))))
(ert-deftest py-ert-close-def-or-class-test ()
(py-test-with-temp-buffer-point-min
"# -*- coding: utf-8 -*-
def main():
if len(sys.argv)==1:
usage()
sys.exit()
if __name__==\"__main__\":
main()
"
(search-forward "exit()")
(should (eq 0 (py-close-def-or-class)))))
(ert-deftest py-ert-close-def-test ()
(py-test-with-temp-buffer-point-min
"# -*- coding: utf-8 -*-
def main():
if len(sys.argv)==1:
usage()
sys.exit()
if __name__==\"__main__\":
main()
"
(search-forward "exit()")
(should (eq 0 (py-close-def)))))
(ert-deftest py-ert-close-class-test ()
(py-test-with-temp-buffer-point-min
"# -*- coding: utf-8 -*-
class asdf:
def main():
if len(sys.argv)==1:
usage()
sys.exit()
if __name__==\"__main__\":
main()
"
(search-forward "exit()")
(should (eq 0 (py-close-class)))))
(ert-deftest py-ert-dedent-forward-test ()
(py-test-with-temp-buffer
"with file(\"roulette-\" + zeit + \".csv\", 'w') as datei:
for i in range(anzahl):
klauf.pylauf()
datei.write(str(spiel[i]) + \"\\n\")"
(skip-chars-backward " \t\r\n\f")
(py-dedent-forward-line)
(should (empty-line-p))
(forward-line -1)
(should (eq 4 (current-indentation)))))
(ert-deftest py-face-lp-1454858-python2-1-test ()
(let ((py-python-edit-version ""))
(py-test-with-temp-buffer
"#! /usr/bin/env python2
file.close()"
(beginning-of-line)
(font-lock-fontify-buffer)
(sit-for 0.1)
(should (eq (face-at-point) 'py-builtins-face)))))
;; Setting of py-python-edit-version should precede
(ert-deftest py-face-lp-1454858-python2-2-test ()
(let ((py-python-edit-version "python2"))
(py-test-with-temp-buffer
"#! /usr/bin/env python3
file.close()"
(beginning-of-line)
(font-lock-fontify-buffer)
(sit-for 0.1)
(should (eq (face-at-point) 'py-builtins-face)))))
(ert-deftest py-face-lp-1454858-python2-3-test ()
(let ((py-python-edit-version ""))
(with-temp-buffer
(insert "#! /usr/bin/env python2
print()")
(switch-to-buffer (current-buffer))
(beginning-of-line)
(python-mode)
(font-lock-fontify-buffer)
(sit-for 0.1)
(should (eq (face-at-point) 'font-lock-keyword-face)))))
(ert-deftest py-ert-in-comment-p-test ()
(py-test-with-temp-buffer
"# "
(should (py--in-comment-p))))
(ert-deftest py-ert-in-sq-string-p-test ()
(py-test-with-temp-buffer
"' "
(should (py-in-string-p))))
(ert-deftest py-ert-in-dq-string-p-test ()
(py-test-with-temp-buffer
"\" "
(should (py-in-string-p))))
(ert-deftest py-ert-in-sq-tqs-string-p-test ()
(py-test-with-temp-buffer
"''' "
(should (py-in-string-p))))
(ert-deftest py-ert-in-dq-tqs-string-p-test ()
(py-test-with-temp-buffer
"\"\"\" "
(should (py-in-string-p))))
(ert-deftest py-ert-electric-delete-test ()
(py-test-with-temp-buffer-point-min
" {}"
(py-electric-delete)
(should (eq (char-after) ?{))))
(ert-deftest py-ert-end-of-def-or-class-test-1 ()
(py-test-with-temp-buffer-point-min
"class MyTest(unittest.TestCase):
def test(self):
self.assertEqual(fun(3), 4)"
(skip-chars-forward "^(")
(py-end-of-def-or-class)
(should (eobp))))
(ert-deftest py-ert-end-of-def-or-class-test-2 ()
(py-test-with-temp-buffer-point-min
"class MyTest(unittest.TestCase):
def test(self):
pass
def test(self):
pass"
(search-forward "pass")
(py-end-of-def-or-class)
(should (eobp))))
(ert-deftest py-ert-narrow-to-block-test ()
(py-test-with-temp-buffer
"with file(\"roulette-\" + zeit + \".csv\", 'w') as datei:
for i in range(anzahl):
klauf.pylauf()
"
(py-narrow-to-block)
(should (eq 50 (length (buffer-substring-no-properties (point-min)(point-max)))))))
(ert-deftest py-ert-narrow-to-block-or-clause-test ()
(py-test-with-temp-buffer
"if treffer in gruen:
# print \"0, Gruen\"
ausgabe[1] = treffer
ausgabe[2] = treffer
elif treffer in schwarz:
# print \"%i, Schwarz\" % (treffer)
ausgabe[1] = treffer
"
(py-narrow-to-block-or-clause)
(should (eq 87 (length (buffer-substring-no-properties (point-min)(point-max)))))))
(ert-deftest py-ert-narrow-to-clause-test ()
(py-test-with-temp-buffer
"if treffer in gruen:
# print \"0, Gruen\"
ausgabe[1] = treffer
ausgabe[2] = treffer
elif treffer in schwarz:
# print \"%i, Schwarz\" % (treffer)
ausgabe[1] = treffer
"
(py-narrow-to-clause)
(should (eq 87 (length (buffer-substring-no-properties (point-min)(point-max)))))))
(ert-deftest py-ert-narrow-to-class-test ()
(py-test-with-temp-buffer
py-def-and-class-test-string
(search-backward "treffer")
(py-narrow-to-class)
(should (eq 710 (length (buffer-substring-no-properties (point-min)(point-max)))))))
(ert-deftest py-ert-narrow-to-def-test ()
(py-test-with-temp-buffer
py-def-and-class-test-string
(search-backward "treffer")
(py-narrow-to-def)
(should (< 480 (length (buffer-substring-no-properties (point-min)(point-max)))))))
(ert-deftest py-ert-narrow-to-def-or-class-test ()
(py-test-with-temp-buffer
py-def-and-class-test-string
(search-backward "treffer")
(py-narrow-to-def-or-class)
(should (< 480 (length (buffer-substring-no-properties (point-min)(point-max)))))
(should (> 490 (length (buffer-substring-no-properties (point-min)(point-max)))))))
(ert-deftest py-ert-narrow-to-statement-test ()
(py-test-with-temp-buffer
py-def-and-class-test-string
(search-backward "treffer")
(py-narrow-to-statement)
(should (eq 32 (length (buffer-substring-no-properties (point-min)(point-max)))))))
(ert-deftest py-ert-section-backward-test ()
(py-test-with-temp-buffer
"# {{
print('%(language)s has %(number)03d quote types.' %
{'language': \"Python\", \"number\": 2})
# }}
# {{
print(\"%(language)s has %(number)03d quote types.\" %
{'language': \"Python\", \"number\": 2})
# }}
"
(py-backward-section)
(should (eq (char-after) ?#))
(py-backward-section)
(should (eq (char-after) ?#))))
(ert-deftest py-ert-section-forward-test ()
(py-test-with-temp-buffer-point-min
"# {{
print('%(language)s has %(number)03d quote types.' %
{'language': \"Python\", \"number\": 2})
# }}
# {{
print(\"%(language)s has %(number)03d quote types.\" %
{'language': \"Python\", \"number\": 2})
# }}
"
(py-forward-section)
(should (eq (char-before) ?}))
(py-forward-section)
(should (eq (char-before) ?}))))
(ert-deftest py-ert-sectionize-test ()
(py-test-with-temp-buffer-point-min
"print('%(language)s has %(number)03d quote types.' %
{'language': \"Python\", \"number\": 2})
"
(end-of-line)
(py-sectionize-region (point-min) (point-max))
(goto-char (point-min))
(should (eq (char-after) ?#))
(py-forward-section)
(should (eq (char-before) ?}))))
(ert-deftest py-ert-jump-matching-indent-test ()
(py-test-with-temp-buffer
py-def-and-class-test-string
(search-backward "if ")
(forward-line -1)
(indent-to 12)
(py-backward-block)
(should (eq (current-column) 8))))
(ert-deftest py-ert-fill-plain-string-test ()
(py-test-with-temp-buffer-point-min
"'''asdf' asdf asdf asdf asdf asdfasdf asdfasdf a asdf asdf asdf asdfasdfa asdf asdf asdf asdf asdf' asdf asdf asdf asdf asdfasdf asdfasdf a asdf asdf asdf asdfasdfa asdf asdf asdf asdfasdf' asdf asdf asdf asdf asdfasdf asdfasdf a asdf asdf asdf asdfasdfa asdf asdf asdf asdf
'''"
(forward-char 4)
(fill-paragraph)
(forward-line 1)
(should (not (empty-line-p)))))
(ert-deftest py-ert-nil-docstring-style-lp-1477422-test ()
(py-test-with-temp-buffer-point-min
"def foo():
'''asdf' asdf asdf asdf asdf asdfasdf asdfasdf a asdf asdf asdf asdfasdfa asdf asdf asdf asdf asdf' asdf asdf asdf asdf asdfasdf asdfasdf a asdf asdf asdf asdfasdfa asdf asdf asdf asdfasdf' asdf asdf asdf asdf asdfasdf asdfasdf a asdf asdf asdf asdfasdfa asdf asdf asdf asdf'''"
(let (py-docstring-style)
(search-forward "'''")
(save-excursion
(fill-paragraph))
(forward-line 1)
(should (not (empty-line-p))))))
(ert-deftest py-markup-region-as-section-test ()
(py-test-with-temp-buffer-point-min
py-def-and-class-test-string
(search-forward "fertig")
(py-sectionize-region (match-beginning 0) (line-end-position))
(py-mark-section)
(should (eq 371 (region-beginning)))
(should (eq 408 (region-end)))))
(ert-deftest py-indent-in-docstring-gh6 ()
(py-test-with-temp-buffer-point-min
"def f():
\"\"\"
Return nothing.
.. NOTE::
First note line
second note line\"\"\"
pass"
(search-forward "second")
(back-to-indentation)
(should (eq 8 (py-compute-indentation)))))
(provide 'py-ert-tests-2)
;;; py-ert-tests-2.el ends here
python-mode.el-6.2.3/test/py-ert-tests-3.el 0000644 0000000 0000000 00000042062 13034514444 020351 0 ustar root root 0000000 0000000 ;; py-ert-tests-3.el --- Some more Tests -*- lexical-binding: t; -*-
;; Copyright (C) 2014 Andreas Röhler,
;; 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 .
;;; Commentary:
;;; Code:
;; tests are expected to run from directory test
(add-to-list 'load-path default-directory)
(load "py-ert-tests-1.el" nil t)
;; py-if-name-main-permission-p
(ert-deftest py-ert-if-name-main-permission-lp-326620-test ()
(py-test-with-temp-buffer-point-min
"#! /usr/bin/env python2
# -*- coding: utf-8 -*-
def py_if_name_main_permission_test():
if __name__ == \"__main__\" :
print(\"__name__ == '__main__' run\")
return True
else:
print(\"__name__ == '__main__' supressed\")
return False
py_if_name_main_permission_test()
"
(let ((py-if-name-main-permission-p t))
(py-execute-buffer-python2)
(set-buffer "*Python2*")
(goto-char (point-max))
(forward-line -1)
(end-of-line)
(sit-for 0.2)
(assert (looking-back "run") nil "py-if-name-main-permission-lp-326620-test #1 failed"))))
(ert-deftest py-ert-indent-try-test ()
(py-test-with-temp-buffer-point-min
"#! /usr/bin/env python
import sys
import os
try:"
(search-forward "try")
(should (eq 0 (py-compute-indentation)))))
;; Broken
;; (ert-deftest py-ert-find-definition-test-1 ()
;; (py-test-with-temp-buffer
;; ""
;; (py-find-definition pdb)))
(ert-deftest py-ert-multiple-decorators-test-1 ()
(py-test-with-temp-buffer
"@blah
@blub
def foo():
pass
"
(let ((py-mark-decorators t))
(py-beginning-of-def-or-class)
(should (bobp)))))
(ert-deftest py-ert-multiple-decorators-test-2 ()
(py-test-with-temp-buffer
"@blah
@blub
def foo():
pass
"
(let* (py-mark-decorators
(erg (py-beginning-of-def-or-class)))
(should (eq 13 erg)))))
;; (ert-deftest py-ert-find-definition-test-2 ()
;; (py-test-with-temp-buffer
;; "#! /usr/bin/env python
;; import sys
;; import os
;; def foo ()
;; pass
;; foo()"
;; (beginning-of-line)
;; (sit-for 0.1)
;; (should (string= "def foo" (py-find-definition)))))
(ert-deftest py-ert-async-backward-block-test ()
(py-test-with-temp-buffer
"async def coro(name, lock):
print('coro {}: waiting for lock'.format(name))
async with lock:
print('coro {}: holding the lock'.format(name))
await asyncio.sleep(1)
print('coro {}: releasing the lock'.format(name))"
(py-backward-block)
(should (looking-at "async with"))))
(ert-deftest py-ert-async-backward-def-test ()
(py-test-with-temp-buffer
"async def coro(name, lock):
print('coro {}: waiting for lock'.format(name))
async with lock:
print('coro {}: holding the lock'.format(name))
await asyncio.sleep(1)
print('coro {}: releasing the lock'.format(name))"
(py-backward-def)
(should (looking-at "async def"))))
(ert-deftest py-ert-async-indent-test ()
(py-test-with-temp-buffer-point-min
"async def coro(name, lock):
print('coro {}: waiting for lock'.format(name))
async with lock:
print('coro {}: holding the lock'.format(name))
await asyncio.sleep(1)
print('coro {}: releasing the lock'.format(name))"
(forward-line 1)
(should (eq 4 (py-compute-indentation)))
(forward-line 3)
(should (eq 8 (py-compute-indentation)))))
(ert-deftest py-ert-execute-statement-fast-test ()
(py-test-with-temp-buffer-point-min
"print(123234)"
(py-execute-statement-fast)
(set-buffer (concat "*" (capitalize py-shell-name) " Fast*"))
(should (search-backward "123234"))))
(ert-deftest py-ert-fill-comment-test ()
(py-test-with-temp-buffer-point-min
"class Foo(Bar):
def baz(self):
# Given a winning upgrade path, we can ceiling the maximum image number from that path to be applied. This is useful for image testing purposes. XXX
self.assertEqual([str(image.version) for image in state.winner],
[])"
(search-forward "XXX")
(fill-paragraph)
(search-forward "self")
(back-to-indentation)
(should (eq 8 (current-column)))
(should (eq 6 (count-lines (point-min) (point))))))
(ert-deftest py-ert-parens-span-multiple-lines-lp-1191225-test ()
(py-test-with-temp-buffer-point-min
"# -*- coding: utf-8 -*-
def foo():
if (foo &&
baz):
bar()
# >> This example raises a pep8 warning[0],
# >> I've been dealing with it and manually
# >> adding another indentation level to not leave 'baz' aligned with 'baz
# ()'
# >>
def foo():
if (foo &&
baz):
bar()
"
(let (py-indent-paren-spanned-multilines-p)
(search-forward "b")
(should (eq 8 (py-compute-indentation)))
(search-forward "def foo():")
(search-forward "b")
(setq py-indent-paren-spanned-multilines-p t)
(should (eq 12 (py-compute-indentation))))))
;; (ert-deftest py-raw-docstring-test-1 ()
;; (py-test-with-temp-buffer-point-min
;; "def f():
;; r\"\"\" This is the docstring for my function.It's a raw docstring because I want to type \\t here, and maybe \\n,for example in LaTeX code like \\tau or \\nu.
;; More docstring here.
;; \"\"\"
;; pass"
;; (search-forward "docstring")
;; (py-backward-statement)
;; (sit-for 0.1)
;; (should (eq (char-after) ?r))))
(ert-deftest py-raw-docstring-test-2 ()
(py-test-with-temp-buffer-point-min
"def f():
r\"\"\" This is the docstring for my function.It's a raw docstring because I want to type \\t here, and maybe \\n,for example in LaTeX code like \\tau or \\nu.
More docstring here.
\"\"\"
pass"
(let ((py-docstring-style 'pep-257-nn))
(search-forward "docstring")
(fill-paragraph)
(forward-line 1)
(skip-chars-forward " \t\r\n\f")
(should (eq 4 (current-indentation))))))
(ert-deftest py-ert-backward-indent-test ()
(py-test-with-temp-buffer
"class A(object):
def a(self):
sdfasde
pass
def b(self):
asdef
asdf
pass"
(py-backward-indent)
(should (eq (char-after) ?a))
(py-backward-indent)
(should (eq (char-after) ?d))
(py-backward-indent)
(should (eq (char-after) ?s))))
(ert-deftest py-ert-forward-indent-test-1 ()
(py-test-with-temp-buffer-point-min
"class A(object):
def a(self):
sdfasde
pass
def b(self):
asdef
asdf
pass"
(search-forward "sdf")
(py-forward-indent)
(should (eq (char-before) ?s))))
(ert-deftest py-ert-beginning-of-indent-p-test ()
(py-test-with-temp-buffer-point-min
"class A(object):
def a(self):
sdfasde
pass"
(search-forward "sdfasde")
(should (not (py--beginning-of-indent-p)))
(py-backward-indent)
(should (py--beginning-of-indent-p))))
(ert-deftest py-ert-beginning-of-indent-bol-p-test ()
(py-test-with-temp-buffer-point-min
"class A(object):
def a(self):
sdfasde
pass"
(search-forward "sdfasde")
(should (not (py--beginning-of-indent-bol-p)))
(beginning-of-line)
(should (py--beginning-of-indent-bol-p))))
(ert-deftest py-ert-copy-indent-test ()
(py-test-with-temp-buffer-point-min
"class A(object):
def a(self):
sdfasde
pass"
(search-forward "sdfasde")
(py-copy-indent)
(should (string-match "sdfasde" (car kill-ring)))
(should (not (py--beginning-of-indent-p)))
(py-backward-statement)
(should (py--beginning-of-indent-p))))
(ert-deftest py-ert-delete-indent-test ()
(py-test-with-temp-buffer-point-min
"class A(object):
def a(self):
sdfasde
pass"
(search-forward "sdfasde")
(py-delete-indent)
(should (eobp))
(should (bolp))))
(ert-deftest py-ert-kill-indent-test ()
(py-test-with-temp-buffer-point-min
"class A(object):
def a(self):
sdfasde
pass"
(search-forward "sdfasde")
(py-kill-indent)
(should (string= (concat (make-string 8 ?\ ) "sdfasde\n" (make-string 8 ?\ ) "pass") (car kill-ring)))
(should (eobp))
(should (bolp))))
(ert-deftest py-ert-mark-indent-test ()
(py-test-with-temp-buffer-point-min
"class A(object):
def a(self):
sdfasde
pass"
(search-forward "sdfasde")
(py-mark-indent)
;; (message "%s" (buffer-substring-no-properties (region-beginning) (region-end)))
(should (eq 28 (length (buffer-substring-no-properties (region-beginning) (region-end)))))))
(ert-deftest py-ert-backward-comment-test ()
(py-test-with-temp-buffer-point-min
"class A(object):
def a(self):
# sdfasde
# sdfasde
# sdfasde
print(123)"
(search-forward "sdfasde" nil t 3)
(py-backward-comment)
(should (eq (char-after) ?#))))
(ert-deftest py-ert-forward-comment-test ()
(py-test-with-temp-buffer-point-min
"class A(object):
def a(self):
# sdfasde
# sdfasde
# sdfasde
print(123)"
(search-forward "sdfasde")
(py-forward-comment)
(should (eq (char-before) ?\)))))
(ert-deftest py-ert-shift-indent-test ()
(py-test-with-temp-buffer-point-min
"class A(object):
def a(self):
sdfasde
sdfasde
sdfasde
print(123)"
(search-forward "sdfasde")
(py-shift-indent-right)
(should (eq 12 (current-indentation)))
(py-shift-indent-left)
(should (eq 8 (current-indentation)))))
(ert-deftest py-ert-dont-stop-embedded-def-or-class-test-1 ()
(py-test-with-temp-buffer
"# lp:1545649, C-M-a and C-M-e stop at embedded defs.
class Foo:
def bar(self):
print(\"\"\"
This is
a nested
string.
\"\"\")
"
(py-backward-def-or-class)
(should (eq (char-after) ?c))))
(ert-deftest py-ert-dont-stop-embedded-def-or-class-test-2 ()
(py-test-with-temp-buffer
"# lp:1545649, C-M-a and C-M-e stop at embedded defs.
class Foo:
def bar(self):
print(\"\"\"
This is
a nested
string.
\"\"\")
return True"
(py-backward-def-or-class)
(should (eq (char-after) ?d))))
(ert-deftest py-ert-dont-stop-embedded-class-test ()
(py-test-with-temp-buffer
"# lp:1545649, C-M-a and C-M-e stop at embedded defs.
class Foo:
def bar(self):
class baz
print(\"\"\"
This is
a nested
string.
\"\"\")
"
(py-backward-class)
(should (eq 0 (current-column)))))
(ert-deftest py-ert-dont-stop-embedded-def-test ()
(py-test-with-temp-buffer
"# lp:1545649, C-M-a and C-M-e stop at embedded defs.
def Foo:
class bar(self):
def baz
print(\"\"\"
This is
a nested
string.
\"\"\")
"
(py-backward-def)
(should (eq 0 (current-column)))))
(ert-deftest py-ert-dont-stop-embedded-def-from-string-test ()
(py-test-with-temp-buffer
"# lp:1545649, C-M-a and C-M-e stop at embedded defs.
def Foo:
class bar(self):
def baz
print(\"\"\"
This is
a nested
string.
\"\"\")
"
(search-backward "string")
(skip-chars-backward " \t\r\n\f")
(py-backward-def)
(should (eq (char-after) ?d))))
(ert-deftest py-ert-wrong-indent-inside-string-lp-1574731-test ()
(py-test-with-temp-buffer
"def foo():
print(\"\"\"
Bar
\"\"\")
"
(forward-line -3)
(should (eq 0 (py-compute-indentation)))))
(ert-deftest py-ert-edit-docstring-write-content-back-test ()
(py-test-with-temp-buffer-point-min
"def foo():
\"\"\"def bar():
pass\"\"\"
pass
"
(let ((py-edit-docstring-buffer "Py-Ert-Edit-Docstring-Test"))
(search-forward "pass" nil t 1)
(py-edit-docstring)
(set-buffer "Py-Ert-Edit-Docstring-Test")
(switch-to-buffer (current-buffer))
(goto-char (point-min))
(end-of-line)
(newline)
(insert "'''My edit-docstring ert-test'''")
(beginning-of-line)
(indent-according-to-mode)
(py--write-back-docstring)
;; back in orginial test buffer
(forward-line -1)
(should (and (nth 3 (parse-partial-sexp (point-min) (point)))
(nth 8 (parse-partial-sexp (point-min) (point)))))
)))
(ert-deftest py-ert-nested-def-lp-1594263-test ()
(py-test-with-temp-buffer
"def decoratorFunctionWithArguments(arg1, arg2, arg3):
'''print decorated function call data to stdout.
Usage:
@decoratorFunctionWithArguments('arg1', 'arg2')
def func(a, b, c=True):
pass
'''
def wwrap(f):
print 'Inside wwrap()'
def wrapped_f(\*args):
print 'Inside wrapped_f()'
print 'Decorator arguments:', arg1, arg2, arg3
f(\*args)
print 'After f(\*args)'
return wrapped_f
return wwrap"
(forward-line -1)
(back-to-indentation)
(py-backward-def-or-class)
(should (looking-at "def wwrap"))))
(ert-deftest py--indent-line-by-line-lp-1621672 ()
(py-test-with-temp-buffer
"def asdf()
pass"
(py-indent-region (point-min) (point-max))
(should (eq 4 (current-indentation)))))
(ert-deftest py--indent-line-by-line-lp-1621672-b ()
(py-test-with-temp-buffer
" print(\"asdf\")"
(py-indent-region (point-min) (point-max))
(should (eq 0 (current-indentation)))))
(ert-deftest py-forward-def-or-class-1 ()
(py-test-with-temp-buffer-point-min
"def foo(arg1, arg2, arg3):
'''print decorated function call data to stdout.
'''
def bar(f):
print 'Inside wwrap()'
def wrapped_f(*args):
print 'Inside wrapped_f()'
print 'Decorator arguments:', arg1, arg2, arg3
f(*args)
print 'After f(*args)'
return wrapped_f
return wwrap"
(search-forward "args)'")
(should-not (py-forward-def-or-class))))
(ert-deftest py-forward-block-1 ()
(py-test-with-temp-buffer-point-min
"def foo(arg1, arg2, arg3):
'''print decorated function call data to stdout.
'''
def bar(f):
print 'Inside wwrap()'
def wrapped_f(*args):
print 'Inside wrapped_f()'
print 'Decorator arguments:', arg1, arg2, arg3
f(*args)
print 'After f(*args)'
return wrapped_f
return wwrap"
(search-forward "args)'")
(should-not (py-forward-block))))
(ert-deftest py-forward-clause-lp-1630952-1 ()
(py-test-with-temp-buffer-point-min
"def foo(arg1, arg2, arg3):
'''print decorated function call data to stdout.
'''
def bar(f):
print 'Inside wwrap()'
def wrapped_f(*args):
print 'Inside wrapped_f()'
print 'Decorator arguments:', arg1, arg2, arg3
f(*args)
print 'After f(*args)'
return wrapped_f
return wwrap"
(search-forward "args)'")
(should-not (py-forward-clause))))
(ert-deftest py-forward-clause-lp-1630952-2 ()
(py-test-with-temp-buffer
"def foo(arg1, arg2, arg3):
'''print decorated function call data to stdout.
'''
def bar(f):
print 'Inside wwrap()'
def wrapped_f(*args):
print 'Inside wrapped_f()'
print 'Decorator arguments:', arg1, arg2, arg3
f(*args)
print 'After f(*args)'
return wrapped_f
return wwrap"
(search-backward "wrapped_f")
(end-of-line)
(should-not (py-forward-clause))))
(ert-deftest py-up-block-test-1 ()
(py-test-with-temp-buffer
py-up-text
(search-backward "except True:")
(py-up-block)
(should (looking-at "else"))))
(ert-deftest UnicodeEncodeError-lp-550661-test-1 ()
(py-test-with-temp-buffer
"#! /usr/bin/env python3
print(u'\\xA9')"
(py-execute-buffer)
(set-buffer "*Python3*")
(when (called-interactively-p 'any) (switch-to-buffer (current-buffer)))
(string-match "@" (buffer-substring-no-properties (point-min) (point-max)))))
(ert-deftest py-execute-region-ipython-test-1 ()
(py-test-with-temp-buffer
"#! /usr/bin/env python3
print(u'\\xA9')"
(push-mark)
(beginning-of-line)
(py-execute-region-ipython (region-beginning) (region-end))
(set-buffer "*IPython*")
(string-match "@" (buffer-substring-no-properties (point-min) (point-max)))))
(ert-deftest py-execute-region-no-transmm-test-1 ()
(py-test-with-temp-buffer
"print(u'\\xA9')"
(let (transient-mark-mode)
(push-mark)
(beginning-of-line)
(py-shift-region-right)
(should (eq 4 (current-indentation))))))
(ert-deftest py-forward-statement-test-3 ()
(py-test-with-temp-buffer-point-min
"print('%(language)s has %(number)03d quote types.' %
{'language': \"Python\", \"number\": 2})
print(\"%(language)s has %(number)03d quote types.\" %
{'language': \"Python\", \"number\": 2})"
(py-forward-statement)
(py-forward-statement)
(should (eobp))))
(provide 'py-ert-tests-3)
;;; py-ert-tests-3.el ends here
python-mode.el-6.2.3/test/py-shell-arg-ert-tests.el 0000644 0000000 0000000 00000006576 13011652223 022070 0 ustar root root 0000000 0000000 ;;; py-shell-arg-ert-tests.el --- py-shell ert tests
;; Copyright (C) 2015 Andreas Röhler
;; Author: Andreas Röhler
;; Keywords: languages, convenience
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;; This file is generated by function from python-mode-utils.el - see in
;; directory devel. Edits here might not be persistent.
;;; Code:
(ert-deftest py-ert-python-shell-test ()
(let ((py-python-command-args (list "-i -c\"abc=4\"")))
(py-kill-buffer-unconditional "*Python*")
(python)
(should (buffer-live-p (get-buffer "*Python*")))
(set-buffer (get-buffer "*Python*"))
(should (string= "4" py-result))
(should (< 1 comint-last-input-end))))
(ert-deftest py-ert-python2-shell-test ()
(let ((py-python2-command-args (list "-i -c\"abc=4\"")))
(py-kill-buffer-unconditional "*Python2*")
(python2)
(should (buffer-live-p (get-buffer "*Python2*")))
(set-buffer (get-buffer "*Python2*"))
(should (string= "4" py-result))
(should (< 1 comint-last-input-end))))
(ert-deftest py-ert-python3-shell-test ()
(let ((py-python3-command-args (list "-i -c\"abc=4\"")))
(py-kill-buffer-unconditional "*Python3*")
(python3)
(should (buffer-live-p (get-buffer "*Python3*")))
(set-buffer (get-buffer "*Python3*"))
(should (string= "4" py-result))
(should (< 1 comint-last-input-end))))
(ert-deftest py-ert-ipython-shell-test ()
(let ((py-ipython-command-args (list "-i -c\"abc=4\"")))
(py-kill-buffer-unconditional "*IPython*")
(ipython)
(should (buffer-live-p (get-buffer "*IPython*")))
(set-buffer (get-buffer "*IPython*"))
(should (string= "4" py-result))
(should (< 1 comint-last-input-end))))
(ert-deftest py-ert-ipython2.7-shell-test ()
(let ((py-ipython2.7-command-args (list "-i -c\"abc=4\"")))
(py-kill-buffer-unconditional "*IPython2.7*")
(ipython2.7)
(should (buffer-live-p (get-buffer "*IPython2.7*")))
(set-buffer (get-buffer "*IPython2.7*"))
(should (string= "4" py-result))
(should (< 1 comint-last-input-end))))
(ert-deftest py-ert-ipython3-shell-test ()
(let ((py-ipython3-command-args (list "-i -c\"abc=4\"")))
(py-kill-buffer-unconditional "*IPython3*")
(ipython3)
(should (buffer-live-p (get-buffer "*IPython3*")))
(set-buffer (get-buffer "*IPython3*"))
(should (string= "4" py-result))
(should (< 1 comint-last-input-end))))
(ert-deftest py-ert-jython-shell-test ()
(let ((py-jython-command-args (list "-i -c\"abc=4\"")))
(py-kill-buffer-unconditional "*Jython*")
(jython)
(should (buffer-live-p (get-buffer "*Jython*")))
(set-buffer (get-buffer "*Jython*"))
(should (string= "4" py-result))
(should (< 1 comint-last-input-end))))
(provide 'py-shell-arg-ert-tests)
;;; py-shell-arg-ert-tests.el ends here
python-mode.el-6.2.3/test/py-ert-function-tests.el 0000644 0000000 0000000 00000266070 13015565045 022045 0 ustar root root 0000000 0000000 ;;; py-ert-function-tests.el --- functionp ert tests -*- lexical-binding: t; -*-
;; Copyright (C) 2015 Andreas Röhler
;; Author: Andreas Röhler
;; Keywords: lisp
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;;
;;; Code:
(ert-deftest py-ert-virtualenv-filter-functionp-test ()
(should (functionp 'virtualenv-filter)))
(ert-deftest py-ert-virtualenv-append-path-functionp-test ()
(should (functionp 'virtualenv-append-path)))
(ert-deftest py-ert-virtualenv-add-to-path-functionp-test ()
(should (functionp 'virtualenv-add-to-path)))
(ert-deftest py-ert-virtualenv-current-functionp-test ()
(should (functionp 'virtualenv-current)))
(ert-deftest py-ert-virtualenv-deactivate-functionp-test ()
(should (functionp 'virtualenv-deactivate)))
(ert-deftest py-ert-virtualenv-activate-functionp-test ()
(should (functionp 'virtualenv-activate)))
(ert-deftest py-ert-virtualenv-p-functionp-test ()
(should (functionp 'virtualenv-p)))
(ert-deftest py-ert-virtualenv-workon-complete-functionp-test ()
(should (functionp 'virtualenv-workon-complete)))
(ert-deftest py-ert-virtualenv-workon-functionp-test ()
(should (functionp 'virtualenv-workon)))
(ert-deftest py-ert--beginning-of-block-p-functionp-test ()
(should (functionp 'py--beginning-of-block-p)))
(ert-deftest py-ert--beginning-of-clause-p-functionp-test ()
(should (functionp 'py--beginning-of-clause-p)))
(ert-deftest py-ert--beginning-of-block-or-clause-p-functionp-test ()
(should (functionp 'py--beginning-of-block-or-clause-p)))
(ert-deftest py-ert--beginning-of-def-p-functionp-test ()
(should (functionp 'py--beginning-of-def-p)))
(ert-deftest py-ert--beginning-of-class-p-functionp-test ()
(should (functionp 'py--beginning-of-class-p)))
(ert-deftest py-ert--beginning-of-def-or-class-p-functionp-test ()
(should (functionp 'py--beginning-of-def-or-class-p)))
(ert-deftest py-ert--beginning-of-if-block-p-functionp-test ()
(should (functionp 'py--beginning-of-if-block-p)))
(ert-deftest py-ert--beginning-of-try-block-p-functionp-test ()
(should (functionp 'py--beginning-of-try-block-p)))
(ert-deftest py-ert--beginning-of-minor-block-p-functionp-test ()
(should (functionp 'py--beginning-of-minor-block-p)))
(ert-deftest py-ert--beginning-of-for-block-p-functionp-test ()
(should (functionp 'py--beginning-of-for-block-p)))
(ert-deftest py-ert--beginning-of-top-level-p-functionp-test ()
(should (functionp 'py--beginning-of-top-level-p)))
(ert-deftest py-ert--beginning-of-statement-p-functionp-test ()
(should (functionp 'py--beginning-of-statement-p)))
(ert-deftest py-ert--beginning-of-expression-p-functionp-test ()
(should (functionp 'py--beginning-of-expression-p)))
(ert-deftest py-ert--beginning-of-partial-expression-p-functionp-test ()
(should (functionp 'py--beginning-of-partial-expression-p)))
(ert-deftest py-ert--beginning-of-block-bol-p-functionp-test ()
(should (functionp 'py--beginning-of-block-bol-p)))
(ert-deftest py-ert--beginning-of-clause-bol-p-functionp-test ()
(should (functionp 'py--beginning-of-clause-bol-p)))
(ert-deftest py-ert--beginning-of-block-or-clause-bol-p-functionp-test ()
(should (functionp 'py--beginning-of-block-or-clause-bol-p)))
(ert-deftest py-ert--beginning-of-def-bol-p-functionp-test ()
(should (functionp 'py--beginning-of-def-bol-p)))
(ert-deftest py-ert--beginning-of-class-bol-p-functionp-test ()
(should (functionp 'py--beginning-of-class-bol-p)))
(ert-deftest py-ert--beginning-of-def-or-class-bol-p-functionp-test ()
(should (functionp 'py--beginning-of-def-or-class-bol-p)))
(ert-deftest py-ert--beginning-of-if-block-bol-p-functionp-test ()
(should (functionp 'py--beginning-of-if-block-bol-p)))
(ert-deftest py-ert--beginning-of-try-block-bol-p-functionp-test ()
(should (functionp 'py--beginning-of-try-block-bol-p)))
(ert-deftest py-ert--beginning-of-minor-block-bol-p-functionp-test ()
(should (functionp 'py--beginning-of-minor-block-bol-p)))
(ert-deftest py-ert--beginning-of-for-block-bol-p-functionp-test ()
(should (functionp 'py--beginning-of-for-block-bol-p)))
(ert-deftest py-ert--beginning-of-statement-bol-p-functionp-test ()
(should (functionp 'py--beginning-of-statement-bol-p)))
(ert-deftest py-ert-up-statement-functionp-test ()
(should (functionp 'py-up-statement)))
(ert-deftest py-ert-down-statement-functionp-test ()
(should (functionp 'py-down-statement)))
(ert-deftest py-ert-up-base-functionp-test ()
(should (functionp 'py-up-base)))
(ert-deftest py-ert-down-base-functionp-test ()
(should (functionp 'py-down-base)))
(ert-deftest py-ert-up-block-functionp-test ()
(should (functionp 'py-up-block)))
(ert-deftest py-ert-up-minor-block-functionp-test ()
(should (functionp 'py-up-minor-block)))
(ert-deftest py-ert-up-def-functionp-test ()
(should (functionp 'py-up-def)))
(ert-deftest py-ert-up-class-functionp-test ()
(should (functionp 'py-up-class)))
(ert-deftest py-ert-up-def-or-class-functionp-test ()
(should (functionp 'py-up-def-or-class)))
(ert-deftest py-ert-down-block-functionp-test ()
(should (functionp 'py-down-block)))
(ert-deftest py-ert-down-minor-block-functionp-test ()
(should (functionp 'py-down-minor-block)))
(ert-deftest py-ert-down-def-functionp-test ()
(should (functionp 'py-down-def)))
(ert-deftest py-ert-down-class-functionp-test ()
(should (functionp 'py-down-class)))
(ert-deftest py-ert-down-def-or-class-functionp-test ()
(should (functionp 'py-down-def-or-class)))
(ert-deftest py-ert-up-block-bol-functionp-test ()
(should (functionp 'py-up-block-bol)))
(ert-deftest py-ert-up-minor-block-bol-functionp-test ()
(should (functionp 'py-up-minor-block-bol)))
(ert-deftest py-ert-up-def-bol-functionp-test ()
(should (functionp 'py-up-def-bol)))
(ert-deftest py-ert-up-class-bol-functionp-test ()
(should (functionp 'py-up-class-bol)))
(ert-deftest py-ert-up-def-or-class-bol-functionp-test ()
(should (functionp 'py-up-def-or-class-bol)))
(ert-deftest py-ert-down-block-bol-functionp-test ()
(should (functionp 'py-down-block-bol)))
(ert-deftest py-ert-down-minor-block-bol-functionp-test ()
(should (functionp 'py-down-minor-block-bol)))
(ert-deftest py-ert-down-def-bol-functionp-test ()
(should (functionp 'py-down-def-bol)))
(ert-deftest py-ert-down-class-bol-functionp-test ()
(should (functionp 'py-down-class-bol)))
(ert-deftest py-ert-down-def-or-class-bol-functionp-test ()
(should (functionp 'py-down-def-or-class-bol)))
(ert-deftest py-ert--end-of-statement-position-functionp-test ()
(should (functionp 'py--end-of-statement-position)))
(ert-deftest py-ert--end-of-block-position-functionp-test ()
(should (functionp 'py--end-of-block-position)))
(ert-deftest py-ert--end-of-clause-position-functionp-test ()
(should (functionp 'py--end-of-clause-position)))
(ert-deftest py-ert--end-of-block-or-clause-position-functionp-test ()
(should (functionp 'py--end-of-block-or-clause-position)))
(ert-deftest py-ert--end-of-def-position-functionp-test ()
(should (functionp 'py--end-of-def-position)))
(ert-deftest py-ert--end-of-class-position-functionp-test ()
(should (functionp 'py--end-of-class-position)))
(ert-deftest py-ert--end-of-def-or-class-position-functionp-test ()
(should (functionp 'py--end-of-def-or-class-position)))
(ert-deftest py-ert--end-of-buffer-position-functionp-test ()
(should (functionp 'py--end-of-buffer-position)))
(ert-deftest py-ert--end-of-expression-position-functionp-test ()
(should (functionp 'py--end-of-expression-position)))
(ert-deftest py-ert--end-of-partial-expression-position-functionp-test ()
(should (functionp 'py--end-of-partial-expression-position)))
(ert-deftest py-ert--end-of-minor-block-position-functionp-test ()
(should (functionp 'py--end-of-minor-block-position)))
(ert-deftest py-ert--end-of-if-block-position-functionp-test ()
(should (functionp 'py--end-of-if-block-position)))
(ert-deftest py-ert--end-of-try-block-position-functionp-test ()
(should (functionp 'py--end-of-try-block-position)))
(ert-deftest py-ert--end-of-except-block-position-functionp-test ()
(should (functionp 'py--end-of-except-block-position)))
(ert-deftest py-ert--end-of-top-level-position-functionp-test ()
(should (functionp 'py--end-of-top-level-position)))
(ert-deftest py-ert--end-of-statement-position-bol-functionp-test ()
(should (functionp 'py--end-of-statement-position-bol)))
(ert-deftest py-ert--end-of-block-position-bol-functionp-test ()
(should (functionp 'py--end-of-block-position-bol)))
(ert-deftest py-ert--end-of-clause-position-bol-functionp-test ()
(should (functionp 'py--end-of-clause-position-bol)))
(ert-deftest py-ert--end-of-block-or-clause-position-bol-functionp-test ()
(should (functionp 'py--end-of-block-or-clause-position-bol)))
(ert-deftest py-ert--end-of-def-position-bol-functionp-test ()
(should (functionp 'py--end-of-def-position-bol)))
(ert-deftest py-ert--end-of-class-position-bol-functionp-test ()
(should (functionp 'py--end-of-class-position-bol)))
(ert-deftest py-ert--end-of-minor-block-position-bol-functionp-test ()
(should (functionp 'py--end-of-minor-block-position-bol)))
(ert-deftest py-ert--end-of-if-block-position-bol-functionp-test ()
(should (functionp 'py--end-of-if-block-position-bol)))
(ert-deftest py-ert--end-of-try-block-position-bol-functionp-test ()
(should (functionp 'py--end-of-try-block-position-bol)))
(ert-deftest py-ert-kill-block-functionp-test ()
(should (functionp 'py-kill-block)))
(ert-deftest py-ert-kill-clause-functionp-test ()
(should (functionp 'py-kill-clause)))
(ert-deftest py-ert-kill-block-or-clause-functionp-test ()
(should (functionp 'py-kill-block-or-clause)))
(ert-deftest py-ert-kill-def-functionp-test ()
(should (functionp 'py-kill-def)))
(ert-deftest py-ert-kill-class-functionp-test ()
(should (functionp 'py-kill-class)))
(ert-deftest py-ert-kill-def-or-class-functionp-test ()
(should (functionp 'py-kill-def-or-class)))
(ert-deftest py-ert-kill-if-block-functionp-test ()
(should (functionp 'py-kill-if-block)))
(ert-deftest py-ert-kill-try-block-functionp-test ()
(should (functionp 'py-kill-try-block)))
(ert-deftest py-ert-kill-minor-block-functionp-test ()
(should (functionp 'py-kill-minor-block)))
(ert-deftest py-ert-kill-for-block-functionp-test ()
(should (functionp 'py-kill-for-block)))
(ert-deftest py-ert-kill-top-level-functionp-test ()
(should (functionp 'py-kill-top-level)))
(ert-deftest py-ert-kill-statement-functionp-test ()
(should (functionp 'py-kill-statement)))
(ert-deftest py-ert-kill-expression-functionp-test ()
(should (functionp 'py-kill-expression)))
(ert-deftest py-ert-kill-partial-expression-functionp-test ()
(should (functionp 'py-kill-partial-expression)))
(ert-deftest py-ert-backward-expression-functionp-test ()
(should (functionp 'py-backward-expression)))
(ert-deftest py-ert-forward-expression-functionp-test ()
(should (functionp 'py-forward-expression)))
(ert-deftest py-ert-beginning-of-partial-expression-functionp-test ()
(should (functionp 'py-backward-partial-expression)))
(ert-deftest py-ert-forward-partial-expression-functionp-test ()
(should (functionp 'py-forward-partial-expression)))
(ert-deftest py-ert-beginning-of-line-functionp-test ()
(should (functionp 'py-beginning-of-line)))
(ert-deftest py-ert-end-of-line-functionp-test ()
(should (functionp 'py-end-of-line)))
(ert-deftest py-ert-backward-statement-functionp-test ()
(should (functionp 'py-backward-statement)))
(ert-deftest py-ert-beginning-of-statement-bol-functionp-test ()
(should (functionp 'py-backward-statement-bol)))
(ert-deftest py-ert-end-of-statement-functionp-test ()
(should (functionp 'py-forward-statement)))
(ert-deftest py-ert-end-of-statement-bol-functionp-test ()
(should (functionp 'py-forward-statement-bol)))
(ert-deftest py-ert-backward-decorator-functionp-test ()
(should (functionp 'py-backward-decorator)))
(ert-deftest py-ert-end-of-decorator-functionp-test ()
(should (functionp 'py-forward-decorator)))
(ert-deftest py-ert-forward-line-functionp-test ()
(should (functionp 'py-forward-line)))
(ert-deftest py-ert-go-to-backward-comment-functionp-test ()
(should (functionp 'py-go-to-beginning-of-comment)))
(ert-deftest py-ert--go-to-keyword-functionp-test ()
(should (functionp 'py--go-to-keyword)))
(ert-deftest py-ert--clause-lookup-keyword-functionp-test ()
(should (functionp 'py--clause-lookup-keyword)))
(ert-deftest py-ert-leave-comment-or-string-backward-functionp-test ()
(should (functionp 'py-leave-comment-or-string-backward)))
(ert-deftest py-ert-beginning-of-list-pps-functionp-test ()
(should (functionp 'py-beginning-of-list-pps)))
(ert-deftest py-ert-forward-into-nomenclature-functionp-test ()
(should (functionp 'py-forward-into-nomenclature)))
(ert-deftest py-ert-backward-into-nomenclature-functionp-test ()
(should (functionp 'py-backward-into-nomenclature)))
(ert-deftest py-ert--travel-current-indent-functionp-test ()
(should (functionp 'py--travel-current-indent)))
(ert-deftest py-ert-beginning-of-block-current-column-functionp-test ()
(should (functionp 'py-beginning-of-block-current-column)))
(ert-deftest py-ert--end-of-block-p-functionp-test ()
(should (functionp 'py--end-of-block-p)))
(ert-deftest py-ert--end-of-clause-p-functionp-test ()
(should (functionp 'py--end-of-clause-p)))
(ert-deftest py-ert--end-of-block-or-clause-p-functionp-test ()
(should (functionp 'py--end-of-block-or-clause-p)))
(ert-deftest py-ert--end-of-def-p-functionp-test ()
(should (functionp 'py--end-of-def-p)))
(ert-deftest py-ert--end-of-class-p-functionp-test ()
(should (functionp 'py--end-of-class-p)))
(ert-deftest py-ert--end-of-def-or-class-p-functionp-test ()
(should (functionp 'py--end-of-def-or-class-p)))
(ert-deftest py-ert--end-of-if-block-p-functionp-test ()
(should (functionp 'py--end-of-if-block-p)))
(ert-deftest py-ert--end-of-try-block-p-functionp-test ()
(should (functionp 'py--end-of-try-block-p)))
(ert-deftest py-ert--end-of-minor-block-p-functionp-test ()
(should (functionp 'py--end-of-minor-block-p)))
(ert-deftest py-ert--end-of-for-block-p-functionp-test ()
(should (functionp 'py--end-of-for-block-p)))
(ert-deftest py-ert--end-of-top-level-p-functionp-test ()
(should (functionp 'py--end-of-top-level-p)))
(ert-deftest py-ert--end-of-statement-p-functionp-test ()
(should (functionp 'py--end-of-statement-p)))
(ert-deftest py-ert--end-of-expression-p-functionp-test ()
(should (functionp 'py--end-of-expression-p)))
(ert-deftest py-ert--end-of-block-bol-p-functionp-test ()
(should (functionp 'py--end-of-block-bol-p)))
(ert-deftest py-ert--end-of-clause-bol-p-functionp-test ()
(should (functionp 'py--end-of-clause-bol-p)))
(ert-deftest py-ert--end-of-block-or-clause-bol-p-functionp-test ()
(should (functionp 'py--end-of-block-or-clause-bol-p)))
(ert-deftest py-ert--end-of-def-bol-p-functionp-test ()
(should (functionp 'py--end-of-def-bol-p)))
(ert-deftest py-ert--end-of-class-bol-p-functionp-test ()
(should (functionp 'py--end-of-class-bol-p)))
(ert-deftest py-ert--end-of-def-or-class-bol-p-functionp-test ()
(should (functionp 'py--end-of-def-or-class-bol-p)))
(ert-deftest py-ert--end-of-if-block-bol-p-functionp-test ()
(should (functionp 'py--end-of-if-block-bol-p)))
(ert-deftest py-ert--end-of-try-block-bol-p-functionp-test ()
(should (functionp 'py--end-of-try-block-bol-p)))
(ert-deftest py-ert--end-of-minor-block-bol-p-functionp-test ()
(should (functionp 'py--end-of-minor-block-bol-p)))
(ert-deftest py-ert--end-of-for-block-bol-p-functionp-test ()
(should (functionp 'py--end-of-for-block-bol-p)))
(ert-deftest py-ert--end-of-statement-bol-p-functionp-test ()
(should (functionp 'py--end-of-statement-bol-p)))
(ert-deftest py-ert--fast-completion-get-completions-functionp-test ()
(should (functionp 'py--fast-completion-get-completions)))
(ert-deftest py-ert--fast--do-completion-at-point-functionp-test ()
(should (functionp 'py--fast--do-completion-at-point)))
(ert-deftest py-ert--fast-complete-base-functionp-test ()
(should (functionp 'py--fast-complete-base)))
(ert-deftest py-ert-fast-complete-functionp-test ()
(should (functionp 'py-fast-complete)))
(ert-deftest py-ert--all-shell-mode-setting-functionp-test ()
(should (functionp 'py--all-shell-mode-setting)))
(ert-deftest py-ert-fast-process-functionp-test ()
(should (functionp 'py-fast-process)))
(ert-deftest py-ert--filter-result-functionp-test ()
(should (functionp 'py--filter-result)))
(ert-deftest py-ert--fast-send-string-no-output-functionp-test ()
(should (functionp 'py--fast-send-string-no-output)))
(ert-deftest py-ert--fast-send-string-intern-functionp-test ()
(should (functionp 'py--fast-send-string-intern)))
(ert-deftest py-ert--fast-send-string-functionp-test ()
(should (functionp 'py--fast-send-string)))
(ert-deftest py-ert-fast-send-string-functionp-test ()
(should (functionp 'py--fast-send-string)))
(ert-deftest py-ert-process-region-fast-functionp-test ()
(should (functionp 'py-process-region-fast)))
(ert-deftest py-ert-execute-statement-fast-functionp-test ()
(should (functionp 'py-execute-statement-fast)))
(ert-deftest py-ert-execute-block-fast-functionp-test ()
(should (functionp 'py-execute-block-fast)))
(ert-deftest py-ert-execute-block-or-clause-fast-functionp-test ()
(should (functionp 'py-execute-block-or-clause-fast)))
(ert-deftest py-ert-execute-def-fast-functionp-test ()
(should (functionp 'py-execute-def-fast)))
(ert-deftest py-ert-execute-class-fast-functionp-test ()
(should (functionp 'py-execute-class-fast)))
(ert-deftest py-ert-execute-def-or-class-fast-functionp-test ()
(should (functionp 'py-execute-def-or-class-fast)))
(ert-deftest py-ert-execute-expression-fast-functionp-test ()
(should (functionp 'py-execute-expression-fast)))
(ert-deftest py-ert-execute-partial-expression-fast-functionp-test ()
(should (functionp 'py-execute-partial-expression-fast)))
(ert-deftest py-ert-execute-top-level-fast-functionp-test ()
(should (functionp 'py-execute-top-level-fast)))
(ert-deftest py-ert-execute-clause-fast-functionp-test ()
(should (functionp 'py-execute-clause-fast)))
(ert-deftest py-ert-restore-window-configuration-functionp-test ()
(should (functionp 'py-restore-window-configuration)))
(ert-deftest py-ert-shell-execute-string-now-functionp-test ()
(should (functionp 'py-shell-execute-string-now)))
(ert-deftest py-ert-switch-to-python-functionp-test ()
(should (functionp 'py-switch-to-python)))
(ert-deftest py-ert-send-file-functionp-test ()
(should (functionp 'py-send-file)))
(ert-deftest py-ert-toggle-force-local-shell-functionp-test ()
(should (functionp 'toggle-force-local-shell)))
(ert-deftest py-ert-force-local-shell-on-functionp-test ()
(should (functionp 'py-force-local-shell-on)))
(ert-deftest py-ert-force-local-shell-off-functionp-test ()
(should (functionp 'py-force-local-shell-off)))
(ert-deftest py-ert-toggle-force-py-shell-name-p-functionp-test ()
(should (functionp 'toggle-force-py-shell-name-p)))
(ert-deftest py-ert-force-py-shell-name-p-on-functionp-test ()
(should (functionp 'force-py-shell-name-p-on)))
(ert-deftest py-ert-force-py-shell-name-p-off-functionp-test ()
(should (functionp 'force-py-shell-name-p-off)))
(ert-deftest py-ert-toggle-split-windows-on-execute-functionp-test ()
(should (functionp 'py-toggle-split-windows-on-execute)))
(ert-deftest py-ert-split-windows-on-execute-on-functionp-test ()
(should (functionp 'py-split-windows-on-execute-on)))
(ert-deftest py-ert-split-windows-on-execute-off-functionp-test ()
(should (functionp 'py-split-windows-on-execute-off)))
(ert-deftest py-ert-toggle-shell-switch-buffers-on-execute-functionp-test ()
(should (functionp 'py-toggle-shell-switch-buffers-on-execute)))
(ert-deftest py-ert-shell-switch-buffers-on-execute-on-functionp-test ()
(should (functionp 'py-shell-switch-buffers-on-execute-on)))
(ert-deftest py-ert-shell-switch-buffers-on-execute-off-functionp-test ()
(should (functionp 'py-shell-switch-buffers-on-execute-off)))
(ert-deftest py-ert-guess-default-python-functionp-test ()
(should (functionp 'py-guess-default-python)))
(ert-deftest py-ert-dirstack-hook-functionp-test ()
(should (functionp 'py-dirstack-hook)))
(ert-deftest py-ert-shell-dedicated-functionp-test ()
(should (functionp 'py-shell-dedicated)))
(ert-deftest py-ert-set-ipython-completion-command-string-functionp-test ()
(should (functionp 'py-set-ipython-completion-command-string)))
(ert-deftest py-ert-ipython--module-completion-import-functionp-test ()
(should (functionp 'py-ipython--module-completion-import)))
(ert-deftest py-ert--compose-buffer-name-initials-functionp-test ()
(should (functionp 'py--compose-buffer-name-initials)))
(ert-deftest py-ert--remove-home-directory-from-list-functionp-test ()
(should (functionp 'py--remove-home-directory-from-list)))
(ert-deftest py-ert--choose-buffer-name-functionp-test ()
(should (functionp 'py--choose-buffer-name)))
(ert-deftest py-ert--jump-to-exception-intern-functionp-test ()
(should (functionp 'py--jump-to-exception-intern)))
(ert-deftest py-ert--jump-to-exception-functionp-test ()
(should (functionp 'py--jump-to-exception)))
(ert-deftest py-ert-toggle-split-window-function-functionp-test ()
(should (functionp 'py-toggle-split-window-function)))
(ert-deftest py-ert--manage-windows-set-and-switch-functionp-test ()
(should (functionp 'py--manage-windows-set-and-switch)))
(ert-deftest py-ert--alternative-split-windows-on-execute-function-functionp-test ()
(should (functionp 'py--alternative-split-windows-on-execute-function)))
(ert-deftest py-ert--get-splittable-window-functionp-test ()
(should (functionp 'py--get-splittable-window)))
(ert-deftest py-ert--manage-windows-split-functionp-test ()
(should (functionp 'py--manage-windows-split)))
(ert-deftest py-ert--shell-manage-windows-functionp-test ()
(should (functionp 'py--shell-manage-windows)))
(ert-deftest py-ert-kill-shell-unconditional-functionp-test ()
(should (functionp 'py-kill-shell-unconditional)))
(ert-deftest py-ert-kill-default-shell-unconditional-functionp-test ()
(should (functionp 'py-kill-default-shell-unconditional)))
(ert-deftest py-ert--report-executable-functionp-test ()
(should (functionp 'py--report-executable)))
(ert-deftest py-ert--shell-make-comint-functionp-test ()
(should (functionp 'py--shell-make-comint)))
(ert-deftest py-ert--guess-buffer-name-functionp-test ()
(should (functionp 'py--guess-buffer-name)))
(ert-deftest py-ert--configured-shell-functionp-test ()
(should (functionp 'py--configured-shell)))
(ert-deftest py-ert--grab-prompt-ps1-functionp-test ()
(should (functionp 'py--grab-prompt-ps1)))
(ert-deftest py-ert--start-fast-process-functionp-test ()
(should (functionp 'py--start-fast-process)))
(ert-deftest py-ert-shell-functionp-test ()
(should (functionp 'py-shell)))
(ert-deftest py-ert-shell-get-process-functionp-test ()
(should (functionp 'py-shell-get-process)))
(ert-deftest py-ert-switch-to-shell-functionp-test ()
(should (functionp 'py-switch-to-shell)))
(ert-deftest py-ert-which-execute-file-command-functionp-test ()
(should (functionp 'py-which-execute-file-command)))
(ert-deftest py-ert--store-result-maybe-functionp-test ()
(should (functionp 'py--store-result-maybe)))
(ert-deftest py-ert--close-execution-functionp-test ()
(should (functionp 'py--close-execution)))
(ert-deftest py-ert--execute-base-functionp-test ()
(should (functionp 'py--execute-base)))
(ert-deftest py-ert--send-to-fast-process-functionp-test ()
(should (functionp 'py--send-to-fast-process)))
(ert-deftest py-ert--execute-base-intern-functionp-test ()
(should (functionp 'py--execute-base-intern)))
(ert-deftest py-ert--execute-buffer-finally-functionp-test ()
(should (functionp 'py--execute-buffer-finally)))
(ert-deftest py-ert--fetch-error-functionp-test ()
(should (functionp 'py--fetch-error)))
(ert-deftest py-ert--fetch-result-functionp-test ()
(should (functionp 'py--fetch-result)))
(ert-deftest py-ert--postprocess-comint-functionp-test ()
(should (functionp 'py--postprocess-comint)))
(ert-deftest py-ert--execute-ge24.3-functionp-test ()
(should (functionp 'py--execute-ge24.3)))
(ert-deftest py-ert-delete-temporary-functionp-test ()
(should (functionp 'py-delete-temporary)))
(ert-deftest py-ert-execute-python-mode-v5-functionp-test ()
(should (functionp 'py-execute-python-mode-v5)))
(ert-deftest py-ert--insert-offset-lines-functionp-test ()
(should (functionp 'py--insert-offset-lines)))
(ert-deftest py-ert--execute-file-base-functionp-test ()
(should (functionp 'py--execute-file-base)))
(ert-deftest py-ert-execute-file-functionp-test ()
(should (functionp 'py-execute-file)))
(ert-deftest py-ert--current-working-directory-functionp-test ()
(should (functionp 'py--current-working-directory)))
(ert-deftest py-ert--update-execute-directory-intern-functionp-test ()
(should (functionp 'py--update-execute-directory-intern)))
(ert-deftest py-ert--update-execute-directory-functionp-test ()
(should (functionp 'py--update-execute-directory)))
(ert-deftest py-ert-execute-string-functionp-test ()
(should (functionp 'py-execute-string)))
(ert-deftest py-ert-execute-string-dedicated-functionp-test ()
(should (functionp 'py-execute-string-dedicated)))
(ert-deftest py-ert--insert-execute-directory-functionp-test ()
(should (functionp 'py--insert-execute-directory)))
(ert-deftest py-ert--fix-if-name-main-permission-functionp-test ()
(should (functionp 'py--fix-if-name-main-permission)))
(ert-deftest py-ert--fix-start-functionp-test ()
(should (functionp 'py--fix-start)))
(ert-deftest py-ert-fetch-py-master-file-functionp-test ()
(should (functionp 'py-fetch-py-master-file)))
(ert-deftest py-ert-execute-import-or-reload-functionp-test ()
(should (functionp 'py-execute-import-or-reload)))
(ert-deftest py-ert--qualified-module-name-functionp-test ()
(should (functionp 'py--qualified-module-name)))
(ert-deftest py-ert-execute-buffer-functionp-test ()
(should (functionp 'py-execute-buffer)))
(ert-deftest py-ert-execute-buffer-dedicated-functionp-test ()
(should (functionp 'py-execute-buffer-dedicated)))
(ert-deftest py-ert-execute-buffer-switch-functionp-test ()
(should (functionp 'py-execute-buffer-switch)))
(ert-deftest py-ert-execute-buffer-no-switch-functionp-test ()
(should (functionp 'py-execute-buffer-no-switch)))
(ert-deftest py-ert-execute-buffer-dedicated-switch-functionp-test ()
(should (functionp 'py-execute-buffer-dedicated-switch)))
(ert-deftest py-ert-execute-region-python-functionp-test ()
(should (functionp 'py-execute-region-python)))
(ert-deftest py-ert-execute-region-python-switch-functionp-test ()
(should (functionp 'py-execute-region-python-switch)))
(ert-deftest py-ert-execute-region-python-no-switch-functionp-test ()
(should (functionp 'py-execute-region-python-no-switch)))
(ert-deftest py-ert-execute-region-python2-functionp-test ()
(should (functionp 'py-execute-region-python2)))
(ert-deftest py-ert-execute-region-python2-switch-functionp-test ()
(should (functionp 'py-execute-region-python2-switch)))
(ert-deftest py-ert-execute-region-python2-no-switch-functionp-test ()
(should (functionp 'py-execute-region-python2-no-switch)))
(ert-deftest py-ert-execute-region-python3-functionp-test ()
(should (functionp 'py-execute-region-python3)))
(ert-deftest py-ert-execute-region-python3-switch-functionp-test ()
(should (functionp 'py-execute-region-python3-switch)))
(ert-deftest py-ert-execute-region-python3-no-switch-functionp-test ()
(should (functionp 'py-execute-region-python3-no-switch)))
(ert-deftest py-ert-execute-region-ipython-functionp-test ()
(should (functionp 'py-execute-region-ipython)))
(ert-deftest py-ert-execute-region-ipython-switch-functionp-test ()
(should (functionp 'py-execute-region-ipython-switch)))
(ert-deftest py-ert-execute-region-ipython-no-switch-functionp-test ()
(should (functionp 'py-execute-region-ipython-no-switch)))
(ert-deftest py-ert-execute-region-jython-functionp-test ()
(should (functionp 'py-execute-region-jython)))
(ert-deftest py-ert-execute-region-jython-switch-functionp-test ()
(should (functionp 'py-execute-region-jython-switch)))
(ert-deftest py-ert-execute-region-jython-no-switch-functionp-test ()
(should (functionp 'py-execute-region-jython-no-switch)))
(ert-deftest py-ert-execute-defun-functionp-test ()
(should (functionp 'py-execute-defun)))
(ert-deftest py-ert-process-file-functionp-test ()
(should (functionp 'py-process-file)))
(ert-deftest py-ert-execute-line-functionp-test ()
(should (functionp 'py-execute-line)))
(ert-deftest py-ert-remove-overlays-at-point-functionp-test ()
(should (functionp 'py-remove-overlays-at-point)))
(ert-deftest py-ert-mouseto-exception-functionp-test ()
(should (functionp 'py-mouseto-exception)))
(ert-deftest py-ert-goto-exception-functionp-test ()
(should (functionp 'py-goto-exception)))
(ert-deftest py-ert--find-next-exception-functionp-test ()
(should (functionp 'py--find-next-exception)))
(ert-deftest py-ert-down-exception-functionp-test ()
(should (functionp 'py-down-exception)))
(ert-deftest py-ert-up-exception-functionp-test ()
(should (functionp 'py-up-exception)))
(ert-deftest py-ert--postprocess-intern-functionp-test ()
(should (functionp 'py--postprocess-intern)))
(ert-deftest py-ert--find-next-exception-prepare-functionp-test ()
(should (functionp 'py--find-next-exception-prepare)))
(ert-deftest py-ert-python-functionp-test ()
(should (functionp 'python)))
(ert-deftest py-ert-ipython-functionp-test ()
(should (functionp 'ipython)))
(ert-deftest py-ert-python2-functionp-test ()
(should (functionp 'python2)))
(ert-deftest py-ert-jython-functionp-test ()
(should (functionp 'jython)))
(ert-deftest py-ert-python3-functionp-test ()
(should (functionp 'python3)))
(ert-deftest py-ert-python-dedicated-functionp-test ()
(should (functionp 'python-dedicated)))
(ert-deftest py-ert-ipython-dedicated-functionp-test ()
(should (functionp 'ipython-dedicated)))
(ert-deftest py-ert-python2-dedicated-functionp-test ()
(should (functionp 'python2-dedicated)))
(ert-deftest py-ert-jython-dedicated-functionp-test ()
(should (functionp 'jython-dedicated)))
(ert-deftest py-ert-python3-dedicated-functionp-test ()
(should (functionp 'python3-dedicated)))
(ert-deftest py-ert-python-switch-functionp-test ()
(should (functionp 'python-switch)))
(ert-deftest py-ert-ipython-switch-functionp-test ()
(should (functionp 'ipython-switch)))
(ert-deftest py-ert-python2-switch-functionp-test ()
(should (functionp 'python2-switch)))
(ert-deftest py-ert-jython-switch-functionp-test ()
(should (functionp 'jython-switch)))
(ert-deftest py-ert-python3-switch-functionp-test ()
(should (functionp 'python3-switch)))
(ert-deftest py-ert-python-no-switch-functionp-test ()
(should (functionp 'python-no-switch)))
(ert-deftest py-ert-ipython-no-switch-functionp-test ()
(should (functionp 'ipython-no-switch)))
(ert-deftest py-ert-python2-no-switch-functionp-test ()
(should (functionp 'python2-no-switch)))
(ert-deftest py-ert-jython-no-switch-functionp-test ()
(should (functionp 'jython-no-switch)))
(ert-deftest py-ert-python3-no-switch-functionp-test ()
(should (functionp 'python3-no-switch)))
(ert-deftest py-ert-python-switch-dedicated-functionp-test ()
(should (functionp 'python-switch-dedicated)))
(ert-deftest py-ert-ipython-switch-dedicated-functionp-test ()
(should (functionp 'ipython-switch-dedicated)))
(ert-deftest py-ert-python2-switch-dedicated-functionp-test ()
(should (functionp 'python2-switch-dedicated)))
(ert-deftest py-ert-jython-switch-dedicated-functionp-test ()
(should (functionp 'jython-switch-dedicated)))
(ert-deftest py-ert-python3-switch-dedicated-functionp-test ()
(should (functionp 'python3-switch-dedicated)))
(ert-deftest py-ert-hide-base-functionp-test ()
(should (functionp 'py-hide-base)))
(ert-deftest py-ert-show-base-functionp-test ()
(should (functionp 'py-show-base)))
(ert-deftest py-ert-hide-show-functionp-test ()
(should (functionp 'py-hide-show)))
(ert-deftest py-ert-hide-region-functionp-test ()
(should (functionp 'py-hide-region)))
(ert-deftest py-ert-show-region-functionp-test ()
(should (functionp 'py-show-region)))
(ert-deftest py-ert-hide-statement-functionp-test ()
(should (functionp 'py-hide-statement)))
(ert-deftest py-ert-show-statement-functionp-test ()
(should (functionp 'py-show-statement)))
(ert-deftest py-ert-hide-block-functionp-test ()
(should (functionp 'py-hide-block)))
(ert-deftest py-ert-show-block-functionp-test ()
(should (functionp 'py-show-block)))
(ert-deftest py-ert-hide-clause-functionp-test ()
(should (functionp 'py-hide-clause)))
(ert-deftest py-ert-show-clause-functionp-test ()
(should (functionp 'py-show-clause)))
(ert-deftest py-ert-hide-block-or-clause-functionp-test ()
(should (functionp 'py-hide-block-or-clause)))
(ert-deftest py-ert-show-block-or-clause-functionp-test ()
(should (functionp 'py-show-block-or-clause)))
(ert-deftest py-ert-hide-def-functionp-test ()
(should (functionp 'py-hide-def)))
(ert-deftest py-ert-show-def-functionp-test ()
(should (functionp 'py-show-def)))
(ert-deftest py-ert-hide-class-functionp-test ()
(should (functionp 'py-hide-class)))
(ert-deftest py-ert-show-class-functionp-test ()
(should (functionp 'py-show-class)))
(ert-deftest py-ert-hide-expression-functionp-test ()
(should (functionp 'py-hide-expression)))
(ert-deftest py-ert-show-expression-functionp-test ()
(should (functionp 'py-show-expression)))
(ert-deftest py-ert-hide-partial-expression-functionp-test ()
(should (functionp 'py-hide-partial-expression)))
(ert-deftest py-ert-show-partial-expression-functionp-test ()
(should (functionp 'py-show-partial-expression)))
(ert-deftest py-ert-hide-line-functionp-test ()
(should (functionp 'py-hide-line)))
(ert-deftest py-ert-show-line-functionp-test ()
(should (functionp 'py-show-line)))
(ert-deftest py-ert-hide-top-level-functionp-test ()
(should (functionp 'py-hide-top-level)))
(ert-deftest py-ert-show-top-level-functionp-test ()
(should (functionp 'py-show-top-level)))
(ert-deftest py-ert-copy-statement-functionp-test ()
(should (functionp 'py-copy-statement)))
(ert-deftest py-ert-copy-statement-bol-functionp-test ()
(should (functionp 'py-copy-statement-bol)))
(ert-deftest py-ert-copy-top-level-functionp-test ()
(should (functionp 'py-copy-top-level)))
(ert-deftest py-ert-copy-top-level-bol-functionp-test ()
(should (functionp 'py-copy-top-level-bol)))
(ert-deftest py-ert-copy-block-functionp-test ()
(should (functionp 'py-copy-block)))
(ert-deftest py-ert-copy-block-bol-functionp-test ()
(should (functionp 'py-copy-block-bol)))
(ert-deftest py-ert-copy-clause-functionp-test ()
(should (functionp 'py-copy-clause)))
(ert-deftest py-ert-copy-clause-bol-functionp-test ()
(should (functionp 'py-copy-clause-bol)))
(ert-deftest py-ert-copy-block-or-clause-functionp-test ()
(should (functionp 'py-copy-block-or-clause)))
(ert-deftest py-ert-copy-block-or-clause-bol-functionp-test ()
(should (functionp 'py-copy-block-or-clause-bol)))
(ert-deftest py-ert-copy-def-functionp-test ()
(should (functionp 'py-copy-def)))
(ert-deftest py-ert-copy-def-bol-functionp-test ()
(should (functionp 'py-copy-def-bol)))
(ert-deftest py-ert-copy-class-functionp-test ()
(should (functionp 'py-copy-class)))
(ert-deftest py-ert-copy-class-bol-functionp-test ()
(should (functionp 'py-copy-class-bol)))
(ert-deftest py-ert-copy-def-or-class-functionp-test ()
(should (functionp 'py-copy-def-or-class)))
(ert-deftest py-ert-copy-def-or-class-bol-functionp-test ()
(should (functionp 'py-copy-def-or-class-bol)))
(ert-deftest py-ert-copy-expression-functionp-test ()
(should (functionp 'py-copy-expression)))
(ert-deftest py-ert-copy-expression-bol-functionp-test ()
(should (functionp 'py-copy-expression-bol)))
(ert-deftest py-ert-copy-partial-expression-functionp-test ()
(should (functionp 'py-copy-partial-expression)))
(ert-deftest py-ert-copy-partial-expression-bol-functionp-test ()
(should (functionp 'py-copy-partial-expression-bol)))
(ert-deftest py-ert-copy-minor-block-functionp-test ()
(should (functionp 'py-copy-minor-block)))
(ert-deftest py-ert-copy-minor-block-bol-functionp-test ()
(should (functionp 'py-copy-minor-block-bol)))
(ert-deftest py-ert-statement-functionp-test ()
(should (functionp 'py-statement)))
(ert-deftest py-ert-top-level-functionp-test ()
(should (functionp 'py-top-level)))
(ert-deftest py-ert-block-functionp-test ()
(should (functionp 'py-block)))
(ert-deftest py-ert-clause-functionp-test ()
(should (functionp 'py-clause)))
(ert-deftest py-ert-block-or-clause-functionp-test ()
(should (functionp 'py-block-or-clause)))
(ert-deftest py-ert-def-functionp-test ()
(should (functionp 'py-def)))
(ert-deftest py-ert-class-functionp-test ()
(should (functionp 'py-class)))
(ert-deftest py-ert-def-or-class-functionp-test ()
(should (functionp 'py-def-or-class)))
(ert-deftest py-ert-expression-functionp-test ()
(should (functionp 'py-expression)))
(ert-deftest py-ert-partial-expression-functionp-test ()
(should (functionp 'py-partial-expression)))
(ert-deftest py-ert-minor-block-functionp-test ()
(should (functionp 'py-minor-block)))
(ert-deftest py-ert-output-buffer-filter-functionp-test ()
(should (functionp 'py-output-buffer-filter)))
(ert-deftest py-ert-output-filter-functionp-test ()
(should (functionp 'py-output-filter)))
(ert-deftest py-ert-send-string-functionp-test ()
(should (functionp 'py-send-string)))
(ert-deftest py-ert-copy-statement-functionp-test ()
(should (functionp 'py-copy-statement)))
(ert-deftest py-ert-copy-top-level-functionp-test ()
(should (functionp 'py-copy-top-level)))
(ert-deftest py-ert-copy-block-functionp-test ()
(should (functionp 'py-copy-block)))
(ert-deftest py-ert-copy-clause-functionp-test ()
(should (functionp 'py-copy-clause)))
(ert-deftest py-ert-copy-block-or-clause-functionp-test ()
(should (functionp 'py-copy-block-or-clause)))
(ert-deftest py-ert-copy-def-functionp-test ()
(should (functionp 'py-copy-def)))
(ert-deftest py-ert-copy-class-functionp-test ()
(should (functionp 'py-copy-class)))
(ert-deftest py-ert-copy-def-or-class-functionp-test ()
(should (functionp 'py-copy-def-or-class)))
(ert-deftest py-ert-copy-expression-functionp-test ()
(should (functionp 'py-copy-expression)))
(ert-deftest py-ert-copy-partial-expression-functionp-test ()
(should (functionp 'py-copy-partial-expression)))
(ert-deftest py-ert-copy-minor-block-functionp-test ()
(should (functionp 'py-copy-minor-block)))
(ert-deftest py-ert-delete-statement-functionp-test ()
(should (functionp 'py-delete-statement)))
(ert-deftest py-ert-delete-top-level-functionp-test ()
(should (functionp 'py-delete-top-level)))
(ert-deftest py-ert-delete-block-functionp-test ()
(should (functionp 'py-delete-block)))
(ert-deftest py-ert-delete-clause-functionp-test ()
(should (functionp 'py-delete-clause)))
(ert-deftest py-ert-delete-block-or-clause-functionp-test ()
(should (functionp 'py-delete-block-or-clause)))
(ert-deftest py-ert-delete-def-functionp-test ()
(should (functionp 'py-delete-def)))
(ert-deftest py-ert-delete-class-functionp-test ()
(should (functionp 'py-delete-class)))
(ert-deftest py-ert-delete-def-or-class-functionp-test ()
(should (functionp 'py-delete-def-or-class)))
(ert-deftest py-ert-delete-expression-functionp-test ()
(should (functionp 'py-delete-expression)))
(ert-deftest py-ert-delete-partial-expression-functionp-test ()
(should (functionp 'py-delete-partial-expression)))
(ert-deftest py-ert-delete-minor-block-functionp-test ()
(should (functionp 'py-delete-minor-block)))
(ert-deftest py-ert--beginning-of-statement-position-functionp-test ()
(should (functionp 'py--beginning-of-statement-position)))
(ert-deftest py-ert--beginning-of-block-position-functionp-test ()
(should (functionp 'py--beginning-of-block-position)))
(ert-deftest py-ert--beginning-of-clause-position-functionp-test ()
(should (functionp 'py--beginning-of-clause-position)))
(ert-deftest py-ert--beginning-of-block-or-clause-position-functionp-test ()
(should (functionp 'py--beginning-of-block-or-clause-position)))
(ert-deftest py-ert--beginning-of-def-position-functionp-test ()
(should (functionp 'py--beginning-of-def-position)))
(ert-deftest py-ert--beginning-of-class-position-functionp-test ()
(should (functionp 'py--beginning-of-class-position)))
(ert-deftest py-ert--beginning-of-def-or-class-position-functionp-test ()
(should (functionp 'py--beginning-of-def-or-class-position)))
(ert-deftest py-ert--beginning-of-expression-position-functionp-test ()
(should (functionp 'py--beginning-of-expression-position)))
(ert-deftest py-ert--beginning-of-partial-expression-position-functionp-test ()
(should (functionp 'py--beginning-of-partial-expression-position)))
(ert-deftest py-ert--beginning-of-minor-block-position-functionp-test ()
(should (functionp 'py--beginning-of-minor-block-position)))
(ert-deftest py-ert--beginning-of-if-block-position-functionp-test ()
(should (functionp 'py--beginning-of-if-block-position)))
(ert-deftest py-ert--beginning-of-try-block-position-functionp-test ()
(should (functionp 'py--beginning-of-try-block-position)))
(ert-deftest py-ert--beginning-of-except-block-position-functionp-test ()
(should (functionp 'py--beginning-of-except-block-position)))
(ert-deftest py-ert--beginning-of-statement-position-bol-functionp-test ()
(should (functionp 'py--beginning-of-statement-position-bol)))
(ert-deftest py-ert--beginning-of-block-position-bol-functionp-test ()
(should (functionp 'py--beginning-of-block-position-bol)))
(ert-deftest py-ert--beginning-of-clause-position-bol-functionp-test ()
(should (functionp 'py--beginning-of-clause-position-bol)))
(ert-deftest py-ert--beginning-of-block-or-clause-position-bol-functionp-test ()
(should (functionp 'py--beginning-of-block-or-clause-position-bol)))
(ert-deftest py-ert--beginning-of-def-position-bol-functionp-test ()
(should (functionp 'py--beginning-of-def-position-bol)))
(ert-deftest py-ert--beginning-of-class-position-bol-functionp-test ()
(should (functionp 'py--beginning-of-class-position-bol)))
(ert-deftest py-ert--beginning-of-def-or-class-position-bol-functionp-test ()
(should (functionp 'py--beginning-of-def-or-class-position-bol)))
(ert-deftest py-ert--beginning-of-minor-block-position-bol-functionp-test ()
(should (functionp 'py--beginning-of-minor-block-position-bol)))
(ert-deftest py-ert--beginning-of-if-block-position-bol-functionp-test ()
(should (functionp 'py--beginning-of-if-block-position-bol)))
(ert-deftest py-ert--beginning-of-try-block-position-bol-functionp-test ()
(should (functionp 'py--beginning-of-try-block-position-bol)))
(ert-deftest py-ert--beginning-of-except-block-position-bol-functionp-test ()
(should (functionp 'py--beginning-of-except-block-position-bol)))
(ert-deftest py-ert-fill-string-django-functionp-test ()
(should (functionp 'py-fill-string-django)))
(ert-deftest py-ert-fill-string-onetwo-functionp-test ()
(should (functionp 'py-fill-string-onetwo)))
(ert-deftest py-ert-fill-string-pep-257-functionp-test ()
(should (functionp 'py-fill-string-pep-257)))
(ert-deftest py-ert-fill-string-pep-257-nn-functionp-test ()
(should (functionp 'py-fill-string-pep-257-nn)))
(ert-deftest py-ert-fill-string-symmetric-functionp-test ()
(should (functionp 'py-fill-string-symmetric)))
(ert-deftest py-ert-set-nil-docstring-style-functionp-test ()
(should (functionp 'py-set-nil-docstring-style)))
(ert-deftest py-ert-set-pep-257-nn-docstring-style-functionp-test ()
(should (functionp 'py-set-pep-257-nn-docstring-style)))
(ert-deftest py-ert-set-pep-257-docstring-style-functionp-test ()
(should (functionp 'py-set-pep-257-docstring-style)))
(ert-deftest py-ert-set-django-docstring-style-functionp-test ()
(should (functionp 'py-set-django-docstring-style)))
(ert-deftest py-ert-set-symmetric-docstring-style-functionp-test ()
(should (functionp 'py-set-symmetric-docstring-style)))
(ert-deftest py-ert-set-onetwo-docstring-style-functionp-test ()
(should (functionp 'py-set-onetwo-docstring-style)))
(ert-deftest py-ert-fill-comment-functionp-test ()
(should (functionp 'py-fill-comment)))
(ert-deftest py-ert-fill-labelled-string-functionp-test ()
(should (functionp 'py-fill-labelled-string)))
(ert-deftest py-ert--in-or-behind-or-before-a-docstring-functionp-test ()
(should (functionp 'py--in-or-behind-or-before-a-docstring)))
(ert-deftest py-ert--string-fence-delete-spaces-functionp-test ()
(should (functionp 'py--string-fence-delete-spaces)))
(ert-deftest py-ert--fill-fix-end-functionp-test ()
(should (functionp 'py--fill-fix-end)))
(ert-deftest py-ert--fill-docstring-base-functionp-test ()
(should (functionp 'py--fill-docstring-base)))
(ert-deftest py-ert--fill-docstring-last-line-functionp-test ()
(should (functionp 'py--fill-docstring-last-line)))
(ert-deftest py-ert--fill-docstring-first-line-functionp-test ()
(should (functionp 'py--fill-docstring-first-line)))
(ert-deftest py-ert--fill-docstring-functionp-test ()
(should (functionp 'py--fill-docstring)))
(ert-deftest py-ert-fill-string-functionp-test ()
(should (functionp 'py-fill-string)))
(ert-deftest py-ert-fill-paragraph-functionp-test ()
(should (functionp 'py-fill-paragraph)))
(ert-deftest py-ert-insert-default-shebang-functionp-test ()
(should (functionp 'py-insert-default-shebang)))
(ert-deftest py-ert--top-level-form-p-functionp-test ()
(should (functionp 'py--top-level-form-p)))
(ert-deftest py-ert-indent-line-outmost-functionp-test ()
(should (functionp 'py-indent-line-outmost)))
(ert-deftest py-ert--indent-fix-region-intern-functionp-test ()
(should (functionp 'py--indent-fix-region-intern)))
(ert-deftest py-ert--indent-line-intern-functionp-test ()
(should (functionp 'py--indent-line-intern)))
(ert-deftest py-ert--indent-line-base-functionp-test ()
(should (functionp 'py--indent-line-base)))
(ert-deftest py-ert--calculate-indent-backwards-functionp-test ()
(should (functionp 'py--calculate-indent-backwards)))
(ert-deftest py-ert-indent-line-functionp-test ()
(should (functionp 'py-indent-line)))
(ert-deftest py-ert--delete-trailing-whitespace-functionp-test ()
(should (functionp 'py--delete-trailing-whitespace)))
(ert-deftest py-ert-newline-and-indent-functionp-test ()
(should (functionp 'py-newline-and-indent)))
(ert-deftest py-ert-newline-and-dedent-functionp-test ()
(should (functionp 'py-newline-and-dedent)))
(ert-deftest py-ert-toggle-indent-tabs-mode-functionp-test ()
(should (functionp 'py-toggle-indent-tabs-mode)))
(ert-deftest py-ert-indent-tabs-mode-functionp-test ()
(should (functionp 'py-indent-tabs-mode)))
(ert-deftest py-ert-indent-tabs-mode-on-functionp-test ()
(should (functionp 'py-indent-tabs-mode-on)))
(ert-deftest py-ert-indent-tabs-mode-off-functionp-test ()
(should (functionp 'py-indent-tabs-mode-off)))
(ert-deftest py-ert-guessed-sanity-check-functionp-test ()
(should (functionp 'py-guessed-sanity-check)))
(ert-deftest py-ert--guess-indent-final-functionp-test ()
(should (functionp 'py--guess-indent-final)))
(ert-deftest py-ert--guess-indent-forward-functionp-test ()
(should (functionp 'py--guess-indent-forward)))
(ert-deftest py-ert--guess-indent-backward-functionp-test ()
(should (functionp 'py--guess-indent-backward)))
(ert-deftest py-ert-guess-indent-offset-functionp-test ()
(should (functionp 'py-guess-indent-offset)))
(ert-deftest py-ert--comment-indent-function-functionp-test ()
(should (functionp 'py--comment-indent-function)))
(ert-deftest py-ert-backward-paragraph-functionp-test ()
(should (functionp 'py-backward-paragraph)))
(ert-deftest py-ert-end-of-paragraph-functionp-test ()
(should (functionp 'py-forward-paragraph)))
(ert-deftest py-ert-indent-and-forward-functionp-test ()
(should (functionp 'py-indent-and-forward)))
(ert-deftest py-ert-indent-region-functionp-test ()
(should (functionp 'py-indent-region)))
(ert-deftest py-ert--beginning-of-buffer-position-functionp-test ()
(should (functionp 'py--beginning-of-buffer-position)))
(ert-deftest py-ert-backward-declarations-functionp-test ()
(should (functionp 'py-backward-declarations)))
(ert-deftest py-ert-end-of-declarations-functionp-test ()
(should (functionp 'py-forward-declarations)))
(ert-deftest py-ert-declarations-functionp-test ()
(should (functionp 'py-declarations)))
(ert-deftest py-ert-kill-declarations-functionp-test ()
(should (functionp 'py-kill-declarations)))
(ert-deftest py-ert-backward-statements-functionp-test ()
(should (functionp 'py-backward-statements)))
(ert-deftest py-ert-end-of-statements-functionp-test ()
(should (functionp 'py-forward-statements)))
(ert-deftest py-ert-statements-functionp-test ()
(should (functionp 'py-statements)))
(ert-deftest py-ert-kill-statements-functionp-test ()
(should (functionp 'py-kill-statements)))
(ert-deftest py-ert--join-words-wrapping-functionp-test ()
(should (functionp 'py--join-words-wrapping)))
(ert-deftest py-ert-insert-super-functionp-test ()
(should (functionp 'py-insert-super)))
(ert-deftest py-ert-comment-region-functionp-test ()
(should (functionp 'py-comment-region)))
(ert-deftest py-ert-delete-comments-in-def-or-class-functionp-test ()
(should (functionp 'py-delete-comments-in-def-or-class)))
(ert-deftest py-ert-delete-comments-in-class-functionp-test ()
(should (functionp 'py-delete-comments-in-class)))
(ert-deftest py-ert-delete-comments-in-block-functionp-test ()
(should (functionp 'py-delete-comments-in-block)))
(ert-deftest py-ert-delete-comments-in-region-functionp-test ()
(should (functionp 'py-delete-comments-in-region)))
(ert-deftest py-ert--delete-comments-intern-functionp-test ()
(should (functionp 'py--delete-comments-intern)))
(ert-deftest py-ert-update-gud-pdb-history-functionp-test ()
(should (functionp 'py-update-gud-pdb-history)))
(ert-deftest py-ert--pdbtrack-overlay-arrow-functionp-test ()
(should (functionp 'py--pdbtrack-overlay-arrow)))
(ert-deftest py-ert--pdbtrack-track-stack-file-functionp-test ()
(should (functionp 'py--pdbtrack-track-stack-file)))
(ert-deftest py-ert--pdbtrack-map-filename-functionp-test ()
(should (functionp 'py--pdbtrack-map-filename)))
(ert-deftest py-ert--pdbtrack-get-source-buffer-functionp-test ()
(should (functionp 'py--pdbtrack-get-source-buffer)))
(ert-deftest py-ert--pdbtrack-grub-for-buffer-functionp-test ()
(should (functionp 'py--pdbtrack-grub-for-buffer)))
(ert-deftest py-ert-pdbtrack-toggle-stack-tracking-functionp-test ()
(should (functionp 'py-pdbtrack-toggle-stack-tracking)))
(ert-deftest py-ert-turn-on-pdbtrack-functionp-test ()
(should (functionp 'turn-on-pdbtrack)))
(ert-deftest py-ert-turn-off-pdbtrack-functionp-test ()
(should (functionp 'turn-off-pdbtrack)))
(ert-deftest py-ert-execute-statement-pdb-functionp-test ()
(should (functionp 'py-execute-statement-pdb)))
(ert-deftest py-ert-execute-region-pdb-functionp-test ()
(should (functionp 'py-execute-region-pdb)))
(ert-deftest py-ert-pdb-execute-statement-functionp-test ()
(should (functionp 'py-pdb-execute-statement)))
(ert-deftest py-ert-pdb-help-functionp-test ()
(should (functionp 'py-pdb-help)))
(ert-deftest py-ert-pdb-break-functionp-test ()
(should (functionp 'py-pdb-break)))
(ert-deftest py-ert-end-of-block-functionp-test ()
(should (functionp 'py-forward-block)))
(ert-deftest py-ert-end-of-block-bol-functionp-test ()
(should (functionp 'py-forward-block-bol)))
(ert-deftest py-ert-end-of-clause-functionp-test ()
(should (functionp 'py-forward-clause)))
(ert-deftest py-ert-end-of-clause-bol-functionp-test ()
(should (functionp 'py-forward-clause-bol)))
(ert-deftest py-ert-end-of-block-or-clause-functionp-test ()
(should (functionp 'py-forward-block-or-clause)))
(ert-deftest py-ert-end-of-block-or-clause-bol-functionp-test ()
(should (functionp 'py-forward-block-or-clause-bol)))
(ert-deftest py-ert-end-of-def-functionp-test ()
(should (functionp 'py-forward-def)))
(ert-deftest py-ert-end-of-def-bol-functionp-test ()
(should (functionp 'py-forward-def-bol)))
(ert-deftest py-ert-end-of-class-functionp-test ()
(should (functionp 'py-forward-class)))
(ert-deftest py-ert-end-of-class-bol-functionp-test ()
(should (functionp 'py-forward-class-bol)))
(ert-deftest py-ert-end-of-def-or-class-functionp-test ()
(should (functionp 'py-forward-def-or-class)))
(ert-deftest py-ert-end-of-def-or-class-bol-functionp-test ()
(should (functionp 'py-forward-def-or-class-bol)))
(ert-deftest py-ert-end-of-if-block-functionp-test ()
(should (functionp 'py-forward-if-block)))
(ert-deftest py-ert-end-of-if-block-bol-functionp-test ()
(should (functionp 'py-forward-if-block-bol)))
(ert-deftest py-ert-end-of-try-block-functionp-test ()
(should (functionp 'py-forward-try-block)))
(ert-deftest py-ert-end-of-try-block-bol-functionp-test ()
(should (functionp 'py-forward-try-block-bol)))
(ert-deftest py-ert-end-of-minor-block-functionp-test ()
(should (functionp 'py-forward-minor-block)))
(ert-deftest py-ert-end-of-minor-block-bol-functionp-test ()
(should (functionp 'py-forward-minor-block-bol)))
(ert-deftest py-ert-end-of-for-block-functionp-test ()
(should (functionp 'py-forward-for-block)))
(ert-deftest py-ert-end-of-for-block-bol-functionp-test ()
(should (functionp 'py-forward-for-block-bol)))
(ert-deftest py-ert-end-of-except-block-functionp-test ()
(should (functionp 'py-forward-except-block)))
(ert-deftest py-ert-end-of-except-block-bol-functionp-test ()
(should (functionp 'py-forward-except-block-bol)))
(ert-deftest py-ert-execute-statement-functionp-test ()
(should (functionp 'py-execute-statement)))
(ert-deftest py-ert-execute-block-functionp-test ()
(should (functionp 'py-execute-block)))
(ert-deftest py-ert-execute-block-or-clause-functionp-test ()
(should (functionp 'py-execute-block-or-clause)))
(ert-deftest py-ert-execute-def-functionp-test ()
(should (functionp 'py-execute-def)))
(ert-deftest py-ert-execute-class-functionp-test ()
(should (functionp 'py-execute-class)))
(ert-deftest py-ert-execute-def-or-class-functionp-test ()
(should (functionp 'py-execute-def-or-class)))
(ert-deftest py-ert-execute-expression-functionp-test ()
(should (functionp 'py-execute-expression)))
(ert-deftest py-ert-execute-partial-expression-functionp-test ()
(should (functionp 'py-execute-partial-expression)))
(ert-deftest py-ert-execute-top-level-functionp-test ()
(should (functionp 'py-execute-top-level)))
(ert-deftest py-ert-execute-clause-functionp-test ()
(should (functionp 'py-execute-clause)))
(ert-deftest py-ert--end-of-buffer-position-functionp-test ()
(should (functionp 'py--end-of-buffer-position)))
(ert-deftest py-ert-toggle-highlight-indentation-functionp-test ()
(should (functionp 'py-toggle-highlight-indentation)))
(ert-deftest py-ert-highlight-indentation-off-functionp-test ()
(should (functionp 'py-highlight-indentation-off)))
(ert-deftest py-ert-highlight-indentation-on-functionp-test ()
(should (functionp 'py-highlight-indentation-on)))
(ert-deftest py-ert-toggle-smart-indentation-functionp-test ()
(should (functionp 'py-toggle-smart-indentation)))
(ert-deftest py-ert-smart-indentation-on-functionp-test ()
(should (functionp 'py-smart-indentation-on)))
(ert-deftest py-ert-smart-indentation-off-functionp-test ()
(should (functionp 'py-smart-indentation-off)))
(ert-deftest py-ert-toggle-sexp-function-functionp-test ()
(should (functionp 'py-toggle-sexp-function)))
(ert-deftest py-ert-toggle-autopair-mode-functionp-test ()
(should (functionp 'py-toggle-autopair-mode)))
(ert-deftest py-ert-autopair-mode-on-functionp-test ()
(should (functionp 'py-autopair-mode-on)))
(ert-deftest py-ert-autopair-mode-off-functionp-test ()
(should (functionp 'py-autopair-mode-off)))
(ert-deftest py-ert-toggle-py-smart-operator-mode-p-functionp-test ()
(should (functionp 'toggle-py-smart-operator-mode-p)))
(ert-deftest py-ert-smart-operator-mode-p-on-functionp-test ()
(should (functionp 'py-smart-operator-mode-p-on)))
(ert-deftest py-ert-smart-operator-mode-p-off-functionp-test ()
(should (functionp 'py-smart-operator-mode-p-off)))
(ert-deftest py-ert-toggle-py-switch-buffers-on-execute-p-functionp-test ()
(should (functionp 'toggle-py-switch-buffers-on-execute-p)))
(ert-deftest py-ert-switch-buffers-on-execute-p-on-functionp-test ()
(should (functionp 'py-switch-buffers-on-execute-p-on)))
(ert-deftest py-ert-switch-buffers-on-execute-p-off-functionp-test ()
(should (functionp 'py-switch-buffers-on-execute-p-off)))
(ert-deftest py-ert-toggle-py-split-window-on-execute-functionp-test ()
(should (functionp 'toggle-py-split-window-on-execute)))
(ert-deftest py-ert-split-window-on-execute-on-functionp-test ()
(should (functionp 'py-split-window-on-execute-on)))
(ert-deftest py-ert-split-window-on-execute-off-functionp-test ()
(should (functionp 'py-split-window-on-execute-off)))
(ert-deftest py-ert-toggle-py-fontify-shell-buffer-p-functionp-test ()
(should (functionp 'toggle-py-fontify-shell-buffer-p)))
(ert-deftest py-ert-fontify-shell-buffer-p-on-functionp-test ()
(should (functionp 'py-fontify-shell-buffer-p-on)))
(ert-deftest py-ert-fontify-shell-buffer-p-off-functionp-test ()
(should (functionp 'py-fontify-shell-buffer-p-off)))
(ert-deftest py-ert-toggle-python-mode-v5-behavior-p-functionp-test ()
(should (functionp 'toggle-python-mode-v5-behavior-p)))
(ert-deftest py-ert-python-mode-v5-behavior-p-on-functionp-test ()
(should (functionp 'python-mode-v5-behavior-p-on)))
(ert-deftest py-ert-python-mode-v5-behavior-p-off-functionp-test ()
(should (functionp 'python-mode-v5-behavior-p-off)))
(ert-deftest py-ert-toggle-py-jump-on-exception-functionp-test ()
(should (functionp 'toggle-py-jump-on-exception)))
(ert-deftest py-ert-jump-on-exception-on-functionp-test ()
(should (functionp 'py-jump-on-exception-on)))
(ert-deftest py-ert-jump-on-exception-off-functionp-test ()
(should (functionp 'py-jump-on-exception-off)))
(ert-deftest py-ert-toggle-py-use-current-dir-when-execute-p-functionp-test ()
(should (functionp 'toggle-py-use-current-dir-when-execute-p)))
(ert-deftest py-ert-use-current-dir-when-execute-p-on-functionp-test ()
(should (functionp 'py-use-current-dir-when-execute-p-on)))
(ert-deftest py-ert-use-current-dir-when-execute-p-off-functionp-test ()
(should (functionp 'py-use-current-dir-when-execute-p-off)))
(ert-deftest py-ert-toggle-py-electric-comment-p-functionp-test ()
(should (functionp 'toggle-py-electric-comment-p)))
(ert-deftest py-ert-electric-comment-p-on-functionp-test ()
(should (functionp 'py-electric-comment-p-on)))
(ert-deftest py-ert-electric-comment-p-off-functionp-test ()
(should (functionp 'py-electric-comment-p-off)))
(ert-deftest py-ert-toggle-py-underscore-word-syntax-p-functionp-test ()
(should (functionp 'toggle-py-underscore-word-syntax-p)))
(ert-deftest py-ert-underscore-word-syntax-p-on-functionp-test ()
(should (functionp 'py-underscore-word-syntax-p-on)))
(ert-deftest py-ert-underscore-word-syntax-p-off-functionp-test ()
(should (functionp 'py-underscore-word-syntax-p-off)))
(ert-deftest py-ert-backward-block-functionp-test ()
(should (functionp 'py-backward-block)))
(ert-deftest py-ert-backward-clause-functionp-test ()
(should (functionp 'py-backward-clause)))
(ert-deftest py-ert-beginning-of-block-or-clause-functionp-test ()
(should (functionp 'py-backward-block-or-clause)))
(ert-deftest py-ert-backward-def-functionp-test ()
(should (functionp 'py-backward-def)))
(ert-deftest py-ert-backward-class-functionp-test ()
(should (functionp 'py-backward-class)))
(ert-deftest py-ert-beginning-of-def-or-class-functionp-test ()
(should (functionp 'py-backward-def-or-class)))
(ert-deftest py-ert-beginning-of-if-block-functionp-test ()
(should (functionp 'py-backward-if-block)))
(ert-deftest py-ert-beginning-of-try-block-functionp-test ()
(should (functionp 'py-backward-try-block)))
(ert-deftest py-ert-beginning-of-minor-block-functionp-test ()
(should (functionp 'py-backward-minor-block)))
(ert-deftest py-ert-beginning-of-for-block-functionp-test ()
(should (functionp 'py-backward-for-block)))
(ert-deftest py-ert-beginning-of-except-block-functionp-test ()
(should (functionp 'py-backward-except-block)))
(ert-deftest py-ert-backward-block-bol-functionp-test ()
(should (functionp 'py-backward-block-bol)))
(ert-deftest py-ert-backward-clause-bol-functionp-test ()
(should (functionp 'py-backward-clause-bol)))
(ert-deftest py-ert-backward-block-or-clause-bol-functionp-test ()
(should (functionp 'py-backward-block-or-clause-bol)))
(ert-deftest py-ert-backward-def-bol-functionp-test ()
(should (functionp 'py-backward-def-bol)))
(ert-deftest py-ert-backward-class-bol-functionp-test ()
(should (functionp 'py-backward-class-bol)))
(ert-deftest py-ert-backward-def-or-class-bol-functionp-test ()
(should (functionp 'py-backward-def-or-class-bol)))
(ert-deftest py-ert-backward-if-block-bol-functionp-test ()
(should (functionp 'py-backward-if-block-bol)))
(ert-deftest py-ert-backward-try-block-bol-functionp-test ()
(should (functionp 'py-backward-try-block-bol)))
(ert-deftest py-ert-backward-minor-block-bol-functionp-test ()
(should (functionp 'py-backward-minor-block-bol)))
(ert-deftest py-ert-backward-for-block-bol-functionp-test ()
(should (functionp 'py-backward-for-block-bol)))
(ert-deftest py-ert-backward-except-block-bol-functionp-test ()
(should (functionp 'py-backward-except-block-bol)))
(ert-deftest py-ert-comment-auto-fill-functionp-test ()
(should (functionp 'py-comment-auto-fill)))
(ert-deftest py-ert-comment-auto-fill-on-functionp-test ()
(should (functionp 'py-comment-auto-fill-on)))
(ert-deftest py-ert-comment-auto-fill-off-functionp-test ()
(should (functionp 'py-comment-auto-fill-off)))
(ert-deftest py-ert-backward-elif-block-functionp-test ()
(should (functionp 'py-backward-elif-block)))
(ert-deftest py-ert-backward-else-block-functionp-test ()
(should (functionp 'py-backward-else-block)))
(ert-deftest py-ert-backward-elif-block-bol-functionp-test ()
(should (functionp 'py-backward-elif-block-bol)))
(ert-deftest py-ert-backward-else-block-bol-functionp-test ()
(should (functionp 'py-backward-else-block-bol)))
(ert-deftest py-ert-indent-forward-line-functionp-test ()
(should (functionp 'py-indent-forward-line)))
(ert-deftest py-ert-dedent-forward-line-functionp-test ()
(should (functionp 'py-dedent-forward-line)))
(ert-deftest py-ert-dedent-functionp-test ()
(should (functionp 'py-dedent)))
(ert-deftest py-ert--close-intern-functionp-test ()
(should (functionp 'py--close-intern)))
(ert-deftest py-ert-close-def-functionp-test ()
(should (functionp 'py-close-def)))
(ert-deftest py-ert-close-class-functionp-test ()
(should (functionp 'py-close-class)))
(ert-deftest py-ert-close-block-functionp-test ()
(should (functionp 'py-close-block)))
(ert-deftest py-ert-class-at-point-functionp-test ()
(should (functionp 'py-class-at-point)))
(ert-deftest py-ert-py-match-paren-mode-functionp-test ()
(should (functionp 'py-match-paren-mode)))
(ert-deftest py-ert-py-match-paren-functionp-test ()
(should (functionp 'py-match-paren)))
(ert-deftest py-ert-eva-functionp-test ()
(should (functionp 'eva)))
(ert-deftest py-ert-pst-here-functionp-test ()
(should (functionp 'pst-here)))
(ert-deftest py-ert-printform-insert-functionp-test ()
(should (functionp 'py-printform-insert)))
(ert-deftest py-ert-line-to-printform-python2-functionp-test ()
(should (functionp 'py-line-to-printform-python2)))
(ert-deftest py-ert-boolswitch-functionp-test ()
(should (functionp 'py-boolswitch)))
(ert-deftest py-ert-end-of-elif-block-functionp-test ()
(should (functionp 'py-forward-elif-block)))
(ert-deftest py-ert-end-of-elif-block-bol-functionp-test ()
(should (functionp 'py-forward-elif-block-bol)))
(ert-deftest py-ert-end-of-else-block-functionp-test ()
(should (functionp 'py-forward-else-block)))
(ert-deftest py-ert-end-of-else-block-bol-functionp-test ()
(should (functionp 'py-forward-else-block-bol)))
(ert-deftest py-ert-mark-paragraph-functionp-test ()
(should (functionp 'py-mark-paragraph)))
(ert-deftest py-ert-mark-block-functionp-test ()
(should (functionp 'py-mark-block)))
(ert-deftest py-ert-mark-minor-block-functionp-test ()
(should (functionp 'py-mark-minor-block)))
(ert-deftest py-ert-mark-clause-functionp-test ()
(should (functionp 'py-mark-clause)))
(ert-deftest py-ert-mark-block-or-clause-functionp-test ()
(should (functionp 'py-mark-block-or-clause)))
(ert-deftest py-ert-mark-def-functionp-test ()
(should (functionp 'py-mark-def)))
(ert-deftest py-ert-mark-class-functionp-test ()
(should (functionp 'py-mark-class)))
(ert-deftest py-ert-mark-def-or-class-functionp-test ()
(should (functionp 'py-mark-def-or-class)))
(ert-deftest py-ert-mark-line-functionp-test ()
(should (functionp 'py-mark-line)))
(ert-deftest py-ert-mark-statement-functionp-test ()
(should (functionp 'py-mark-statement)))
(ert-deftest py-ert-mark-comment-functionp-test ()
(should (functionp 'py-mark-comment)))
(ert-deftest py-ert-mark-top-level-functionp-test ()
(should (functionp 'py-mark-top-level)))
(ert-deftest py-ert-mark-partial-expression-functionp-test ()
(should (functionp 'py-mark-partial-expression)))
(ert-deftest py-ert-mark-expression-functionp-test ()
(should (functionp 'py-mark-expression)))
(ert-deftest py-ert--kill-emacs-hook-functionp-test ()
(should (functionp 'py--kill-emacs-hook)))
(ert-deftest py-ert-python-version-functionp-test ()
(should (functionp 'py-python-version)))
(ert-deftest py-ert-version-functionp-test ()
(should (functionp 'py-version)))
(ert-deftest py-ert-history-input-filter-functionp-test ()
(should (functionp 'py-history-input-filter)))
(ert-deftest py-ert-load-file-functionp-test ()
(should (functionp 'py-load-file)))
(ert-deftest py-ert-proc-functionp-test ()
(should (functionp 'py-proc)))
(ert-deftest py-ert--shell-simple-send-functionp-test ()
(should (functionp 'py--shell-simple-send)))
(ert-deftest py-ert-guess-pdb-path-functionp-test ()
(should (functionp 'py-guess-pdb-path)))
(ert-deftest py-ert-switch-shell-functionp-test ()
(should (functionp 'py-switch-shell)))
(ert-deftest py-ert-toggle-local-default-use-functionp-test ()
(should (functionp 'py-toggle-local-default-use)))
(ert-deftest py-ert--input-filter-functionp-test ()
(should (functionp 'py--input-filter)))
(ert-deftest py-ert--set-auto-fill-values-functionp-test ()
(should (functionp 'py--set-auto-fill-values)))
(ert-deftest py-ert--run-auto-fill-timer-functionp-test ()
(should (functionp 'py--run-auto-fill-timer)))
(ert-deftest py-ert-complete-auto-functionp-test ()
(should (functionp 'py-complete-auto)))
(ert-deftest py-ert-set-command-args-functionp-test ()
(should (functionp 'py-set-command-args)))
(ert-deftest py-ert---emacs-version-greater-23-functionp-test ()
(should (functionp 'py---emacs-version-greater-23)))
(ert-deftest py-ert--empty-arglist-indent-functionp-test ()
(should (functionp 'py--empty-arglist-indent)))
(ert-deftest py-ert-symbol-at-point-functionp-test ()
(should (functionp 'py-symbol-at-point)))
(ert-deftest py-ert-kill-buffer-unconditional-functionp-test ()
(should (functionp 'py-kill-buffer-unconditional)))
(ert-deftest py-ert--line-backward-maybe-functionp-test ()
(should (functionp 'py--line-backward-maybe)))
(ert-deftest py-ert--after-empty-line-functionp-test ()
(should (functionp 'py--after-empty-line)))
(ert-deftest py-ert-compute-indentation-functionp-test ()
(should (functionp 'py-compute-indentation)))
(ert-deftest py-ert--fetch-previous-indent-functionp-test ()
(should (functionp 'py--fetch-previous-indent)))
(ert-deftest py-ert-continuation-offset-functionp-test ()
(should (functionp 'py-continuation-offset)))
(ert-deftest py-ert-indentation-of-statement-functionp-test ()
(should (functionp 'py-indentation-of-statement)))
(ert-deftest py-ert-list-beginning-position-functionp-test ()
(should (functionp 'py-list-beginning-position)))
(ert-deftest py-ert-end-of-list-position-functionp-test ()
(should (functionp 'py-end-of-list-position)))
(ert-deftest py-ert--in-comment-p-functionp-test ()
(should (functionp 'py--in-comment-p)))
(ert-deftest py-ert-in-triplequoted-string-p-functionp-test ()
(should (functionp 'py-in-triplequoted-string-p)))
(ert-deftest py-ert-in-string-p-functionp-test ()
(should (functionp 'py-in-string-p)))
(ert-deftest py-ert-in-statement-p-functionp-test ()
(should (functionp 'py-in-statement-p)))
(ert-deftest py-ert-beginning-of-top-level-p-functionp-test ()
(should (functionp 'py-backward-top-level-p)))
(ert-deftest py-ert--beginning-of-line-p-functionp-test ()
(should (functionp 'py--beginning-of-line-p)))
(ert-deftest py-ert--beginning-of-buffer-p-functionp-test ()
(should (functionp 'py--beginning-of-buffer-p)))
(ert-deftest py-ert--beginning-of-paragraph-p-functionp-test ()
(should (functionp 'py--beginning-of-paragraph-p)))
(ert-deftest py-ert--end-of-line-p-functionp-test ()
(should (functionp 'py--end-of-line-p)))
(ert-deftest py-ert--end-of-paragraph-p-functionp-test ()
(should (functionp 'py--end-of-paragraph-p)))
(ert-deftest py-ert--statement-opens-block-p-functionp-test ()
(should (functionp 'py--statement-opens-block-p)))
(ert-deftest py-ert--statement-opens-base-functionp-test ()
(should (functionp 'py--statement-opens-base)))
(ert-deftest py-ert--statement-opens-clause-p-functionp-test ()
(should (functionp 'py--statement-opens-clause-p)))
(ert-deftest py-ert--statement-opens-block-or-clause-p-functionp-test ()
(should (functionp 'py--statement-opens-block-or-clause-p)))
(ert-deftest py-ert--statement-opens-class-p-functionp-test ()
(should (functionp 'py--statement-opens-class-p)))
(ert-deftest py-ert--statement-opens-def-p-functionp-test ()
(should (functionp 'py--statement-opens-def-p)))
(ert-deftest py-ert--statement-opens-def-or-class-p-functionp-test ()
(should (functionp 'py--statement-opens-def-or-class-p)))
(ert-deftest py-ert--record-list-error-functionp-test ()
(should (functionp 'py--record-list-error)))
(ert-deftest py-ert--message-error-functionp-test ()
(should (functionp 'py--message-error)))
(ert-deftest py-ert--end-base-functionp-test ()
(should (functionp 'py--end-base)))
(ert-deftest py-ert--look-downward-for-beginning-functionp-test ()
(should (functionp 'py--look-downward-for-beginning)))
(ert-deftest py-ert-look-downward-for-clause-functionp-test ()
(should (functionp 'py-look-downward-for-clause)))
(ert-deftest py-ert-current-defun-functionp-test ()
(should (functionp 'py-current-defun)))
(ert-deftest py-ert-sort-imports-functionp-test ()
(should (functionp 'py-sort-imports)))
(ert-deftest py-ert--in-literal-functionp-test ()
(should (functionp 'py--in-literal)))
(ert-deftest py-ert-count-lines-functionp-test ()
(should (functionp 'py-count-lines)))
(ert-deftest py-ert--point-functionp-test ()
(should (functionp 'py--point)))
(ert-deftest py-ert-install-search-local-functionp-test ()
(should (functionp 'py-install-search-local)))
(ert-deftest py-ert-install-local-shells-functionp-test ()
(should (functionp 'py-install-local-shells)))
(ert-deftest py-ert--until-found-functionp-test ()
(should (functionp 'py--until-found)))
(ert-deftest py-ert--delay-process-dependent-functionp-test ()
(should (functionp 'py--delay-process-dependent)))
(ert-deftest py-ert--send-string-no-output-functionp-test ()
(should (functionp 'py--send-string-no-output)))
(ert-deftest py-ert--send-string-return-output-functionp-test ()
(should (functionp 'py--send-string-return-output)))
(ert-deftest py-ert-which-def-or-class-functionp-test ()
(should (functionp 'py-which-def-or-class)))
(ert-deftest py-ert--beginning-of-form-intern-functionp-test ()
(should (functionp 'py--beginning-of-form-intern)))
(ert-deftest py-ert--backward-prepare-functionp-test ()
(should (functionp 'py--backward-prepare)))
(ert-deftest py-ert--fetch-first-python-buffer-functionp-test ()
(should (functionp 'py--fetch-first-python-buffer)))
(ert-deftest py-ert-unload-python-el-functionp-test ()
(should (functionp 'py-unload-python-el)))
(ert-deftest py-ert--skip-to-semicolon-backward-functionp-test ()
(should (functionp 'py--skip-to-semicolon-backward)))
(ert-deftest py-ert--end-of-comment-intern-functionp-test ()
(should (functionp 'py--end-of-comment-intern)))
(ert-deftest py-ert--skip-to-comment-or-semicolon-functionp-test ()
(should (functionp 'py--skip-to-comment-or-semicolon)))
(ert-deftest py-ert-backward-top-level-functionp-test ()
(should (functionp 'py-backward-top-level)))
(ert-deftest py-ert-end-of-top-level-functionp-test ()
(should (functionp 'py-forward-top-level)))
(ert-deftest py-ert-end-of-top-level-bol-functionp-test ()
(should (functionp 'py-forward-top-level-bol)))
(ert-deftest py-ert--beginning-of-line-form-functionp-test ()
(should (functionp 'py--beginning-of-line-form)))
(ert-deftest py-ert--mark-base-functionp-test ()
(should (functionp 'py--mark-base)))
(ert-deftest py-ert--mark-base-bol-functionp-test ()
(should (functionp 'py--mark-base-bol)))
(ert-deftest py-ert-mark-base-functionp-test ()
(should (functionp 'py-mark-base)))
(ert-deftest py-ert-beginning-functionp-test ()
(should (functionp 'py-beginning)))
(ert-deftest py-ert-end-functionp-test ()
(should (functionp 'py-end)))
(ert-deftest py-ert-beginning-of-buffer-functionp-test ()
(should (functionp 'py-beginning-of-buffer)))
(ert-deftest py-ert-end-of-buffer-functionp-test ()
(should (functionp 'py-end-of-buffer)))
(ert-deftest py-ert-backward-same-level-functionp-test ()
(should (functionp 'py-backward-same-level)))
(ert-deftest py-ert--end-of-buffer-p-functionp-test ()
(should (functionp 'py--end-of-buffer-p)))
(ert-deftest py-ert--beginning-of-paragraph-position-functionp-test ()
(should (functionp 'py--beginning-of-paragraph-position)))
(ert-deftest py-ert--end-of-paragraph-position-functionp-test ()
(should (functionp 'py--end-of-paragraph-position)))
(ert-deftest py-ert--beginning-of-comment-position-functionp-test ()
(should (functionp 'py--beginning-of-comment-position)))
(ert-deftest py-ert--end-of-comment-position-functionp-test ()
(should (functionp 'py--end-of-comment-position)))
(ert-deftest py-ert-info-lookup-symbol-functionp-test ()
(should (functionp 'py-info-lookup-symbol)))
(ert-deftest py-ert-python-after-info-look-functionp-test ()
(should (functionp 'python-after-info-look)))
(ert-deftest py-ert--warn-tmp-files-left-functionp-test ()
(should (functionp 'py--warn-tmp-files-left)))
(ert-deftest py-ert-fetch-docu-functionp-test ()
(should (functionp 'py-fetch-docu)))
(ert-deftest py-ert-info-current-defun-functionp-test ()
(should (functionp 'py-info-current-defun)))
(ert-deftest py-ert-help-at-point-functionp-test ()
(should (functionp 'py-help-at-point)))
(ert-deftest py-ert--dump-help-string-functionp-test ()
(should (functionp 'py--dump-help-string)))
(ert-deftest py-ert-describe-mode-functionp-test ()
(should (functionp 'py-describe-mode)))
(ert-deftest py-ert-find-definition-functionp-test ()
(should (functionp 'py-find-definition)))
(ert-deftest py-ert-find-imports-functionp-test ()
(should (functionp 'py-find-imports)))
(ert-deftest py-ert-update-imports-functionp-test ()
(should (functionp 'py-update-imports)))
(ert-deftest py-ert-pep8-run-functionp-test ()
(should (functionp 'py-pep8-run)))
(ert-deftest py-ert-pep8-help-functionp-test ()
(should (functionp 'py-pep8-help)))
(ert-deftest py-ert-pylint-run-functionp-test ()
(should (functionp 'py-pylint-run)))
(ert-deftest py-ert-pylint-help-functionp-test ()
(should (functionp 'py-pylint-help)))
(ert-deftest py-ert-pylint-doku-functionp-test ()
(should (functionp 'py-pylint-doku)))
(ert-deftest py-ert-pyflakes-run-functionp-test ()
(should (functionp 'py-pyflakes-run)))
(ert-deftest py-ert-pyflakes-help-functionp-test ()
(should (functionp 'py-pyflakes-help)))
(ert-deftest py-ert-pyflakespep8-run-functionp-test ()
(should (functionp 'py-pyflakespep8-run)))
(ert-deftest py-ert-pyflakespep8-help-functionp-test ()
(should (functionp 'py-pyflakespep8-help)))
(ert-deftest py-ert-pychecker-run-functionp-test ()
(should (functionp 'py-pychecker-run)))
(ert-deftest py-ert-check-command-functionp-test ()
(should (functionp 'py-check-command)))
(ert-deftest py-ert-flake8-run-functionp-test ()
(should (functionp 'py-flake8-run)))
(ert-deftest py-ert-flake8-help-functionp-test ()
(should (functionp 'py-flake8-help)))
(ert-deftest py-ert--string-strip-functionp-test ()
(should (functionp 'py--string-strip)))
(ert-deftest py-ert-nesting-level-functionp-test ()
(should (functionp 'py-nesting-level)))
(ert-deftest py-ert-ffap-module-path-functionp-test ()
(should (functionp 'py-ffap-module-path)))
(ert-deftest py-ert-toggle-flymake-intern-functionp-test ()
(should (functionp 'py-toggle-flymake-intern)))
(ert-deftest py-ert-pylint-flymake-mode-functionp-test ()
(should (functionp 'pylint-flymake-mode)))
(ert-deftest py-ert-pyflakes-flymake-mode-functionp-test ()
(should (functionp 'pyflakes-flymake-mode)))
(ert-deftest py-ert-pychecker-flymake-mode-functionp-test ()
(should (functionp 'pychecker-flymake-mode)))
(ert-deftest py-ert-pep8-flymake-mode-functionp-test ()
(should (functionp 'pep8-flymake-mode)))
(ert-deftest py-ert-pyflakespep8-flymake-mode-functionp-test ()
(should (functionp 'pyflakespep8-flymake-mode)))
(ert-deftest py-ert-variables-state-functionp-test ()
(should (functionp 'variables-state)))
(ert-deftest py-ert-variables-base-state-functionp-test ()
(should (functionp 'variables-base-state)))
(ert-deftest py-ert-smart-operator-check-functionp-test ()
(should (functionp 'py-smart-operator-check)))
(ert-deftest py-ert-autopair-check-functionp-test ()
(should (functionp 'py-autopair-check)))
(ert-deftest py-ert--set-ffap-form-functionp-test ()
(should (functionp 'py--set-ffap-form)))
(ert-deftest py-ert--quote-syntax-functionp-test ()
(should (functionp 'py--quote-syntax)))
(ert-deftest py-ert--python-send-setup-code-intern-functionp-test ()
(should (functionp 'py--python-send-setup-code-intern)))
(ert-deftest py-ert--python-send-completion-setup-code-functionp-test ()
(should (functionp 'py--python-send-completion-setup-code)))
(ert-deftest py-ert--python-send-ffap-setup-code-functionp-test ()
(should (functionp 'py--python-send-ffap-setup-code)))
(ert-deftest py-ert--python-send-eldoc-setup-code-functionp-test ()
(should (functionp 'py--python-send-eldoc-setup-code)))
(ert-deftest py-ert--ipython-import-module-completion-functionp-test ()
(should (functionp 'py--ipython-import-module-completion)))
(ert-deftest py-ert--docstring-p-functionp-test ()
(should (functionp 'py--docstring-p)))
(ert-deftest py-ert--font-lock-syntactic-face-function-functionp-test ()
(should (functionp 'py--font-lock-syntactic-face-function)))
(ert-deftest py-ert-choose-shell-by-shebang-functionp-test ()
(should (functionp 'py-choose-shell-by-shebang)))
(ert-deftest py-ert--choose-shell-by-import-functionp-test ()
(should (functionp 'py--choose-shell-by-import)))
(ert-deftest py-ert-choose-shell-by-path-functionp-test ()
(should (functionp 'py-choose-shell-by-path)))
(ert-deftest py-ert-which-python-functionp-test ()
(should (functionp 'py-which-python)))
(ert-deftest py-ert-python-current-environment-functionp-test ()
(should (functionp 'py-python-current-environment)))
(ert-deftest py-ert--cleanup-process-name-functionp-test ()
(should (functionp 'py--cleanup-process-name)))
(ert-deftest py-ert-choose-shell-functionp-test ()
(should (functionp 'py-choose-shell)))
(ert-deftest py-ert--normalize-directory-functionp-test ()
(should (functionp 'py--normalize-directory)))
(ert-deftest py-ert-install-directory-check-functionp-test ()
(should (functionp 'py-install-directory-check)))
(ert-deftest py-ert-guess-py-install-directory-functionp-test ()
(should (functionp 'py-guess-py-install-directory)))
(ert-deftest py-ert-load-pymacs-functionp-test ()
(should (functionp 'py-load-pymacs)))
(ert-deftest py-ert-set-load-path-functionp-test ()
(should (functionp 'py-set-load-path)))
(ert-deftest py-ert-separator-char-functionp-test ()
(should (functionp 'py-separator-char)))
(ert-deftest py-ert-pps-emacs-version-functionp-test ()
(should (functionp 'pps-emacs-version)))
(ert-deftest py-ert-in-string-or-comment-p-functionp-test ()
(should (functionp 'py-in-string-or-comment-p)))
(ert-deftest py-ert-electric-colon-functionp-test ()
(should (functionp 'py-electric-colon)))
(ert-deftest py-ert-electric-close-functionp-test ()
(should (functionp 'py-electric-close)))
(ert-deftest py-ert-electric-comment-functionp-test ()
(should (functionp 'py-electric-comment)))
(ert-deftest py-ert-empty-out-list-backward-functionp-test ()
(should (functionp 'py-empty-out-list-backward)))
(ert-deftest py-ert-electric-backspace-functionp-test ()
(should (functionp 'py-electric-backspace)))
(ert-deftest py-ert-electric-delete-functionp-test ()
(should (functionp 'py-electric-delete)))
(ert-deftest py-ert-electric-yank-functionp-test ()
(should (functionp 'py-electric-yank)))
(ert-deftest py-ert-backward-comment-functionp-test ()
(should (functionp 'py-backward-comment)))
(ert-deftest py-ert-forward-comment-functionp-test ()
(should (functionp 'py-forward-comment)))
(ert-deftest py-ert-beginning-of-comment-functionp-test ()
(should (functionp 'py-beginning-of-comment)))
(ert-deftest py-ert--uncomment-intern-functionp-test ()
(should (functionp 'py--uncomment-intern)))
(ert-deftest py-ert-uncomment-functionp-test ()
(should (functionp 'py-uncomment)))
(ert-deftest py-ert-comment-block-functionp-test ()
(should (functionp 'py-comment-block)))
(ert-deftest py-ert-comment-minor-block-functionp-test ()
(should (functionp 'py-comment-minor-block)))
(ert-deftest py-ert-comment-top-level-functionp-test ()
(should (functionp 'py-comment-top-level)))
(ert-deftest py-ert-comment-clause-functionp-test ()
(should (functionp 'py-comment-clause)))
(ert-deftest py-ert-comment-block-or-clause-functionp-test ()
(should (functionp 'py-comment-block-or-clause)))
(ert-deftest py-ert-comment-def-functionp-test ()
(should (functionp 'py-comment-def)))
(ert-deftest py-ert-comment-class-functionp-test ()
(should (functionp 'py-comment-class)))
(ert-deftest py-ert-comment-def-or-class-functionp-test ()
(should (functionp 'py-comment-def-or-class)))
(ert-deftest py-ert-comment-statement-functionp-test ()
(should (functionp 'py-comment-statement)))
(ert-deftest py-ert-delete-statement-functionp-test ()
(should (functionp 'py-delete-statement)))
(ert-deftest py-ert-delete-top-level-functionp-test ()
(should (functionp 'py-delete-top-level)))
(ert-deftest py-ert-delete-block-functionp-test ()
(should (functionp 'py-delete-block)))
(ert-deftest py-ert-delete-block-or-clause-functionp-test ()
(should (functionp 'py-delete-block-or-clause)))
(ert-deftest py-ert-delete-def-functionp-test ()
(should (functionp 'py-delete-def)))
(ert-deftest py-ert-delete-class-functionp-test ()
(should (functionp 'py-delete-class)))
(ert-deftest py-ert-delete-def-or-class-functionp-test ()
(should (functionp 'py-delete-def-or-class)))
(ert-deftest py-ert-delete-expression-functionp-test ()
(should (functionp 'py-delete-expression)))
(ert-deftest py-ert-delete-partial-expression-functionp-test ()
(should (functionp 'py-delete-partial-expression)))
(ert-deftest py-ert-delete-minor-block-functionp-test ()
(should (functionp 'py-delete-minor-block)))
(ert-deftest py-ert-switch-imenu-index-function-functionp-test ()
(should (functionp 'py-switch-imenu-index-function)))
(ert-deftest py-ert--imenu-create-index-functionp-test ()
(should (functionp 'py--imenu-create-index)))
(ert-deftest py-ert--imenu-create-index-engine-functionp-test ()
(should (functionp 'py--imenu-create-index-engine)))
(ert-deftest py-ert--imenu-create-index-new-functionp-test ()
(should (functionp 'py--imenu-create-index-new)))
(ert-deftest py-ert-execute-file-python-functionp-test ()
(should (functionp 'py-execute-file-python)))
(ert-deftest py-ert-execute-file-python-switch-functionp-test ()
(should (functionp 'py-execute-file-python-switch)))
(ert-deftest py-ert-execute-file-python-no-switch-functionp-test ()
(should (functionp 'py-execute-file-python-no-switch)))
(ert-deftest py-ert-execute-file-python-dedicated-functionp-test ()
(should (functionp 'py-execute-file-python-dedicated)))
(ert-deftest py-ert-execute-file-python-dedicated-switch-functionp-test ()
(should (functionp 'py-execute-file-python-dedicated-switch)))
(ert-deftest py-ert-execute-file-ipython-functionp-test ()
(should (functionp 'py-execute-file-ipython)))
(ert-deftest py-ert-execute-file-ipython-switch-functionp-test ()
(should (functionp 'py-execute-file-ipython-switch)))
(ert-deftest py-ert-execute-file-ipython-no-switch-functionp-test ()
(should (functionp 'py-execute-file-ipython-no-switch)))
(ert-deftest py-ert-execute-file-ipython-dedicated-functionp-test ()
(should (functionp 'py-execute-file-ipython-dedicated)))
(ert-deftest py-ert-execute-file-ipython-dedicated-switch-functionp-test ()
(should (functionp 'py-execute-file-ipython-dedicated-switch)))
(ert-deftest py-ert-execute-file-python3-functionp-test ()
(should (functionp 'py-execute-file-python3)))
(ert-deftest py-ert-execute-file-python3-switch-functionp-test ()
(should (functionp 'py-execute-file-python3-switch)))
(ert-deftest py-ert-execute-file-python3-no-switch-functionp-test ()
(should (functionp 'py-execute-file-python3-no-switch)))
(ert-deftest py-ert-execute-file-python3-dedicated-functionp-test ()
(should (functionp 'py-execute-file-python3-dedicated)))
(ert-deftest py-ert-execute-file-python3-dedicated-switch-functionp-test ()
(should (functionp 'py-execute-file-python3-dedicated-switch)))
(ert-deftest py-ert-execute-file-python2-functionp-test ()
(should (functionp 'py-execute-file-python2)))
(ert-deftest py-ert-execute-file-python2-switch-functionp-test ()
(should (functionp 'py-execute-file-python2-switch)))
(ert-deftest py-ert-execute-file-python2-no-switch-functionp-test ()
(should (functionp 'py-execute-file-python2-no-switch)))
(ert-deftest py-ert-execute-file-python2-dedicated-functionp-test ()
(should (functionp 'py-execute-file-python2-dedicated)))
(ert-deftest py-ert-execute-file-python2-dedicated-switch-functionp-test ()
(should (functionp 'py-execute-file-python2-dedicated-switch)))
(ert-deftest py-ert-execute-file-jython-functionp-test ()
(should (functionp 'py-execute-file-jython)))
(ert-deftest py-ert-execute-file-jython-switch-functionp-test ()
(should (functionp 'py-execute-file-jython-switch)))
(ert-deftest py-ert-execute-file-jython-no-switch-functionp-test ()
(should (functionp 'py-execute-file-jython-no-switch)))
(ert-deftest py-ert-execute-file-jython-dedicated-functionp-test ()
(should (functionp 'py-execute-file-jython-dedicated)))
(ert-deftest py-ert-execute-file-jython-dedicated-switch-functionp-test ()
(should (functionp 'py-execute-file-jython-dedicated-switch)))
(ert-deftest py-ert--shell-completion-get-completions-functionp-test ()
(should (functionp 'py--shell-completion-get-completions)))
(ert-deftest py-ert--after-change-function-functionp-test ()
(should (functionp 'py--after-change-function)))
(ert-deftest py-ert--try-completion-intern-functionp-test ()
(should (functionp 'py--try-completion-intern)))
(ert-deftest py-ert--try-completion-functionp-test ()
(should (functionp 'py--try-completion)))
(ert-deftest py--shell-do-completion-at-point-functionp-test ()
(should (functionp 'py--shell-do-completion-at-point)))
(ert-deftest py--shell-insert-completion-maybe-functionp-test ()
(should (functionp 'py--shell-insert-completion-maybe)))
(ert-deftest py-ert--complete-base-functionp-test ()
(should (functionp 'py--complete-base)))
(ert-deftest py-ert--complete-prepare-functionp-test ()
(should (functionp 'py--complete-prepare)))
(ert-deftest py-ert-shell-complete-functionp-test ()
(should (functionp 'py-shell-complete)))
(ert-deftest py-ert-indent-or-complete-functionp-test ()
(should (functionp 'py-indent-or-complete)))
(ert-deftest py-ert-shift-left-functionp-test ()
(should (functionp 'py-shift-left)))
(ert-deftest py-ert-shift-right-functionp-test ()
(should (functionp 'py-shift-right)))
(ert-deftest py-ert--shift-intern-functionp-test ()
(should (functionp 'py--shift-intern)))
(ert-deftest py-ert--shift-forms-base-functionp-test ()
(should (functionp 'py--shift-forms-base)))
(ert-deftest py-ert-shift-paragraph-right-functionp-test ()
(should (functionp 'py-shift-paragraph-right)))
(ert-deftest py-ert-shift-paragraph-left-functionp-test ()
(should (functionp 'py-shift-paragraph-left)))
(ert-deftest py-ert-shift-block-right-functionp-test ()
(should (functionp 'py-shift-block-right)))
(ert-deftest py-ert-shift-block-left-functionp-test ()
(should (functionp 'py-shift-block-left)))
(ert-deftest py-ert-shift-minor-block-left-functionp-test ()
(should (functionp 'py-shift-minor-block-left)))
(ert-deftest py-ert-shift-minor-block-right-functionp-test ()
(should (functionp 'py-shift-minor-block-right)))
(ert-deftest py-ert-shift-clause-right-functionp-test ()
(should (functionp 'py-shift-clause-right)))
(ert-deftest py-ert-shift-clause-left-functionp-test ()
(should (functionp 'py-shift-clause-left)))
(ert-deftest py-ert-shift-block-or-clause-right-functionp-test ()
(should (functionp 'py-shift-block-or-clause-right)))
(ert-deftest py-ert-shift-block-or-clause-left-functionp-test ()
(should (functionp 'py-shift-block-or-clause-left)))
(ert-deftest py-ert-shift-def-right-functionp-test ()
(should (functionp 'py-shift-def-right)))
(ert-deftest py-ert-shift-def-left-functionp-test ()
(should (functionp 'py-shift-def-left)))
(ert-deftest py-ert-shift-class-right-functionp-test ()
(should (functionp 'py-shift-class-right)))
(ert-deftest py-ert-shift-class-left-functionp-test ()
(should (functionp 'py-shift-class-left)))
(ert-deftest py-ert-shift-def-or-class-right-functionp-test ()
(should (functionp 'py-shift-def-or-class-right)))
(ert-deftest py-ert-shift-def-or-class-left-functionp-test ()
(should (functionp 'py-shift-def-or-class-left)))
(ert-deftest py-ert-shift-statement-right-functionp-test ()
(should (functionp 'py-shift-statement-right)))
(ert-deftest py-ert-shift-statement-left-functionp-test ()
(should (functionp 'py-shift-statement-left)))
(ert-deftest py-ert-end-of-block-functionp-test ()
(should (functionp 'py-forward-block)))
(ert-deftest py-ert-end-of-clause-functionp-test ()
(should (functionp 'py-forward-clause)))
(ert-deftest py-ert-end-of-block-or-clause-functionp-test ()
(should (functionp 'py-forward-block-or-clause)))
(ert-deftest py-ert-end-of-def-functionp-test ()
(should (functionp 'py-forward-def)))
(ert-deftest py-ert-end-of-class-functionp-test ()
(should (functionp 'py-forward-class)))
(provide 'py-ert-function-tests)
;;; py-ert-function-tests.el ends here
python-mode.el-6.2.3/test/py-ert-beginning-tests.el 0000644 0000000 0000000 00000023722 13011652223 022142 0 ustar root root 0000000 0000000 ;;; py-ert-beginning-tests.el --- Just some more tests
;; Copyright (C) 2011-2014 Andreas Röhler
;; Author: Andreas Röhler
;; Keywords: languages, convenience
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;; This file is generated by function from python-mode-utils.el - see in
;; directory devel. Edits here might not be persistent.
;;; Code:
(ert-deftest py-ert-beginning-of-block-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-block)
(should (eq (char-after) ?f))))
(ert-deftest py-ert-beginning-of-clause-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-clause)
(should (eq (char-after) ?f))))
(ert-deftest py-ert-beginning-of-block-or-clause-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-block-or-clause)
(should (eq (char-after) ?f))))
(ert-deftest py-ert-beginning-of-def-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-def)
(should (eq (char-after) ?d))))
(ert-deftest py-ert-beginning-of-class-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-class)
(should (eq (char-after) ?c))))
(ert-deftest py-ert-beginning-of-def-or-class-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-def-or-class)
(should (eq (char-after) ?d))))
(ert-deftest py-ert-beginning-of-if-block-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-if-block)
(should (eq (char-after) ?i))))
(ert-deftest py-ert-beginning-of-try-block-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-try-block)
(should (eq (char-after) ?t))))
(ert-deftest py-ert-beginning-of-minor-block-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-minor-block)
(should (eq (char-after) ?f))))
(ert-deftest py-ert-beginning-of-for-block-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-for-block)
(should (eq (char-after) ?f))))
(ert-deftest py-ert-beginning-of-top-level-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-top-level)
(should (eq (char-after) ?c))))
(ert-deftest py-ert-beginning-of-statement-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-statement)
(should (eq (char-after) ?f))))
(ert-deftest py-ert-beginning-of-expression-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-expression)
(should (eq (char-after) ?r))))
(ert-deftest py-ert-beginning-of-partial-expression-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-partial-expression)
(should (eq (char-after) ?r))))
(ert-deftest py-ert-beginning-of-block-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-block-bol)
(should (eq (char-after) ?\ ))))
(ert-deftest py-ert-beginning-of-clause-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-clause-bol)
(should (eq (char-after) ?\ ))))
(ert-deftest py-ert-beginning-of-block-or-clause-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-block-or-clause-bol)
(should (eq (char-after) ?\ ))))
(ert-deftest py-ert-beginning-of-def-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-def-bol)
(should (eq (char-after) ?\ ))))
(ert-deftest py-ert-beginning-of-class-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-class-bol)
(should (eq (char-after) ?c))))
(ert-deftest py-ert-beginning-of-def-or-class-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-def-or-class-bol)
(should (eq (char-after) ?\ ))))
(ert-deftest py-ert-beginning-of-if-block-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-if-block-bol)
(should (eq (char-after) ?\ ))))
(ert-deftest py-ert-beginning-of-try-block-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-try-block-bol)
(should (eq (char-after) ?\ ))))
(ert-deftest py-ert-beginning-of-minor-block-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-minor-block-bol)
(should (eq (char-after) ?\ ))))
(ert-deftest py-ert-beginning-of-for-block-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-for-block-bol)
(should (eq (char-after) ?\ ))))
(ert-deftest py-ert-beginning-of-statement-bol-test ()
(py-test-with-temp-buffer
"
# -*- coding: utf-8 -*-
class bar:
def foo ():
try:
if True:
for a in range(anzahl):
pass
except:
block2
"
(forward-line -3)
(py-backward-statement-bol)
(should (eq (char-after) ?\ ))))
(provide 'py-ert-beginning-tests)
;;; py-ert-beginning-tests.el ends here
python-mode.el-6.2.3/test/py-ert-always-split-lp-1361531-tests.el 0000644 0000000 0000000 00000007515 13011652223 024067 0 ustar root root 0000000 0000000 ;;; py-ert-always-split-lp-1361531-tests.el --- Test splitting
;; Copyright (C) 2011-2014 Andreas Röhler
;; Author: Andreas Röhler
;; Keywords: languages, convenience
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;; This file is generated by function from python-mode-utils.el - see in
;; directory devel. Edits here might not be persistent.
;;; Code:
(ert-deftest py-ert-always-split-dedicated-lp-1361531-python-test ()
(py-test-with-temp-buffer
"#! /usr/bin/env python
# -*- coding: utf-8 -*-
print(\"I'm the py-always-split-dedicated-lp-1361531-python-test\")"
(delete-other-windows)
(let* ((py-split-window-on-execute 'always)
(erg1 (progn (py-execute-statement-python-dedicated) py-buffer-name))
(erg2 (progn (py-execute-statement-python-dedicated) py-buffer-name)))
(sit-for 1 t)
(when py-debug-p (message "(count-windows) %s" (count-windows)))
(should (< 2 (count-windows)))
(py-kill-buffer-unconditional erg1)
(py-kill-buffer-unconditional erg2)
(py-restore-window-configuration))))
(ert-deftest py-ert-always-split-dedicated-lp-1361531-ipython-test ()
(py-test-with-temp-buffer
"#! /usr/bin/env ipython
# -*- coding: utf-8 -*-
print(\"I'm the py-always-split-dedicated-lp-1361531-ipython-test\")"
(delete-other-windows)
(let* ((py-split-window-on-execute 'always)
(erg1 (progn (py-execute-statement-ipython-dedicated) py-buffer-name))
(erg2 (progn (py-execute-statement-ipython-dedicated) py-buffer-name)))
(sit-for 1 t)
(when py-debug-p (message "(count-windows) %s" (count-windows)))
(should (< 2 (count-windows)))
(py-kill-buffer-unconditional erg1)
(py-kill-buffer-unconditional erg2)
(py-restore-window-configuration))))
(ert-deftest py-ert-always-split-dedicated-lp-1361531-jython-test ()
(py-test-with-temp-buffer
"#! /usr/bin/env jython
# -*- coding: utf-8 -*-
print(\"I'm the py-always-split-dedicated-lp-1361531-jython-test\")"
(delete-other-windows)
(let* ((py-split-window-on-execute 'always)
(erg1 (progn (py-execute-statement-jython-dedicated) py-buffer-name))
(erg2 (progn (py-execute-statement-jython-dedicated) py-buffer-name)))
(sit-for 1 t)
(when py-debug-p (message "(count-windows) %s" (count-windows)))
(should (< 2 (count-windows)))
(py-kill-buffer-unconditional erg1)
(py-kill-buffer-unconditional erg2)
(py-restore-window-configuration))))
(ert-deftest py-ert-always-split-dedicated-lp-1361531-python3-test ()
(py-test-with-temp-buffer
"#! /usr/bin/env python3
# -*- coding: utf-8 -*-
print(\"I'm the py-always-split-dedicated-lp-1361531-python3-test\")"
(delete-other-windows)
(let* ((py-split-window-on-execute 'always)
(erg1 (progn (py-execute-statement-python3-dedicated) py-buffer-name))
(erg2 (progn (py-execute-statement-python3-dedicated) py-buffer-name)))
(sit-for 1 t)
(when py-debug-p (message "(count-windows) %s" (count-windows)))
(should (< 2 (count-windows)))
(py-kill-buffer-unconditional erg1)
(py-kill-buffer-unconditional erg2)
(py-restore-window-configuration))))
;; py-ert-always-split-lp-1361531-tests.el ends here
(provide 'py-ert-always-split-lp-1361531-tests)
python-mode.el-6.2.3/test/py-ert-just-two-split-lp-1361531-tests.el 0000644 0000000 0000000 00000006253 13011652223 024361 0 ustar root root 0000000 0000000 ;;; py-ert-just-two-split-lp-1361531-tests.el --- Test splitting
;; Copyright (C) 2011-2014 Andreas Röhler
;; Author: Andreas Röhler
;; Keywords: languages, convenience
;; This program 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.
;; This program 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 this program. If not, see .
;;; Commentary:
;; This file is generated by function from python-mode-utils.el - see in
;; directory devel. Edits here might not be persistent.
;;; Code:
(ert-deftest py-ert-just-two-split-dedicated-lp-1361531-python-test ()
(py-test-with-temp-buffer
"#! /usr/bin/env python
# -*- coding: utf-8 -*-
print(\"I'm the py-just-two-split-dedicated-lp-1361531-python-test\")"
(delete-other-windows)
(let* ((py-split-window-on-execute 'just-two)
(erg1 (progn (py-execute-statement-python-dedicated) py-buffer-name))
(erg2 (progn (py-execute-statement-python-dedicated) py-buffer-name)))
(sit-for 1 t)
(when py-debug-p (message "(count-windows) %s" (count-windows)))
(should (eq 2 (count-windows)))
(py-kill-buffer-unconditional erg1)
(py-kill-buffer-unconditional erg2)
(py-restore-window-configuration))))
(ert-deftest py-ert-just-two-split-dedicated-lp-1361531-python2-test ()
(py-test-with-temp-buffer
"#! /usr/bin/env python2
# -*- coding: utf-8 -*-
print(\"I'm the py-just-two-split-dedicated-lp-1361531-python2-test\")"
(delete-other-windows)
(let* ((py-split-window-on-execute 'just-two)
(erg1 (progn (py-execute-statement-python2-dedicated) py-buffer-name))
(erg2 (progn (py-execute-statement-python2-dedicated) py-buffer-name)))
(sit-for 1 t)
(when py-debug-p (message "(count-windows) %s" (count-windows)))
(should (eq 2 (count-windows)))
(py-kill-buffer-unconditional erg1)
(py-kill-buffer-unconditional erg2)
(py-restore-window-configuration))))
(ert-deftest py-ert-just-two-split-dedicated-lp-1361531-python3-test ()
(py-test-with-temp-buffer
"#! /usr/bin/env python3
# -*- coding: utf-8 -*-
print(\"I'm the py-just-two-split-dedicated-lp-1361531-python3-test\")"
(delete-other-windows)
(let* ((py-split-window-on-execute 'just-two)
(erg1 (progn (py-execute-statement-python3-dedicated) py-buffer-name))
(erg2 (progn (py-execute-statement-python3-dedicated) py-buffer-name)))
(sit-for 1 t)
(when py-debug-p (message "(count-windows) %s" (count-windows)))
(should (eq 2 (count-windows)))
(py-kill-buffer-unconditional erg1)
(py-kill-buffer-unconditional erg2)
(py-restore-window-configuration))))
;; py-ert-just-two-split-lp-1361531-tests.el ends here
(provide 'py-ert-just-two-split-lp-1361531-tests)
python-mode.el-6.2.3/test/doctest-mode.el 0000644 0000000 0000000 00000246151 12660433546 020234 0 ustar root root 0000000 0000000 ;;; doctest-mode.el --- Major mode for editing Python doctest files
;; Copyright (C) 2004-2007 Edward Loper
;; Author: Edward Loper
;; Maintainer: edloper@alum.mit.edu
;; Created: Aug 2004
;; Keywords: python doctest unittest test docstring
(defconst doctest-version "0.5 alpha"
"`doctest-mode' version number.")
;; This software is provided as-is, without express or implied
;; warranty. Permission to use, copy, modify, distribute or sell this
;; software, without fee, for any purpose and by any individual or
;; organization, is hereby granted, provided that the above copyright
;; notice and this paragraph appear in all copies.
;; This is a major mode for editing text files that contain Python
;; doctest examples. Doctest is a testing framework for Python that
;; emulates an interactive session, and checks the result of each
;; command. For more information, see the Python library reference:
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Table of Contents
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 1. Customization: use-editable variables to customize
;; doctest-mode.
;;
;; 2. Fonts: defines new font-lock faces.
;;
;; 3. Constants: various consts (mainly regexps) used by the rest
;; of the code.
;;
;; 4. Syntax Highlighting: defines variables and functions used by
;; font-lock-mode to perform syntax highlighting.
;;
;; 5. Source code editing & indentation: commands used to
;; automatically indent, dedent, & handle prompts.
;;
;; 6. Code Execution: commands used to start doctest processes,
;; and handle their output.
;;
;; 7. Markers: functions used to insert markers at the start of
;; doctest examples. These are used to keep track of the
;; correspondence between examples in the source buffer and
;; results in the output buffer.
;;
;; 8. Navigation: commands used to navigate between failed examples.
;;
;; 9. Replace Output: command used to replace a doctest example's
;; expected output with its actual output.
;;
;; 10. Helper functions: various helper functions used by the rest
;; of the code.
;;
;; 11. Emacs compatibility functions: defines compatible versions of
;; functions that are defined for some versions of emacs but not
;; others.
;;
;; 12. Doctest Results Mode: defines doctest-results-mode, which is
;; used for the output generated by doctest.
;;
;; 13. Doctest Mode: defines doctest-mode itself.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Customizable Constants
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defgroup doctest nil
"Support for the Python doctest framework"
:group 'languages
:prefix "doctest-")
(defcustom doctest-default-margin 4
"The default pre-prompt margin for doctest examples."
:type 'integer
:group 'doctest)
(defcustom doctest-avoid-trailing-whitespace t
"If true, then delete trailing whitespace when inserting a newline."
:type 'boolean
:group 'doctest)
(defcustom doctest-temp-directory
(let ((ok '(lambda (x)
(and x
(setq x (expand-file-name x)) ; always true
(file-directory-p x)
(file-writable-p x)
x))))
(or (funcall ok (getenv "TMPDIR"))
(funcall ok "/usr/tmp")
(funcall ok "/tmp")
(funcall ok "/var/tmp")
(funcall ok ".")
(error (concat "Couldn't find a usable temp directory -- "
"set `doctest-temp-directory'"))))
"Directory used for temporary files created when running doctest.
By default, the first directory from this list that exists and that you
can write into: the value (if any) of the environment variable TMPDIR,
/usr/tmp, /tmp, /var/tmp, or the current directory."
:type 'string
:group 'doctest)
(defcustom doctest-hide-example-source nil
"If true, then don't display the example source code for each
failure in the results buffer."
:type 'boolean
:group 'doctest)
(defcustom doctest-python-command "python"
"Shell command used to start the python interpreter"
:type 'string
:group 'doctest)
(defcustom doctest-results-buffer-name "*doctest-output (%N)*"
"The name of the buffer used to store the output of the doctest
command. This name can contain the following special sequences:
%n -- replaced by the doctest buffer's name.
%N -- replaced by the doctest buffer's name, with '.doctest'
stripped off.
%f -- replaced by the doctest buffer's filename."
:type 'string
:group 'doctest)
(defcustom doctest-optionflags '()
"Option flags for doctest"
:group 'doctest
:type '(repeat (choice (const :tag "Select an option..." "")
(const :tag "Normalize whitespace"
"NORMALIZE_WHITESPACE")
(const :tag "Ellipsis"
"ELLIPSIS")
(const :tag "Don't accept True for 1"
"DONT_ACCEPT_TRUE_FOR_1")
(const :tag "Don't accept "
"DONT_ACCEPT_BLANKLINE")
(const :tag "Ignore Exception detail"
"IGNORE_EXCEPTION_DETAIL")
(const :tag "Report only first failure"
"REPORT_ONLY_FIRST_FAILURE")
)))
(defcustom doctest-async t
"If true, then doctest will be run asynchronously."
:type 'boolean
:group 'doctest)
(defcustom doctest-trim-exceptions t
"If true, then any exceptions inserted by doctest-replace-output
will have the stack trace lines trimmed."
:type 'boolean
:group 'doctest)
(defcustom doctest-highlight-strings t
"If true, then highlight strings. If you find that doctest-mode
is responding slowly when you type, turning this off might help."
:type 'boolean
:group 'doctest)
(defcustom doctest-follow-output t
"If true, then when doctest is run asynchronously, the output buffer
will scroll to display its output as it is generated. If false, then
the output buffer not scroll."
:type 'boolean
:group 'doctest)
(defvar doctest-mode-hook nil
"Hook called by `doctest-mode'.")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Fonts
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defface doctest-prompt-face
'((((class color) (background dark))
(:foreground "#68f"))
(t (:foreground "#226")))
"Face for Python prompts in doctest examples."
:group 'doctest)
(defface doctest-output-face
'((((class color) (background dark))
(:foreground "#afd"))
(t (:foreground "#262")))
"Face for the output of doctest examples."
:group 'doctest)
(defface doctest-output-marker-face
'((((class color) (background dark))
(:foreground "#0f0"))
(t (:foreground "#080")))
"Face for markers in the output of doctest examples."
:group 'doctest)
(defface doctest-output-traceback-face
'((((class color) (background dark))
(:foreground "#f88"))
(t (:foreground "#622")))
"Face for traceback headers in the output of doctest examples."
:group 'doctest)
(defface doctest-results-divider-face
'((((class color) (background dark))
(:foreground "#08f"))
(t (:foreground "#00f")))
"Face for dividers in the doctest results window."
:group 'doctest)
(defface doctest-results-loc-face
'((((class color) (background dark))
(:foreground "#0f8"))
(t (:foreground "#084")))
"Face for location headers in the doctest results window."
:group 'doctest)
(defface doctest-results-header-face
'((((class color) (background dark))
(:foreground "#8ff"))
(t (:foreground "#088")))
"Face for sub-headers in the doctest results window."
:group 'doctest)
(defface doctest-results-selection-face
'((((class color) (background dark))
(:foreground "#ff0" :background "#008"))
(t (:background "#088" :foreground "#fff")))
"Face for selected failure's location header in the results window."
:group 'doctest)
(defface doctest-selection-face
'((((class color) (background dark))
(:foreground "#ff0" :background "#00f" :bold t))
(t (:foreground "#f00")))
"Face for selected example's prompt"
:group 'doctest)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Constants
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defconst doctest-prompt-re
"^\\(?:\\([ \t]*\\)\\(>>> ?\\|[.][.][.] ?\\)\\([ \t]*\\)\\)"
"Regular expression for doctest prompts. It defines three groups:
the pre-prompt margin; the prompt; and the post-prompt indentation.")
(defconst doctest-open-block-re
"[^\n]+:[ \t]*\\(#.*\\)?$"
"Regular expression for a line that opens a block")
(defconst doctest-close-block-re
"\\(return\\|raise\\|break\\|continue\\|pass\\)\\b"
"Regular expression for a line that closes a block")
(defconst doctest-example-source-re
"^Failed example:\n\\(\n\\| [^\n]*\n\\)+"
"Regular expression for example source in doctest's output.")
(defconst doctest-results-divider-re
"^\\([*]\\{60,\\}\\)$"
"Regular expression for example dividers in doctest's output.")
(defconst doctest-py24-results-loc-re
"^File \"[^\"]+\", line \\([0-9]+\\), in [^\n]+"
"Regular expression for example location markers in doctest's output.")
(defconst doctest-py21-results-loc-re
"^from line #\\([0-9]+\\) of [^\n]*"
"Regular expression for example location markers in doctest's output,
when the output was generated by an old version of doctest.")
(defconst doctest-results-header-re
"^\\([^ \n\t].+:\\|Expected nothing\\|Got nothing\\)$"
"Regular expression for example headers in doctest's output.")
(defconst doctest-traceback-header-re
"^[ \t]*Traceback (\\(most recent call last\\|innermost last\\)):"
"Regular expression for Python traceback headers.")
(defconst doctest-py21-results-re
"^from line #"
"Regular expression used to test which version of doctest was used.")
;; nb: There's a bug in Python's traceback.print_exception function
;; which causes SyntaxError exceptions to be displayed incorrectly;
;; which prevents this regexp from matching. But there shouldn't be
;; too many people testing for SyntaxErrors, so I won't worry about
;; it.
(defconst doctest-traceback-re
(let ((nonprompt
;; This matches any non-blank line that doesn't start with
;; a prompt (... or >>>).
(concat
"\\(?:[.][.][^.\n]\\|[>][>][^>\n]\\|"
"[.][^.\n]\\|[>][^>\n]\\|[^.>\n \t]\\)[^\n]*")))
(concat
"^\\(\\([ \t]*\\)Traceback "
"(\\(?:most recent call last\\|innermost last\\)):\n\\)"
"\\(?:\\2[ \t]+[^ \t\n][^\n]*\n\\)*"
"\\(\\(?:\\2" nonprompt "\n\\)"
"\\(?:\\2[ \t]*" nonprompt "\n\\)*\\)"))
"Regular expression that matches a complete exception traceback.
It contains three groups: group 1 is the header line; group 2 is
the indentation; and group 3 is the exception message.")
(defconst doctest-blankline-re
"^[ \t]*"
"Regular expression that matches blank line markers in doctest
output.")
(defconst doctest-outdent-re
(concat "\\(" (mapconcat 'identity
'("else:"
"except\\(\\s +.*\\)?:"
"finally:"
"elif\\s +.*:")
"\\|")
"\\)")
"Regular expression for a line that should be outdented. Any line
that matches `doctest-outdent-re', but does not follow a line matching
`doctest-no-outdent-re', will be outdented.")
;; It's not clear to me *why* the behavior given by this definition of
;; doctest-no-outdent-re is desirable; but it's basically just copied
;; from python-mode.
(defconst doctest-no-outdent-re
(concat
"\\("
(mapconcat 'identity
(list "try:"
"except\\(\\s +.*\\)?:"
"while\\s +.*:"
"for\\s +.*:"
"if\\s +.*:"
"elif\\s +.*:"
"\\(return\\|raise\\|break\\|continue\\|pass\\)[ \t\n]"
)
"\\|")
"\\)")
"Regular expression matching lines not to outdent after. Any line
that matches `doctest-outdent-re', but does not follow a line matching
`doctest-no-outdent-re', will be outdented.")
(defconst doctest-script
"\
from doctest import *
import sys
if '%m':
import imp
try:
m = imp.load_source('__imported__', '%m')
globs = m.__dict__
except Exception, e:
print ('doctest-mode encountered an error while importing '
'the current buffer:\\n\\n %s' % e)
sys.exit(1)
else:
globs = {}
doc = open('%t').read()
if sys.version_info[:2] >= (2,4):
test = DocTestParser().get_doctest(doc, globs, '%n', '%f', 0)
r = DocTestRunner(optionflags=%l)
r.run(test)
else:
Tester(globs=globs).runstring(doc, '%f')"
;; Docstring:
"Python script used to run doctest.
The following special sequences are defined:
%n -- replaced by the doctest buffer's name.
%f -- replaced by the doctest buffer's filename.
%l -- replaced by the doctest flags string.
%t -- replaced by the name of the tempfile containing the doctests."
)
(defconst doctest-keyword-re
(let* ((kw1 (mapconcat 'identity
'("and" "assert" "break" "class"
"continue" "def" "del" "elif"
"else" "except" "exec" "for"
"from" "global" "if" "import"
"in" "is" "lambda" "not"
"or" "pass" "print" "raise"
"return" "while" "yield"
)
"\\|"))
(kw2 (mapconcat 'identity
'("else:" "except:" "finally:" "try:")
"\\|"))
(kw3 (mapconcat 'identity
'("ArithmeticError" "AssertionError"
"AttributeError" "DeprecationWarning" "EOFError"
"Ellipsis" "EnvironmentError" "Exception" "False"
"FloatingPointError" "FutureWarning" "IOError"
"ImportError" "IndentationError" "IndexError"
"KeyError" "KeyboardInterrupt" "LookupError"
"MemoryError" "NameError" "None" "NotImplemented"
"NotImplementedError" "OSError" "OverflowError"
"OverflowWarning" "PendingDeprecationWarning"
"ReferenceError" "RuntimeError" "RuntimeWarning"
"StandardError" "StopIteration" "SyntaxError"
"SyntaxWarning" "SystemError" "SystemExit"
"TabError" "True" "TypeError" "UnboundLocalError"
"UnicodeDecodeError" "UnicodeEncodeError"
"UnicodeError" "UnicodeTranslateError"
"UserWarning" "ValueError" "Warning"
"ZeroDivisionError" "__debug__"
"__import__" "__name__" "abs" "apply" "basestring"
"bool" "buffer" "callable" "chr" "classmethod"
"cmp" "coerce" "compile" "complex" "copyright"
"delattr" "dict" "dir" "divmod"
"enumerate" "eval" "execfile" "exit" "file"
"filter" "float" "getattr" "globals" "hasattr"
"hash" "hex" "id" "input" "int" "intern"
"isinstance" "issubclass" "iter" "len" "license"
"list" "locals" "long" "map" "max" "min" "object"
"oct" "open" "ord" "pow" "property" "range"
"raw_input" "reduce" "reload" "repr" "round"
"setattr" "slice" "staticmethod" "str" "sum"
"super" "tuple" "type" "unichr" "unicode" "vars"
"xrange" "zip")
"\\|"))
(pseudokw (mapconcat 'identity
'("self" "None" "True" "False" "Ellipsis")
"\\|"))
(string (concat "'\\(?:\\\\[^\n]\\|[^\n']*\\)'" "\\|"
"\"\\(?:\\\\[^\n]\\|[^\n\"]*\\)\""))
(brk "\\(?:[ \t(]\\|$\\)"))
(concat
;; Comments (group 1)
"\\(#.*\\)"
;; Function & Class Definitions (groups 2-3)
"\\|\\b\\(class\\|def\\)"
"[ \t]+\\([a-zA-Z_][a-zA-Z0-9_]*\\)"
;; Builtins preceeded by '.'(group 4)
"\\|[.][\t ]*\\(" kw3 "\\)"
;; Keywords & builtins (group 5)
"\\|\\b\\(" kw1 "\\|" kw2 "\\|"
kw3 "\\|" pseudokw "\\)" brk
;; Decorators (group 6)
"\\|\\(@[a-zA-Z_][a-zA-Z0-9_]*\\)"
))
"A regular expression used for syntax highlighting of Python
source code.")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Syntax Highlighting (font-lock mode)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Define the font-lock keyword table.
(defconst doctest-font-lock-keywords
`(
;; The following pattern colorizes source lines. In particular,
;; it first matches prompts, and then looks for any of the
;; following matches *on the same line* as the prompt. It uses
;; the form:
;;
;; (MATCHER MATCH-HIGHLIGHT
;; (ANCHOR-MATCHER nil nil MATCH-HIGHLIGHT))
;;
;; See the variable documentation for font-lock-keywords for a
;; description of what each of those means.
("^[ \t]*\\(>>>\\|\\.\\.\\.\\)"
(1 'doctest-prompt-face)
(doctest-source-matcher
nil nil
(1 'font-lock-comment-face t t) ; comments
(2 'font-lock-keyword-face t t) ; def/class
(3 'font-lock-type-face t t) ; func/class name
;; group 4 (builtins preceeded by '.') gets no colorization.
(5 'font-lock-keyword-face t t) ; keywords & builtins
(6 'font-lock-preprocessor-face t t) ; decorators
(7 'font-lock-string-face t t) ; strings
))
;; The following pattern colorizes output lines. In particular,
;; it uses doctest-output-line-matcher to check if this is an
;; output line, and if so, it colorizes it, and any special
;; markers it contains.
(doctest-output-line-matcher
(0 'doctest-output-face t)
("\\.\\.\\." (beginning-of-line) (end-of-line)
(0 'doctest-output-marker-face t))
(,doctest-blankline-re (beginning-of-line) (end-of-line)
(0 'doctest-output-marker-face t))
(doctest-traceback-line-matcher (beginning-of-line) (end-of-line)
(0 'doctest-output-traceback-face t))
(,doctest-traceback-header-re (beginning-of-line) (end-of-line)
(0 'doctest-output-traceback-face t))
)
;; A PS1 prompt followed by a non-space is an error.
("^[ \t]*\\(>>>[^ \t\n][^\n]*\\)" (1 'font-lock-warning-face t))
)
"Expressions to highlight in doctest-mode.")
(defconst doctest-results-font-lock-keywords
`((,doctest-results-divider-re
(0 'doctest-results-divider-face))
(,doctest-py24-results-loc-re
(0 'doctest-results-loc-face))
(,doctest-results-header-re
(0 'doctest-results-header-face))
(doctest-results-selection-matcher
(0 'doctest-results-selection-face t)))
"Expressions to highlight in doctest-results-mode.")
(defun doctest-output-line-matcher (limit)
"A `font-lock-keyword' MATCHER that returns t if the current
line is the expected output for a doctest example, and if so,
sets `match-data' so that group 0 spans the current line."
;; The real work is done by doctest-find-output-line.
(when (doctest-find-output-line limit)
;; If we found one, then mark the entire line.
(beginning-of-line)
(re-search-forward "[^\n]*" limit)))
(defun doctest-traceback-line-matcher (limit)
"A `font-lock-keyword' MATCHER that returns t if the current line is
the beginning of a traceback, and if so, sets `match-data' so that
group 0 spans the entire traceback. n.b.: limit is ignored."
(beginning-of-line)
(when (looking-at doctest-traceback-re)
(goto-char (match-end 0))
t))
(defun doctest-source-matcher (limit)
"A `font-lock-keyword' MATCHER that returns t if the current line
contains a Python source expression that should be highlighted
after the point. If so, it sets `match-data' to cover the string
literal. The groups in `match-data' should be interpreted as follows:
Group 1: comments
Group 2: def/class
Group 3: function/class name
Group 4: builtins preceeded by '.'
Group 5: keywords & builtins
Group 6: decorators
Group 7: strings
"
(let ((matchdata nil))
;; First, look for string literals.
(when doctest-highlight-strings
(save-excursion
(when (doctest-string-literal-matcher limit)
(setq matchdata
(list (match-beginning 0) (match-end 0)
nil nil nil nil nil nil nil nil nil nil nil nil
(match-beginning 0) (match-end 0))))))
;; Then, look for other keywords. If they occur before the
;; string literal, then they take precedence.
(save-excursion
(when (and (re-search-forward doctest-keyword-re limit t)
(or (null matchdata)
(< (match-beginning 0) (car matchdata))))
(setq matchdata (match-data))))
(when matchdata
(set-match-data matchdata)
(goto-char (match-end 0))
t)))
(defun doctest-string-literal-matcher (limit &optional debug)
"A `font-lock-keyword' MATCHER that returns t if the current line
contains a string literal starting at or after the point. If so, it
expands `match-data' to cover the string literal. This matcher uses
`doctest-statement-info' to collect information about strings that
continue over multiple lines. It therefore might be a little slow for
very large statements."
(let* ((stmt-info (doctest-statement-info))
(quotes (reverse (nth 5 stmt-info)))
(result nil))
(if debug (doctest-debug "quotes %s" quotes))
(while (and quotes (null result))
(let* ((quote (pop quotes))
(start (car quote))
(end (min limit (or (cdr quote) limit))))
(if debug (doctest-debug "quote %s-%s pt=%s lim=%s"
start end (point) limit))
(when (or (and (<= (point) start) (< start limit))
(and (< start (point)) (< (point) end)))
(setq start (max start (point)))
(set-match-data (list start end))
(if debug (doctest-debug "marking string %s" (match-data)))
(goto-char end)
(setq result t))))
result))
(defun doctest-results-selection-matcher (limit)
"Matches from `doctest-selected-failure' to the end of the
line. This is used to highlight the currently selected failure."
(when (and doctest-selected-failure
(<= (point) doctest-selected-failure)
(< doctest-selected-failure limit))
(goto-char doctest-selected-failure)
(re-search-forward "[^\n]+" limit)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Source code editing & indentation
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun doctest-indent-source-line (&optional dedent-only)
"Re-indent the current line, as doctest source code. I.e., add a
prompt to the current line if it doesn't have one, and re-indent the
source code (to the right of the prompt). If `dedent-only' is true,
then don't increase the indentation level any."
(interactive "*")
(let ((indent-end nil))
(save-excursion
(beginning-of-line)
(let ((new-indent (doctest-current-source-line-indentation dedent-only))
(new-margin (doctest-current-source-line-margin))
(line-had-prompt (looking-at doctest-prompt-re)))
;; Delete the old prompt (if any).
(when line-had-prompt
(goto-char (match-beginning 2))
(delete-char (- (match-end 2) (match-beginning 2))))
;; Delete the old indentation.
(delete-backward-char (skip-chars-forward " \t"))
;; If it's a continuation line, or a new PS1 prompt,
;; then copy the margin.
(when (or new-indent (not line-had-prompt))
(beginning-of-line)
(delete-backward-char (skip-chars-forward " \t"))
(insert-char ?\ new-margin))
;; Add the new prompt.
(insert-string (if new-indent "... " ">>> "))
;; Add the new indentation
(if new-indent (insert-char ?\ new-indent))
(setq indent-end (point))))
;; If we're left of the indentation end, then move up to the
;; indentation end.
(if (< (point) indent-end) (goto-char indent-end))))
(defun doctest-current-source-line-indentation (&optional dedent-only)
"Return the post-prompt indent to use for this line. This is an
integer for a continuation lines, and nil for non-continuation lines."
(save-excursion
;; Examine the previous doctest line (if present).
(let* ((prev-stmt-info (doctest-prev-statement-info))
(prev-stmt-indent (nth 0 prev-stmt-info))
(continuation-indent (nth 1 prev-stmt-info))
(prev-stmt-opens-block (nth 2 prev-stmt-info))
(prev-stmt-closes-block (nth 3 prev-stmt-info))
(prev-stmt-blocks-outdent (nth 4 prev-stmt-info))
)
;; Examine this doctest line.
(let* ((curr-line-indent 0)
(curr-line-outdented nil))
(beginning-of-line)
(when (looking-at doctest-prompt-re)
(setq curr-line-indent (- (match-end 3) (match-beginning 3)))
(goto-char (match-end 3)))
(setq curr-line-outdented (and (looking-at doctest-outdent-re)
(not prev-stmt-blocks-outdent)))
;; Compute the overall indent.
(let ((indent (or continuation-indent
(+ prev-stmt-indent
(if curr-line-outdented -4 0)
(if prev-stmt-opens-block 4 0)
(if prev-stmt-closes-block -4 0)))))
;; If dedent-only is true, then make sure we don't indent.
(when dedent-only
(setq indent (min indent curr-line-indent)))
;; If indent=0 and we're not outdented, then set indent to
;; nil (to signify the start of a new source example).
(when (and (= indent 0)
(not (or curr-line-outdented continuation-indent)))
(setq indent nil))
;; Return the indentation.
indent)))))
(defun doctest-prev-statement-info (&optional debug)
(save-excursion
(forward-line -1)
(doctest-statement-info debug)))
(defun doctest-statement-info (&optional debug)
"Collect info about the previous statement, and return it as a list:
(INDENT, CONTINUATION, OPENS-BLOCK, CLOSES-BLOCK, BLOCKS-OUTDENT,
QUOTES)
INDENT -- The indentation of the previous statement (after the prompt)
CONTINUATION -- If the previous statement is incomplete (e.g., has an
open paren or quote), then this is the appropriate indentation
level; otherwise, it's nil.
OPENS-BLOCK -- True if the previous statement opens a Python control
block.
CLOSES-BLOCK -- True if the previous statement closes a Python control
block.
BLOCKS-OUTDENT -- True if the previous statement should 'block the
next statement from being considered an outdent.
QUOTES -- A list of (START . END) pairs for all quotation strings.
"
(save-excursion
(end-of-line)
(let ((end (point)))
(while (and (doctest-on-source-line-p "...") (= (forward-line -1) 0)))
(cond
;; If there's no previous >>> line, then give up.
((not (doctest-on-source-line-p ">>>"))
'(0 nil nil nil nil))
;; If there is a previous statement, walk through the source
;; code, checking for operators that may be of interest.
(t
(beginning-of-line)
(let* ((quote-mark nil) (nesting 0) (indent-stack '())
(stmt-indent 0)
(stmt-opens-block nil)
(stmt-closes-block nil)
(stmt-blocks-outdent nil)
(quotes '())
(elt-re (concat "\\\\[^\n]\\|"
"(\\|)\\|\\[\\|\\]\\|{\\|}\\|"
"\"\"\"\\|\'\'\'\\|\"\\|\'\\|"
"#[^\n]*\\|" doctest-prompt-re)))
(while (re-search-forward elt-re end t)
(let* ((elt (match-string 0))
(elt-first-char (substring elt 0 1)))
(if debug (doctest-debug "Debug: %s" elt))
(cond
;; Close quote -- set quote-mark back to nil. The
;; second case is for cases like: ' '''
(quote-mark
(cond
((equal quote-mark elt)
(setq quote-mark nil)
(setcdr (car quotes) (point)))
((equal quote-mark elt-first-char)
(setq quote-mark nil)
(setcdr (car quotes) (point))
(backward-char 2))))
;; Prompt -- check if we're starting a new stmt. If so,
;; then collect various info about it.
((string-match doctest-prompt-re elt)
(when (and (null quote-mark) (= nesting 0))
(let ((indent (- (match-end 3) (match-end 2))))
(unless (looking-at "[ \t]*\n")
(setq stmt-indent indent)
(setq stmt-opens-block
(looking-at doctest-open-block-re))
(setq stmt-closes-block
(looking-at doctest-close-block-re))
(setq stmt-blocks-outdent
(looking-at doctest-no-outdent-re))))))
;; Open paren -- increment nesting, and update indent-stack.
((string-match "(\\|\\[\\|{" elt-first-char)
(let ((elt-pos (point))
(at-eol (looking-at "[ \t]*\n"))
(indent 0))
(save-excursion
(re-search-backward doctest-prompt-re)
(if at-eol
(setq indent (+ 4 (- (match-end 3) (match-end 2))))
(setq indent (- elt-pos (match-end 2))))
(push indent indent-stack)))
(setq nesting (+ nesting 1)))
;; Close paren -- decrement nesting, and pop indent-stack.
((string-match ")\\|\\]\\|}" elt-first-char)
(setq indent-stack (cdr indent-stack))
(setq nesting (max 0 (- nesting 1))))
;; Open quote -- set quote-mark.
((string-match "\"\\|\'" elt-first-char)
(push (cons (- (point) (length elt)) nil) quotes)
(setq quote-mark elt)))))
(let* ((continuation-indent
(cond
(quote-mark 0)
((> nesting 0) (if (null indent-stack) 0 (car indent-stack)))
(t nil)))
(result
(list stmt-indent continuation-indent
stmt-opens-block stmt-closes-block
stmt-blocks-outdent quotes)))
(if debug (doctest-debug "Debug: %s" result))
result)))))))
(defun doctest-current-source-line-margin ()
"Return the pre-prompt margin to use for this source line. This is
copied from the most recent source line, or set to
`doctest-default-margin' if there are no preceeding source lines."
(save-excursion
(save-restriction
(when (doctest-in-mmm-docstring-overlay)
(doctest-narrow-to-mmm-overlay))
(beginning-of-line)
(forward-line -1)
(while (and (not (doctest-on-source-line-p))
(re-search-backward doctest-prompt-re nil t))))
(cond ((looking-at doctest-prompt-re)
(- (match-end 1) (match-beginning 1)))
((doctest-in-mmm-docstring-overlay)
(doctest-default-margin-in-mmm-docstring-overlay))
(t
doctest-default-margin))))
(defun doctest-electric-backspace ()
"Delete the preceeding character, level of indentation, or
prompt.
If point is at the leftmost column, delete the preceding newline.
Otherwise, if point is at the first non-whitespace character
following an indented source line's prompt, then reduce the
indentation to the next multiple of 4; and update the source line's
prompt, when necessary.
Otherwise, if point is at the first non-whitespace character
following an unindented source line's prompt, then remove the
prompt (converting the line to an output line or text line).
Otherwise, if point is at the first non-whitespace character of a
line, the delete the line's indentation.
Otherwise, delete the preceeding character.
"
(interactive "*")
(cond
;; Beginning of line: delete preceeding newline.
((bolp) (backward-delete-char 1))
;; First non-ws char following prompt: dedent or remove prompt.
((and (looking-at "[^ \t\n]\\|$") (doctest-looking-back doctest-prompt-re))
(let* ((prompt-beg (match-beginning 2))
(indent-beg (match-beginning 3)) (indent-end (match-end 3))
(old-indent (- indent-end indent-beg))
(new-indent (* (/ (- old-indent 1) 4) 4)))
(cond
;; Indented source line: dedent it.
((> old-indent 0)
(goto-char indent-beg)
(delete-region indent-beg indent-end)
(insert-char ?\ new-indent)
;; Change prompt to PS1, when appropriate.
(when (and (= new-indent 0) (not (looking-at doctest-outdent-re)))
(delete-backward-char 4)
(insert-string ">>> ")))
;; Non-indented source line: remove prompt.
(t
(goto-char indent-end)
(delete-region prompt-beg indent-end)))))
;; First non-ws char of a line: delete all indentation.
((and (looking-at "[^ \n\t]\\|$") (doctest-looking-back "^[ \t]+"))
(delete-region (match-beginning 0) (match-end 0)))
;; Otherwise: delete a character.
(t
(backward-delete-char 1))))
(defun doctest-newline-and-indent ()
"Insert a newline, and indent the new line appropriately.
If the current line is a source line containing a bare prompt,
then clear the current line, and insert a newline.
Otherwise, if the current line is a source line, then insert a
newline, and add an appropriately indented prompt to the new
line.
Otherwise, if the current line is an output line, then insert a
newline and indent the new line to match the example's margin.
Otherwise, insert a newline.
If `doctest-avoid-trailing-whitespace' is true, then clear any
whitespace to the left of the point before inserting a newline.
"
(interactive "*")
;; If we're avoiding trailing spaces, then delete WS before point.
(if doctest-avoid-trailing-whitespace
(delete-char (- (skip-chars-backward " \t"))))
(cond
;; If we're on an empty prompt, delete it.
((doctest-on-empty-source-line-p)
(delete-region (match-beginning 0) (match-end 0))
(insert-char ?\n 1))
;; If we're on a doctest line, add a new prompt.
((doctest-on-source-line-p)
(insert-char ?\n 1)
(doctest-indent-source-line))
;; If we're in doctest output, indent to the margin.
((doctest-on-output-line-p)
(insert-char ?\n 1)
(insert-char ?\ (doctest-current-source-line-margin)))
;; Otherwise, just add a newline.
(t (insert-char ?\n 1))))
(defun doctest-electric-colon ()
"Insert a colon, and dedent the line when appropriate."
(interactive "*")
(insert-char ?: 1)
(when (doctest-on-source-line-p)
(doctest-indent-source-line t)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Code Execution
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun doctest-execute ()
"Run doctest on the current buffer, or on the current docstring
if the point is inside an `mmm-mode' `doctest-docstring' region.
Display the results in the *doctest-output* buffer."
(interactive)
(doctest-execute-region (point-min) (point-max) nil t))
(defun doctest-execute-with-diff ()
"Run doctest on the current buffer, or on the current docstring
if the point is inside an `mmm-mode' `doctest-docstring' region.
Display the results in the *doctest-output* buffer, using diff format."
(interactive)
(doctest-execute-region (point-min) (point-max) t t))
(defun doctest-execute-buffer-with-diff ()
"Run doctest on the current buffer, and display the results in the
*doctest-output* buffer, using the diff format."
(interactive)
(doctest-execute-region (point-min) (point-max) t nil))
(defun doctest-execute-buffer ()
"Run doctest on the current buffer, and display the results in the
*doctest-output* buffer."
(interactive)
(doctest-execute-region (point-min) (point-max) nil nil))
(defun doctest-execute-region (start end &optional diff
check-for-mmm-docstring-overlay)
"Run doctest on the current buffer, and display the results in the
*doctest-output* buffer."
(interactive "r")
;; If it's already running, give the user a chance to restart it.
(when (doctest-process-live-p doctest-async-process)
(when (y-or-n-p "Doctest is already running. Restart it? ")
(doctest-cancel-async-process)
(message "Killing doctest...")))
(cond
((and doctest-async (doctest-process-live-p doctest-async-process))
(message "Can't run two doctest processes at once!"))
(t
(let* ((results-buf-name (doctest-results-buffer-name))
(in-docstring (and check-for-mmm-docstring-overlay
(doctest-in-mmm-docstring-overlay)))
(temp (doctest-temp-name)) (dir doctest-temp-directory)
(input-file (expand-file-name (concat temp ".py") dir))
(globs-file (when in-docstring
(expand-file-name (concat temp "-globs.py") dir)))
(cur-buf (current-buffer))
(in-buf (get-buffer-create "*doctest-input*"))
(script (doctest-script input-file globs-file diff)))
;; If we're in a docstring, narrow start & end.
(when in-docstring
(let ((bounds (doctest-mmm-overlay-bounds)))
(setq start (max start (car bounds))
end (min end (cdr bounds)))))
;; Write the doctests to a file.
(save-excursion
(goto-char (min start end))
(let ((lineno (doctest-line-number)))
(set-buffer in-buf)
;; Add blank lines, to keep line numbers the same:
(dotimes (n (- lineno 1)) (insert-string "\n"))
;; Add the selected region
(insert-buffer-substring cur-buf start end)
;; Write it to a file
(write-file input-file)))
;; If requested, write the buffer to a file for use as globs.
(when globs-file
(let ((cur-buf-start (point-min)) (cur-buf-end (point-max)))
(save-excursion
(set-buffer in-buf)
(delete-region (point-min) (point-max))
(insert-buffer-substring cur-buf cur-buf-start cur-buf-end)
(write-file globs-file))))
;; Dispose of in-buf (we're done with it now.
(kill-buffer in-buf)
;; Prepare the results buffer. Clear it, if it contains
;; anything, and set its mode.
(setq doctest-results-buffer (get-buffer-create results-buf-name))
(save-excursion
(set-buffer doctest-results-buffer)
(toggle-read-only 0)
(delete-region (point-min) (point-max))
(doctest-results-mode)
(setq doctest-source-buffer cur-buf)
)
;; Add markers to examples, and record what line number each one
;; starts at. That way, if the input buffer is edited, we can
;; still find corresponding examples in the output.
(doctest-mark-examples)
;; Run doctest
(cond (doctest-async
;; Asynchronous mode:
(let ((process (start-process "*doctest*" doctest-results-buffer
doctest-python-command
"-c" script)))
;; Store some information about the process.
(setq doctest-async-process-buffer cur-buf)
(setq doctest-async-process process)
(push input-file doctest-async-process-tempfiles)
(when globs-file
(push globs-file doctest-async-process-tempfiles))
;; Set up a sentinel to respond when it's done running.
(set-process-sentinel process 'doctest-async-process-sentinel)
;; Show the output window.
(let ((w (display-buffer doctest-results-buffer)))
(when doctest-follow-output
;; Insert a newline, which will move the buffer's
;; point past the process's mark -- this causes the
;; window to scroll as new output is generated.
(save-current-buffer
(set-buffer doctest-results-buffer)
(insert-string "\n")
(set-window-point w (point)))))
;; Let the user know the process is running.
(doctest-update-mode-line ":running")
(message "Running doctest...")))
(t
;; Synchronous mode:
(call-process doctest-python-command nil
doctest-results-buffer t "-c" script)
(doctest-handle-output)
(delete-file input-file)
(when globs-file
(delete-file globs-file))))))))
(defun doctest-handle-output ()
"This function, which is called after the 'doctest' process spawned
by doctest-execute-buffer has finished, checks the doctest results
buffer. If that buffer is empty, it reports no errors and hides it;
if that buffer is not empty, it reports that errors occured, displays
the buffer, and runs doctest-postprocess-results."
;; If any tests failed, display them.
(cond ((not (buffer-live-p doctest-results-buffer))
(doctest-warn "Results buffer not found!"))
((> (buffer-size doctest-results-buffer) 1)
(display-buffer doctest-results-buffer)
(doctest-postprocess-results)
(let ((num (length doctest-example-markers)))
(message "%d doctest example%s failed!" num
(if (= num 1) "" "s"))))
(t
(display-buffer doctest-results-buffer)
(delete-windows-on doctest-results-buffer)
(message "All doctest examples passed!"))))
(defun doctest-async-process-sentinel (process state)
"A process sentinel, called when the asynchronous doctest process
completes, which calls doctest-handle-output."
;; Check to make sure we got the process we're expecting. On
;; some operating systems, this will end up getting called twice
;; when we use doctest-cancel-async-process; this check keeps us
;; from trying to clean up after the same process twice (since we
;; set doctest-async-process to nil when we're done).
(when (and (equal process doctest-async-process)
(buffer-live-p doctest-async-process-buffer))
(save-current-buffer
(set-buffer doctest-async-process-buffer)
(cond ((not (buffer-live-p doctest-results-buffer))
(doctest-warn "Results buffer not found!"))
((equal state "finished\n")
(doctest-handle-output)
(let ((window (get-buffer-window
doctest-async-process-buffer t)))
(when window (set-window-point window (point)))))
((equal state "killed\n")
(message "Doctest killed."))
(t
(message "Doctest failed -- %s" state)
(display-buffer doctest-results-buffer)))
(doctest-update-mode-line "")
(while doctest-async-process-tempfiles
(delete-file (pop doctest-async-process-tempfiles)))
(setq doctest-async-process nil))))
(defun doctest-cancel-async-process ()
"If a doctest process is running, then kill it."
(interactive "")
(when (doctest-process-live-p doctest-async-process)
;; Update the modeline
(doctest-update-mode-line ":killing")
;; Kill the process.
(kill-process doctest-async-process)
;; Run the sentinel. (Depending on what OS we're on, the sentinel
;; may end up getting called once or twice.)
(doctest-async-process-sentinel doctest-async-process "killed\n")
))
(defun doctest-postprocess-results ()
"Post-process the doctest results buffer: check what version of
doctest was used, and set doctest-results-py-version accordingly;
turn on read-only mode; filter the example markers; hide the example
source (if `doctest-hide-example-source' is non-nil); and select the
first failure."
(save-excursion
(set-buffer doctest-results-buffer)
;; Check if we're using an old doctest version.
(goto-char (point-min))
(if (re-search-forward doctest-py21-results-re nil t)
(setq doctest-results-py-version 'py21)
(setq doctest-results-py-version 'py24))
;; Turn on read-only mode.
(toggle-read-only t))
(doctest-filter-example-markers)
(if doctest-hide-example-source
(doctest-hide-example-source))
(doctest-next-failure 1))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Markers
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun doctest-mark-examples ()
"Add a marker at the beginning of every (likely) example in the
input buffer; and create a list, `doctest-example-markers',
which maps from markers to the line numbers they originally occured
on. This will allow us to find the corresponding example in the
doctest output, even if the input buffer is edited."
(dolist (marker-info doctest-example-markers)
(set-marker (car marker-info) nil))
(setq doctest-example-markers '())
(save-excursion
(goto-char (point-min))
(while (re-search-forward "^ *>>> " nil t)
(backward-char 4)
(push (cons (point-marker) (doctest-line-number))
doctest-example-markers)
(forward-char 4))))
(defun doctest-filter-example-markers ()
"Remove any entries from `doctest-example-markers' that do not
correspond to a failed example."
(let ((filtered nil) (markers doctest-example-markers))
(save-excursion
(set-buffer doctest-results-buffer)
(goto-char (point-max))
(while (re-search-backward (doctest-results-loc-re) nil t)
(let ((lineno (string-to-int (match-string 1))))
(when (equal doctest-results-py-version 'py21)
(setq lineno (+ lineno 1)))
(while (and markers (< lineno (cdar markers)))
(set-marker (caar markers) nil)
(setq markers (cdr markers)))
(if (and markers (= lineno (cdar markers)))
(push (pop markers) filtered)
(doctest-warn "Example expected on line %d but not found %s"
lineno markers)))))
(dolist (marker-info markers)
(set-marker (car marker-info) nil))
(setq doctest-example-markers filtered)))
(defun doctest-prev-example-marker ()
"Helper for doctest-replace-output: move to the preceeding example
marker, and return the corresponding 'original' lineno. If none is
found, return nil."
(let ((lineno nil)
(pos nil))
(save-excursion
(end-of-line)
(when (re-search-backward "^\\( *\\)>>> " nil t)
(goto-char (match-end 1))
(dolist (marker-info doctest-example-markers)
(when (= (marker-position (car marker-info)) (point))
(setq lineno (cdr marker-info))
(setq pos (point))))))
(unless (null lineno)
(goto-char pos)
lineno)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Navigation
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun doctest-next-failure (count)
"Move to the top of the next failing example, and highlight the
example's failure description in *doctest-output*."
(interactive "p")
(cond
((and doctest-async (doctest-process-live-p doctest-async-process))
(message "Wait for doctest to finish running!"))
((not (doctest-results-buffer-valid-p))
(message "Run doctest first! (C-c C-c)"))
((equal count 0)
t)
(t
(let ((marker nil) (example-markers doctest-example-markers)
(results-window (display-buffer doctest-results-buffer)))
(save-excursion
(set-buffer doctest-results-buffer)
;; Pick up where we left off.
;; (nb: doctest-selected-failure is buffer-local)
(goto-char (or doctest-selected-failure (point-min)))
;; Skip past anything on *this* line.
(if (>= count 0) (end-of-line) (beginning-of-line))
;; Look for the next failure
(when
(if (>= count 0)
(re-search-forward (doctest-results-loc-re) nil t count)
(re-search-backward (doctest-results-loc-re) nil t (- count)))
;; We found a failure:
(let ((old-selected-failure doctest-selected-failure))
(beginning-of-line)
;; Extract the line number for the doctest file.
(let ((orig-lineno (string-to-int (match-string 1))))
(when (equal doctest-results-py-version 'py21)
(setq orig-lineno (+ orig-lineno 1)))
(dolist (marker-info example-markers)
(when (= orig-lineno (cdr marker-info))
(setq marker (car marker-info)))))
;; Update the window cursor.
(beginning-of-line)
(set-window-point results-window (point))
;; Store our position for next time.
(setq doctest-selected-failure (point))
;; Update selection.
(doctest-fontify-line old-selected-failure)
(doctest-fontify-line doctest-selected-failure))))
(cond
;; We found a failure -- move point to the selected failure.
(marker
(goto-char (marker-position marker))
(beginning-of-line))
;; We didn't find a failure, but there is one -- wrap.
((> (length doctest-example-markers) 0)
(if (>= count 0) (doctest-first-failure) (doctest-last-failure)))
;; We didn't find a failure -- alert the user.
(t (message "No failures found!")))))))
(defun doctest-prev-failure (count)
"Move to the top of the previous failing example, and highlight
the example's failure description in *doctest-output*."
(interactive "p")
(doctest-next-failure (- count)))
(defun doctest-first-failure ()
"Move to the top of the first failing example, and highlight
the example's failure description in *doctest-output*."
(interactive)
(if (buffer-live-p doctest-results-buffer)
(save-excursion
(set-buffer doctest-results-buffer)
(let ((old-selected-failure doctest-selected-failure))
(setq doctest-selected-failure (point-min))
(doctest-fontify-line old-selected-failure))))
(doctest-next-failure 1))
(defun doctest-last-failure ()
"Move to the top of the last failing example, and highlight
the example's failure description in *doctest-output*."
(interactive)
(if (buffer-live-p doctest-results-buffer)
(save-excursion
(set-buffer doctest-results-buffer)
(let ((old-selected-failure doctest-selected-failure))
(setq doctest-selected-failure (point-max))
(doctest-fontify-line old-selected-failure))))
(doctest-next-failure -1))
(defun doctest-select-failure ()
"Move to the top of the currently selected example, and select that
example in the source buffer. Intended for use in the results
buffer."
(interactive)
(re-search-backward doctest-results-divider-re)
(let ((old-selected-failure doctest-selected-failure))
(setq doctest-selected-failure (point))
(doctest-fontify-line doctest-selected-failure)
(doctest-fontify-line old-selected-failure))
(pop-to-buffer doctest-source-buffer)
(doctest-next-failure 1))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Replace Output
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun doctest-replace-output ()
"Move to the top of the closest example, and replace its output
with the 'got' output from the *doctest-output* buffer. An error is
displayed if the chosen example is not listed in *doctest-output*, or
if the 'expected' output for the example does not exactly match the
output listed in the source buffer. The user is asked to confirm the
replacement."
(interactive)
;; Move to the beginning of the example.
(cond
((and doctest-async (doctest-process-live-p doctest-async-process))
(message "Wait for doctest to finish running!"))
((not (doctest-results-buffer-valid-p))
(message "Run doctest first! (C-c C-c)"))
((save-excursion (set-buffer doctest-results-buffer)
(equal doctest-results-py-version 'py21))
(error "doctest-replace-output requires python 2.4+"))
(t
(save-excursion
(save-restriction
(when (doctest-in-mmm-docstring-overlay)
(doctest-narrow-to-mmm-overlay))
(let* ((orig-buffer (current-buffer))
;; Find an example, and look up its original lineno.
(lineno (doctest-prev-example-marker))
;; Find the example's indentation.
(prompt-indent (doctest-line-indentation)))
;; Switch to the output buffer, and look for the example.
;; If we don't find one, complain.
(cond
((null lineno) (message "Doctest example not found"))
(t
(set-buffer doctest-results-buffer)
(goto-char (point-min))
(let ((output-re (format "^File .*, line %s," lineno)))
(when (not (re-search-forward output-re nil t))
(message "This doctest example did not fail")
(setq lineno nil)))))
;; If we didn't find an example, give up.
(when (not (null lineno))
;; Get the output's 'expected' & 'got' texts.
(let ((doctest-got nil) (doctest-expected nil) (header nil))
(while (setq header (doctest-results-next-header))
(cond
((equal header "Failed example:")
t)
((equal header "Expected nothing")
(setq doctest-expected ""))
((equal header "Expected:")
(unless (re-search-forward "^\\(\\( \\).*\n\\)*" nil t)
(error "Error parsing doctest output"))
(setq doctest-expected (doctest-replace-regexp-in-string
"^ " prompt-indent
(match-string 0))))
((equal header "Got nothing")
(setq doctest-got ""))
((or (equal header "Got:") (equal header "Exception raised:"))
(unless (re-search-forward "^\\(\\( \\).*\n\\)*" nil t)
(error "Error parsing doctest output"))
(setq doctest-got (doctest-replace-regexp-in-string
"^ " prompt-indent (match-string 0))))
((string-match "^Differences" header)
(error (concat "doctest-replace-output can not be used "
"with diff style output")))
(t (error "Unexpected header %s" header))))
;; Go back to the source buffer.
(set-buffer orig-buffer)
;; Skip ahead to the output.
(beginning-of-line)
(unless (re-search-forward "^ *>>>.*")
(error "Error parsing doctest output"))
(re-search-forward "\\(\n *\\.\\.\\..*\\)*\n?")
(when (looking-at "\\'") (insert-char ?\n))
;; Check that the output matches.
(let ((start (point)) end)
(cond ((re-search-forward "^ *\\(>>>.*\\|$\\)" nil t)
(setq end (match-beginning 0)))
(t
(goto-char (point-max))
(insert-string "\n")
(setq end (point-max))))
(when (and doctest-expected
(not (equal (buffer-substring start end)
doctest-expected)))
(warn "{%s} {%s}" (buffer-substring start end)
doctest-expected)
(error (concat "This example's output has been modified "
"since doctest was last run")))
(setq doctest-expected (buffer-substring start end))
(goto-char end))
;; Trim exceptions
(when (and doctest-trim-exceptions
(string-match doctest-traceback-re
doctest-got))
(let ((s1 0) (e1 (match-end 1))
(s2 (match-beginning 2)) (e2 (match-end 2))
(s3 (match-beginning 3)) (e3 (length doctest-got)))
(setq doctest-got
(concat (substring doctest-got s1 e1)
(substring doctest-got s2 e2) " . . .\n"
(substring doctest-got s3 e3)))))
;; Confirm it with the user.
(let ((confirm-buffer (get-buffer-create "*doctest-confirm*")))
(set-buffer confirm-buffer)
;; Erase anything left over in the buffer.
(delete-region (point-min) (point-max))
;; Write a confirmation message
(if (equal doctest-expected "")
(insert-string "Replace nothing\n")
(insert-string (concat "Replace:\n" doctest-expected)))
(if (equal doctest-got "")
(insert-string "With nothing\n")
(insert-string (concat "With:\n" doctest-got)))
(let ((confirm-window (display-buffer confirm-buffer)))
;; Shrink the confirm window.
(shrink-window-if-larger-than-buffer confirm-window)
;; Return to the original buffer.
(set-buffer orig-buffer)
;; Match the old expected region.
(when doctest-expected
(search-backward doctest-expected))
(when (equal doctest-expected "") (backward-char 1))
;; Get confirmation & do the replacement
(widen)
(cond ((y-or-n-p "Ok to replace? ")
(when (equal doctest-expected "") (forward-char 1))
(replace-match doctest-got t t)
(message "Replaced."))
(t
(message "Replace cancelled.")))
;; Clean up our confirm window
(kill-buffer confirm-buffer)
(delete-window confirm-window)))))))))))
(defun doctest-results-next-header ()
"Move to the next header in the doctest results buffer, and return
the string contents of that header. If no header is found, return
nil."
(if (re-search-forward (concat doctest-results-header-re "\\|"
doctest-results-divider-re) nil t)
(let ((result (match-string 0)))
(if (string-match doctest-results-header-re result)
result
nil))
nil))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; mmm-mode support
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; MMM Mode is a minor mode for Emacs which allows Multiple Major
;; Modes to coexist in a single buffer.
;;;###autoload
(defun doctest-register-mmm-classes (&optional add-mode-ext-classes
fix-mmm-fontify-region-bug)
"Register doctest's mmm classes, allowing doctest to be used as a
submode region in other major modes, such as python-mode and rst-mode.
Two classes are registered:
`doctest-docstring'
Used to edit docstrings containing doctest examples in python-
mode. Docstring submode regions start and end with triple-quoted
strings (\"\"\"). In order to avoid confusing start-string
markers and end-string markers, all triple-quote strings in the
buffer are treated as submode regions (even if they're not
actually docstrings). Use (C-c % C-d) to insert a new doctest-
docstring region. When `doctest-execute' (C-c C-c) is called
inside a doctest-docstring region, it executes just the current
docstring. The globals for this execution are constructed by
importing the current buffer's contents in Python.
`doctest-example'
Used to edit doctest examples in text-editing modes, such as
`rst-mode' or `text-mode'. Docstring submode regions start with
optionally indented prompts (>>>) and end with blank lines. Use
(C-c % C-e) to insert a new doctest-example region. When
`doctest-execute' (C-c C-c) is called inside a doctest-example
region, it executes all examples in the buffer.
If ADD-MODE-EXT-CLASSES is true, then register the new classes in
`mmm-mode-ext-classes-alist', which will cause them to be used by
default in the following modes:
doctest-docstring: python-mode
doctest-example: rst-mode
If FIX-MMM-FONTIFY-REGION-BUG is true, then register a hook that will
fix a bug in `mmm-fontify-region' that affects some (but not all)
versions of emacs. (See `doctest-fixed-mmm-fontify-region' for more
info.)"
(interactive)
(require 'mmm-auto)
(mmm-add-classes
'(
;; === doctest-docstring ===
(doctest-docstring :submode doctest-mode
;; The front is any triple-quote. Include it in the submode region,
;; to prevent clashes between the two syntax tables over quotes.
:front "\\(\"\"\"\\|'''\\)" :include-front t
;; The back matches the front. Include just the first character
;; of the quote. If we didn't include at least one quote, then
;; the outer modes quote-counting would be thrown off. But if
;; we include all three, we run into a bug in mmm-mode. See
;; for more info about the bug.
:save-matches t :back "~1" :back-offset 1 :end-not-begin t
;; Define a skeleton for entering new docstrings.
:insert ((?d docstring nil @ "\"\"" @ "\"" \n
_ \n "\"" @ "\"\"" @)))
;; === doctest-example ===
(doctest-example
:submode doctest-mode
;; The front is an optionally indented prompt.
:front "^[ \t]*>>>" :include-front t
;; The back is a blank line.
:back "^[ \t]*$"
;; Define a skeleton for entering new docstrings.
:insert ((?e doctest-example nil
@ @ " >>> " _ "\n\n" @ @)))))
;; Register some local variables that need to be saved.
(add-to-list 'mmm-save-local-variables
'(doctest-results-buffer buffer))
(add-to-list 'mmm-save-local-variables
'(doctest-example-markers buffer))
;; Register association with modes, if requested.
(when add-mode-ext-classes
(mmm-add-mode-ext-class 'python-mode nil 'doctest-docstring)
(mmm-add-mode-ext-class 'rst-mode nil 'doctest-example))
;; Fix the buggy mmm-fontify-region, if requested.
(when fix-mmm-fontify-region-bug
(add-hook 'mmm-mode-hook 'doctest-fix-mmm-fontify-region-bug)))
(defvar doctest-old-mmm-fontify-region 'nil
"Used to hold the original definition of `mmm-fontify-region' when it
is rebound by `doctest-fix-mmm-fontify-region-bug'.")
(defun doctest-fix-mmm-fontify-region-bug ()
"A function for `mmm-mode-hook' which fixes a potential bug in
`mmm-fontify-region' by using `doctest-fixed-mmm-fontify-region'
instead. (See `doctest-fixed-mmm-fontify-region' for more info.)"
(setq font-lock-fontify-region-function
'doctest-fixed-mmm-fontify-region))
(defun doctest-fixed-mmm-fontify-region (start stop &optional loudly)
"A replacement for `mmm-fontify-region', which fixes a bug caused by
versions of emacs where post-command-hooks are run *before*
fontification. `mmm-mode' assumes that its post-command-hook will be
run after fontification; and if it's not, then mmm-mode can end up
with the wrong local variables, keymap, etc. after fontification. We
fix that here by redefining `mmm-fontify-region' to remember what
submode overlay it started in; and to return to that overlay after
fontification is complete. The original definition of
`mmm-fontify-region' is stored in `doctest-old-mmm-fontify-region'."
(let ((overlay mmm-current-overlay))
(mmm-fontify-region start stop loudly)
(if (and overlay (or (< (point) (overlay-start overlay))
(> (point) (overlay-end overlay))))
(goto-char (overlay-start overlay)))
(mmm-update-submode-region)))
(defun doctest-in-mmm-docstring-overlay ()
(and (featurep 'mmm-auto)
(mmm-overlay-at (point))
(save-excursion
(goto-char (overlay-start (mmm-overlay-at (point))))
(looking-at "\"\"\"\\|\'\'\'"))))
(defun doctest-narrow-to-mmm-overlay ()
"If we're in an mmm-mode overlay, then narrow to that overlay.
This is useful, e.g., to keep from interpreting the close-quote of a
docstring as part of the example's output."
(let ((bounds (doctest-mmm-overlay-bounds)))
(when bounds (narrow-to-region (car bounds) (cdr bounds)))))
(defun doctest-default-margin-in-mmm-docstring-overlay ()
(save-excursion
(let ((pos (car (doctest-mmm-overlay-bounds))))
(goto-char pos)
(when (doctest-looking-back "\"\"\"\\|\'\'\'")
(setq pos (- pos 3)))
(beginning-of-line)
(- pos (point)))))
(defun doctest-mmm-overlay-bounds ()
(when (featurep 'mmm-auto)
(let ((overlay (mmm-overlay-at (point))))
(when overlay
(let ((start (overlay-start overlay))
(end (overlay-end overlay)))
(when (doctest-in-mmm-docstring-overlay)
(save-excursion
(goto-char start)
(re-search-forward "[\"\']*")
(setq start (point))
(goto-char end)
(while (doctest-looking-back "[\"\']")
(backward-char 1))
(setq end (point))))
(cons start end))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Helper functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun doctest-on-source-line-p (&optional prompt)
"Return true if the current line is a source line. The optional
argument prompt can be used to specify which type of source
line (... or >>>)."
(save-excursion
(beginning-of-line)
;; Check if we're looking at a prompt (of the right type).
(when (and (looking-at doctest-prompt-re)
(or (null prompt)
(equal prompt (substring (match-string 2) 0 3))))
;; Scan backwards to make sure there's a >>> somewhere. Otherwise,
;; this might be a '...' in the text or in an example's output.
(while (looking-at "^[ \t]*[.][.][.]")
(forward-line -1))
(looking-at "^[ \t]*>>>"))))
(defun doctest-on-empty-source-line-p ()
"Return true if the current line contains a bare prompt."
(save-excursion
(beginning-of-line)
(and (doctest-on-source-line-p)
(looking-at (concat doctest-prompt-re "$")))))
(defun doctest-on-output-line-p ()
"Return true if the current line is an output line."
(save-excursion
(beginning-of-line)
;; The line must not be blank or a source line.
(when (not (or (doctest-on-source-line-p) (looking-at "[ \t]*$")))
;; The line must follow a source line, with no intervening blank
;; lines.
(while (not (or (doctest-on-source-line-p) (looking-at "[ \t]*$")
(= (point) (point-min))))
(forward-line -1))
(doctest-on-source-line-p))))
(defun doctest-find-output-line (&optional limit)
"Move forward to the next doctest output line (staying within
the given bounds). Return the character position of the doctest
output line if one was found, and false otherwise."
(let ((found-it nil) ; point where we found an output line
(limit (or limit (point-max)))) ; default value for limit
(save-excursion
;; Keep moving forward, one line at a time, until we find a
;; doctest output line.
(while (and (not found-it) (< (point) limit) (not (eobp)))
(if (and (not (eolp)) (doctest-on-output-line-p))
(setq found-it (point))
(forward-line))))
;; If we found a doctest output line, then go to it.
(if found-it (goto-char found-it))))
(defun doctest-line-indentation ()
"Helper for doctest-replace-output: return the whitespace indentation
at the beginning of this line."
(save-excursion
(end-of-line)
(re-search-backward "^\\( *\\)" nil t)
(match-string 1)))
(defun doctest-optionflags (&optional diff)
"Return a string describing the optionflags that should be used
by doctest. If DIFF is non-nil, then add the REPORT_UDIFF flag."
(let ((flags "0"))
(dolist (flag doctest-optionflags)
(setq flags (concat flags "|" flag)))
(if diff (concat flags "|" "REPORT_UDIFF") flags)))
(defun doctest-results-loc-re ()
"Return the regexp that should be used to look for doctest example
location markers in doctest's output (based on which version of
doctest was used"
(cond
((equal doctest-results-py-version 'py21)
doctest-py21-results-loc-re)
((equal doctest-results-py-version 'py24)
doctest-py24-results-loc-re)
(t (error "bad value for doctest-results-py-version"))))
(defun doctest-results-buffer-name ()
"Return the buffer name that should be used for the doctest results
buffer. This is computed from the variable
`doctest-results-buffer-name'."
(doctest-replace-regexp-in-string
"%[nfN]"
(lambda (sym)
(cond ((equal sym "%n") (buffer-name))
((equal sym "%N") (doctest-replace-regexp-in-string
"[.]doctest$" "" (buffer-name) t))
((equal sym "%f") (buffer-file-name))))
doctest-results-buffer-name t))
(defun doctest-script (input-file globs-file diff)
"..."
(doctest-replace-regexp-in-string
"%[tnflm]"
(lambda (sym)
(cond ((equal sym "%n") (buffer-name))
((equal sym "%f") (buffer-file-name))
((equal sym "%l") (doctest-optionflags diff))
((equal sym "%t") input-file)
((equal sym "%m") (or globs-file ""))))
doctest-script t))
(defun doctest-hide-example-source ()
"Delete the source code listings from the results buffer (since it's
easy enough to see them in the original buffer)"
(save-excursion
(set-buffer doctest-results-buffer)
(toggle-read-only 0)
(goto-char (point-min))
(while (re-search-forward doctest-example-source-re nil t)
(replace-match "" nil nil))
(toggle-read-only t)))
(defun doctest-results-buffer-valid-p ()
"Return true if this buffer has a live results buffer; and that
results buffer reports this buffer as its source buffer. (Two
buffers in doctest-mode might point to the same results buffer;
but only one of them will be equal to that results buffer's
source buffer."
(let ((cur-buf (current-buffer)))
(and (buffer-live-p doctest-results-buffer)
(save-excursion
(set-buffer doctest-results-buffer)
(equal cur-buf doctest-source-buffer)))))
(defun doctest-update-mode-line (value)
"Update the doctest mode line with the given string value. This
is used to display information about asynchronous processes that
are run by doctest-mode."
(setq doctest-mode-line-process
value)
(force-mode-line-update t))
(defun doctest-version ()
"Echo the current version of `doctest-mode' in the minibuffer."
(interactive)
(message "Using `doctest-mode' version %s" doctest-version))
(defun doctest-warn (msg &rest args)
"Display a doctest warning message."
(if (fboundp 'display-warning)
(display-warning 'doctest (apply 'format msg args))
(apply 'message msg args)))
(defun doctest-debug (msg &rest args)
"Display a doctest debug message."
(if (fboundp 'display-warning)
(display-warning 'doctest (apply 'format msg args) 'debug)
(apply 'message msg args)))
(defvar doctest-serial-number 0) ;used if broken-temp-names.
(defun doctest-temp-name ()
"Return a new temporary filename, for use in calling doctest."
(if (memq 'broken-temp-names features)
(let
((sn doctest-serial-number)
(pid (and (fboundp 'emacs-pid) (emacs-pid))))
(setq doctest-serial-number (1+ doctest-serial-number))
(if pid
(format "doctest-%d-%d" sn pid)
(format "doctest-%d" sn)))
(make-temp-name "doctest-")))
(defun doctest-fontify-line (charpos)
"Run font-lock-fontify-region on the line containing the given
position."
(if (and charpos (functionp 'font-lock-fontify-region))
(save-excursion
(goto-char charpos)
(let ((beg (progn (beginning-of-line) (point)))
(end (progn (end-of-line) (point))))
(font-lock-fontify-region beg end)))))
(defun doctest-do-auto-fill ()
"If the current line is a soucre line or an output line, do nothing.
Otherwise, call (do-auto-fill)."
(cond
;; Don't wrap source lines.
((doctest-on-source-line-p) nil)
;; Don't wrap output lines
((doctest-on-output-line-p) nil)
;; Wrap all other lines
(t (do-auto-fill))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Emacs Compatibility Functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Define compatible versions of functions that are defined
;; for some versions of emacs but not others.
;; Backwards compatibility: looking-back
(cond ((fboundp 'looking-back) ;; Emacs 22.x
(defalias 'doctest-looking-back 'looking-back))
(t
(defun doctest-looking-back (regexp)
"Return true if text before point matches REGEXP."
(save-excursion
(let ((orig-pos (point)))
;; Search backwards for the regexp.
(if (re-search-backward regexp nil t)
;; Check if it ends at the original point.
(= orig-pos (match-end 0))))))))
;; Backwards compatibility: replace-regexp-in-string
(cond ((fboundp 'replace-regexp-in-string)
(defalias 'doctest-replace-regexp-in-string 'replace-regexp-in-string))
(t ;; XEmacs 21.x or Emacs 20.x
(defun doctest-replace-regexp-in-string
(regexp rep string &optional fixedcase literal)
"Replace all matches for REGEXP with REP in STRING."
(let ((start 0))
(while (and (< start (length string))
(string-match regexp string start))
(setq start (+ (match-end 0) 1))
(let ((newtext (if (functionp rep)
(save-match-data
(funcall rep (match-string 0 string)))
rep)))
(setq string (replace-match newtext fixedcase
literal string)))))
string)))
;; Backwards compatibility: line-number
(cond ((fboundp 'line-number) ;; XEmacs
(defalias 'doctest-line-number 'line-number))
((fboundp 'line-number-at-pos) ;; Emacs 22.x
(defalias 'doctest-line-number 'line-number-at-pos))
(t ;; Emacs 21.x
(defun doctest-line-number (&optional pos)
"Return the line number of POS (default=point)."
(1+ (count-lines 1
(save-excursion (progn (beginning-of-line)
(or pos (point)))))))))
;; Backwards compatibility: process-live-p
(cond ((fboundp 'process-live-p) ;; XEmacs
(defalias 'doctest-process-live-p 'process-live-p))
(t ;; Emacs
(defun doctest-process-live-p (process)
(and (processp process)
(equal (process-status process) 'run)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Doctest Results Mode (output of doctest-execute-buffer)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Register the font-lock keywords (xemacs)
(put 'doctest-results-mode 'font-lock-defaults
'(doctest-results-font-lock-keywords))
;; Register the font-lock keywords (older versions of gnu emacs)
(when (boundp 'font-lock-defaults-alist)
(add-to-list 'font-lock-defaults-alist
'(doctest-results-mode doctest-results-font-lock-keywords
nil nil nil nil)))
(defvar doctest-selected-failure nil
"The location of the currently selected failure.
This variable is uffer-local to doctest-results-mode buffers.")
(defvar doctest-source-buffer nil
"The buffer that spawned this one.
This variable is uffer-local to doctest-results-mode buffers.")
(defvar doctest-results-py-version nil
"A symbol indicating which version of Python was used to generate
the results in a doctest-results-mode buffer. Can be either the
symbol `py21' or the symbol `py24'.
This variable is uffer-local to doctest-results-mode buffers.")
;; Keymap for doctest-results-mode.
(defconst doctest-results-mode-map
(let ((map (make-keymap)))
(define-key map [return] 'doctest-select-failure)
map)
"Keymap for doctest-results-mode.")
;; Syntax table for doctest-results-mode.
(defvar doctest-results-mode-syntax-table nil
"Syntax table used in `doctest-results-mode' buffers.")
(when (not doctest-results-mode-syntax-table)
(setq doctest-results-mode-syntax-table (make-syntax-table))
(dolist (entry '(("(" . "()") ("[" . "(]") ("{" . "(}")
(")" . ")(") ("]" . ")[") ("}" . "){")
("$%&*+-/<=>|'\"`" . ".") ("_" . "w")))
(dolist (char (string-to-list (car entry)))
(modify-syntax-entry char (cdr entry)
doctest-results-mode-syntax-table))))
;; Define the mode
(defun doctest-results-mode ()
"A major mode used to display the results of running doctest.
See `doctest-mode'.
\\{doctest-results-mode-map}"
(interactive)
;; Declare local variables.
(kill-all-local-variables)
(make-local-variable 'font-lock-defaults)
(make-local-variable 'doctest-selected-failure)
(make-local-variable 'doctest-source-buffer)
(make-local-variable 'doctest-results-py-version)
;; Define local variables.
(setq major-mode 'doctest-results-mode
mode-name "Doctest-Results"
mode-line-process 'doctest-mode-line-process
font-lock-defaults '(doctest-results-font-lock-keywords
nil nil nil nil))
;; Define keymap.
(use-local-map doctest-results-mode-map)
;; Define the syntax table.
(set-syntax-table doctest-results-mode-syntax-table)
;; Enable font-lock mode.
(if (featurep 'font-lock) (font-lock-mode 1)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Doctest Mode
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Register the font-lock keywords (xemacs)
(put 'doctest-mode 'font-lock-defaults '(doctest-font-lock-keywords
nil nil nil nil))
;; Register the font-lock keywords (older versions of gnu emacs)
(when (boundp 'font-lock-defaults-alist)
(add-to-list 'font-lock-defaults-alist
'(doctest-mode doctest-font-lock-keywords
nil nil nil nil)))
(defvar doctest-results-buffer nil
"The output buffer for doctest-mode.
This variable is buffer-local to doctest-mode buffers.")
(defvar doctest-example-markers nil
"A list mapping markers to the line numbers at which they appeared
in the buffer at the time doctest was last run. This is used to find
'original' line numbers, which can be used to search the doctest
output buffer. It's encoded as a list of (MARKER . POS) tuples, in
reverse POS order.
This variable is buffer-local to doctest-mode buffers.")
;; These are global, since we only one run process at a time:
(defvar doctest-async-process nil
"The process object created by the asynchronous doctest process")
(defvar doctest-async-process-tempfiles nil
"A list of tempfile names created by the asynchronous doctest process")
(defvar doctest-async-process-buffer nil
"The source buffer for the asynchronous doctest process")
(defvar doctest-mode-line-process ""
"A string displayed on the modeline, to indicate when doctest is
running asynchronously.")
;; Keymap for doctest-mode. n.b.: we intentionally define [tab]
;; rather than overriding indent-line-function, since we don't want
;; doctest-indent-source-line to be called by do-auto-fill.
(defconst doctest-mode-map
(let ((map (make-keymap)))
(define-key map [backspace] 'doctest-electric-backspace)
(define-key map [return] 'doctest-newline-and-indent)
(define-key map [tab] 'doctest-indent-source-line)
(define-key map ":" 'doctest-electric-colon)
(define-key map "\C-c\C-v" 'doctest-version)
(define-key map "\C-c\C-c" 'doctest-execute)
(define-key map "\C-c\C-d" 'doctest-execute-with-diff)
(define-key map "\C-c\C-n" 'doctest-next-failure)
(define-key map "\C-c\C-p" 'doctest-prev-failure)
(define-key map "\C-c\C-a" 'doctest-first-failure)
(define-key map "\C-c\C-e" 'doctest-last-failure)
(define-key map "\C-c\C-z" 'doctest-last-failure)
(define-key map "\C-c\C-r" 'doctest-replace-output)
(define-key map "\C-c|" 'doctest-execute-region)
map)
"Keymap for doctest-mode.")
;; Syntax table for doctest-mode.
(defvar doctest-mode-syntax-table nil
"Syntax table used in `doctest-mode' buffers.")
(when (not doctest-mode-syntax-table)
(setq doctest-mode-syntax-table (make-syntax-table))
(dolist (entry '(("(" . "()") ("[" . "(]") ("{" . "(}")
(")" . ")(") ("]" . ")[") ("}" . "){")
("$%&*+-/<=>|'\"`" . ".") ("_" . "w")))
(dolist (char (string-to-list (car entry)))
(modify-syntax-entry char (cdr entry) doctest-mode-syntax-table))))
;; Use doctest mode for files ending in .doctest
;;;###autoload
(add-to-list 'auto-mode-alist '("\\.doctest$" . doctest-mode))
;;;###autoload
(defun doctest-mode ()
"A major mode for editing text files that contain Python
doctest examples. Doctest is a testing framework for Python that
emulates an interactive session, and checks the result of each
command. For more information, see the Python library reference:
`doctest-mode' defines three kinds of line, each of which is
treated differently:
- 'Source lines' are lines consisting of a Python prompt
('>>>' or '...'), followed by source code. Source lines are
colored (similarly to `python-mode') and auto-indented.
- 'Output lines' are non-blank lines immediately following
source lines. They are colored using several doctest-
specific output faces.
- 'Text lines' are any other lines. They are not processed in
any special way.
\\{doctest-mode-map}"
(interactive)
;; Declare local variables.
(kill-all-local-variables)
(make-local-variable 'font-lock-defaults)
(make-local-variable 'doctest-results-buffer)
(make-local-variable 'doctest-example-markers)
;; Define local variables.
(setq major-mode 'doctest-mode
mode-name "Doctest"
mode-line-process 'doctest-mode-line-process
font-lock-defaults '(doctest-font-lock-keywords
nil nil nil nil))
;; Define keymap.
(use-local-map doctest-mode-map)
;; Define the syntax table.
(set-syntax-table doctest-mode-syntax-table)
;; Enable auto-fill mode.
(auto-fill-mode 1)
(setq auto-fill-function 'doctest-do-auto-fill)
;; Enable font-lock mode.
(if (featurep 'font-lock) (font-lock-mode 1))
;; Run the mode hook.
(run-hooks 'doctest-mode-hook))
(provide 'doctest-mode)
;;; doctest-mode.el ends here
python-mode.el-6.2.3/test/py-ert-variablen-tests.el 0000644 0000000 0000000 00000063171 13035134274 022156 0 ustar root root 0000000 0000000 (ert-deftest py-ert-last-exeption-buffer-test ()
(should (boundp 'py-last-exeption-buffer)))
(ert-deftest py-ert-keywords-test ()
(should (boundp 'py-keywords)))
(ert-deftest py-ert-pdbtrack-is-tracking-p-test ()
(should (boundp 'py-pdbtrack-is-tracking-p)))
(ert-deftest py-ert-underscore-word-syntax-p-test ()
(should (boundp 'py-underscore-word-syntax-p)))
(ert-deftest py-ert-auto-fill-mode-orig-test ()
(should (boundp 'py-auto-fill-mode-orig)))
(ert-deftest py-ert-kill-empty-line-test ()
(should (boundp 'py-kill-empty-line)))
(ert-deftest py-ert-match-paren-key-test ()
(should (boundp 'py-match-paren-key)))
(ert-deftest py-ert-match-paren-mode-test ()
(should (boundp 'py-match-paren-mode)))
(ert-deftest py-ert-ipython-shell-mode-map-test ()
(should (boundp 'py-ipython-shell-mode-map)))
(ert-deftest py-ert-python-shell-mode-map-test ()
(should (boundp 'py-python-shell-mode-map)))
(ert-deftest py-ert-shell-map-test ()
(should (boundp 'py-shell-map)))
(ert-deftest py-ert-eldoc-string-code-test ()
(should (boundp 'py-eldoc-string-code)))
(ert-deftest py-ert-chars-after-test ()
(should (boundp 'py-chars-after)))
(ert-deftest py-ert-chars-before-test ()
(should (boundp 'py-chars-before)))
(ert-deftest py-ert-ask-about-save-test ()
(should (boundp 'py-ask-about-save)))
(ert-deftest py-ert-auto-complete-p-test ()
(should (boundp 'py-auto-complete-p)))
(ert-deftest py-ert--auto-complete-timer-delay-test ()
(should (boundp 'py--auto-complete-timer-delay)))
(ert-deftest py-ert-auto-fill-mode-test ()
(should (boundp 'py-auto-fill-mode)))
(ert-deftest py-ert-autofill-timer-delay-test ()
(should (boundp 'py-autofill-timer-delay)))
(ert-deftest py-ert-autopair-mode-test ()
(should (boundp 'py-autopair-mode)))
(ert-deftest py-ert-backslashed-lines-indent-offset-test ()
(should (boundp 'py-backslashed-lines-indent-offset)))
(ert-deftest py-ert-beep-if-tab-change-test ()
(should (boundp 'py-beep-if-tab-change)))
(ert-deftest py-ert-block-comment-prefix-test ()
(should (boundp 'py-block-comment-prefix)))
(ert-deftest py-ert-block-comment-prefix-p-test ()
(should (boundp 'py-block-comment-prefix-p)))
(ert-deftest py-ert-check-command-test ()
(should (boundp 'py-check-command)))
(ert-deftest py-ert-close-provides-newline-test ()
(should (boundp 'py-close-provides-newline)))
(ert-deftest py-ert-closing-list-dedents-bos-test ()
(should (boundp 'py-closing-list-dedents-bos)))
(ert-deftest py-ert-closing-list-keeps-space-test ()
(should (boundp 'py-closing-list-keeps-space)))
(ert-deftest py-ert-closing-list-space-test ()
(should (boundp 'py-closing-list-space)))
(ert-deftest py-ert-comment-fill-column-test ()
(should (boundp 'py-comment-fill-column)))
(ert-deftest py-ert-company-pycomplete-p-test ()
(should (boundp 'py-company-pycomplete-p)))
(ert-deftest py-ert-compilation-regexp-alist-test ()
(should (boundp 'py-compilation-regexp-alist)))
(ert-deftest py-ert-complete-ac-sources-test ()
(should (boundp 'py-complete-ac-sources)))
(ert-deftest py-ert-complete-function-test ()
(should (boundp 'py-complete-function)))
(ert-deftest py-ert-continuation-offset-test ()
(should (boundp 'py-continuation-offset)))
(ert-deftest py-ert-current-defun-delay-test ()
(should (boundp 'py-current-defun-delay)))
(ert-deftest py-ert-current-defun-show-test ()
(should (boundp 'py-current-defun-show)))
(ert-deftest py-ert-custom-temp-directory-test ()
(should (boundp 'py-custom-temp-directory)))
(ert-deftest py-ert-debug-p-test ()
(should (boundp 'py-debug-p)))
(ert-deftest py-ert-dedent-keep-relative-column-test ()
(should (boundp 'py-dedent-keep-relative-column)))
(ert-deftest py-ert-dedicated-process-p-test ()
(should (boundp 'py-dedicated-process-p)))
(ert-deftest py-ert-defun-use-top-level-p-test ()
(should (boundp 'py-defun-use-top-level-p)))
(ert-deftest py-ert-delete-function-test ()
(should (boundp 'py-delete-function)))
(ert-deftest py-ert-docstring-fill-column-test ()
(should (boundp 'py-docstring-fill-column)))
(ert-deftest py-ert-docstring-style-test ()
(should (boundp 'py-docstring-style)))
(ert-deftest py-ert-edit-only-p-test ()
(should (boundp 'py-edit-only-p)))
(ert-deftest py-ert-electric-colon-active-p-test ()
(should (boundp 'py-electric-colon-active-p)))
(ert-deftest py-ert-electric-colon-bobl-only-test ()
(should (boundp 'py-electric-colon-bobl-only)))
(ert-deftest py-ert-electric-colon-greedy-p-test ()
(should (boundp 'py-electric-colon-greedy-p)))
(ert-deftest py-ert-electric-colon-newline-and-indent-p-test ()
(should (boundp 'py-electric-colon-newline-and-indent-p)))
(ert-deftest py-ert-electric-comment-add-space-p-test ()
(should (boundp 'py-electric-comment-add-space-p)))
(ert-deftest py-ert-electric-comment-p-test ()
(should (boundp 'py-electric-comment-p)))
(ert-deftest py-ert-electric-kill-backward-p-test ()
(should (boundp 'py-electric-kill-backward-p)))
(ert-deftest py-ert-electric-yank-active-p-test ()
(should (boundp 'py-electric-yank-active-p)))
(ert-deftest py-ert-empty-comment-line-separates-paragraph-p-test ()
(should (boundp 'py-empty-comment-line-separates-paragraph-p)))
(ert-deftest py-ert-empty-line-closes-p-test ()
(should (boundp 'py-empty-line-closes-p)))
(ert-deftest py-ert-encoding-string-test ()
(should (boundp 'py-encoding-string)))
(ert-deftest py-ert-error-markup-delay-test ()
(should (boundp 'py-error-markup-delay)))
(ert-deftest py-ert-execute-directory-test ()
(should (boundp 'py-execute-directory)))
(ert-deftest py-ert-execute-no-temp-p-test ()
(should (boundp 'py-execute-no-temp-p)))
(ert-deftest py-ert-extensions-test ()
(should (boundp 'py-extensions)))
(ert-deftest py-ert-fast-completion-delay-test ()
(should (boundp 'py-fast-completion-delay)))
(ert-deftest py-ert-fast-process-p-test ()
(should (boundp 'py-fast-process-p)))
(ert-deftest py-ert-ffap-p-test ()
(should (boundp 'py-ffap-p)))
(ert-deftest py-ert-fileless-buffer-use-default-directory-p-test ()
(should (boundp 'py-fileless-buffer-use-default-directory-p)))
(ert-deftest py-ert-flake8-command-test ()
(should (boundp 'py-flake8-command)))
(ert-deftest py-ert-flake8-command-args-test ()
(should (boundp 'py-flake8-command-args)))
(ert-deftest py-ert-fontify-shell-buffer-p-test ()
(should (boundp 'py-fontify-shell-buffer-p)))
(ert-deftest py-ert-force-py-shell-name-p-test ()
(should (boundp 'py-force-py-shell-name-p)))
(ert-deftest py-ert-guess-py-install-directory-p-test ()
(should (boundp 'py-guess-py-install-directory-p)))
(ert-deftest py-ert-hide-comments-when-hiding-all-test ()
(should (boundp 'py-hide-comments-when-hiding-all)))
(ert-deftest py-ert-hide-show-hide-docstrings-test ()
(should (boundp 'py-hide-show-hide-docstrings)))
(ert-deftest py-ert-hide-show-keywords-test ()
(should (boundp 'py-hide-show-keywords)))
(ert-deftest py-ert-hide-show-minor-mode-p-test ()
(should (boundp 'py-hide-show-minor-mode-p)))
(ert-deftest py-ert-highlight-error-source-p-test ()
(should (boundp 'py-highlight-error-source-p)))
(ert-deftest py-ert-history-filter-regexp-test ()
(should (boundp 'py-history-filter-regexp)))
(ert-deftest py-ert-honor-IPYTHONDIR-p-test ()
(should (boundp 'py-honor-IPYTHONDIR-p)))
(ert-deftest py-ert-honor-PYTHONHISTORY-p-test ()
(should (boundp 'py-honor-PYTHONHISTORY-p)))
(ert-deftest py-ert-if-name-main-permission-p-test ()
(should (boundp 'py-if-name-main-permission-p)))
(ert-deftest py-ert--imenu-create-index-function-test ()
(should (boundp 'py--imenu-create-index-function)))
(ert-deftest py-ert--imenu-create-index-p-test ()
(should (boundp 'py--imenu-create-index-p)))
(ert-deftest py-ert-imenu-show-method-args-p-test ()
(should (boundp 'py-imenu-show-method-args-p)))
(ert-deftest py-ert-import-check-point-max-test ()
(should (boundp 'py-import-check-point-max)))
(ert-deftest py-ert-indent-comments-test ()
(should (boundp 'py-indent-comments)))
(ert-deftest py-ert-indent-honors-inline-comment-test ()
(should (boundp 'py-indent-honors-inline-comment)))
(ert-deftest py-ert-indent-honors-multiline-listing-test ()
(should (boundp 'py-indent-honors-multiline-listing)))
(ert-deftest py-ert-indent-no-completion-p-test ()
(should (boundp 'py-indent-no-completion-p)))
(ert-deftest py-ert-indent-offset-test ()
(should (boundp 'py-indent-offset)))
(ert-deftest py-ert-indent-paren-spanned-multilines-p-test ()
(should (boundp 'py-indent-paren-spanned-multilines-p)))
(ert-deftest py-ert-indent-tabs-mode-test ()
(should (boundp 'py-indent-tabs-mode)))
(ert-deftest py-ert-input-filter-re-test ()
(should (boundp 'py-input-filter-re)))
(ert-deftest py-ert-install-directory-test ()
(should (boundp 'py-install-directory)))
(ert-deftest py-ert-ipython-command-test ()
(should (boundp 'py-ipython-command)))
(ert-deftest py-ert-ipython-command-args-test ()
(should (boundp 'py-ipython-command-args)))
(ert-deftest py-ert-ipython-execute-delay-test ()
(should (boundp 'py-ipython-execute-delay)))
(ert-deftest py-ert-ipython-history-test ()
(should (boundp 'py-ipython-history)))
(ert-deftest py-ert-ipython-send-delay-test ()
(should (boundp 'py-ipython-send-delay)))
(ert-deftest py-ert-jump-on-exception-test ()
(should (boundp 'py-jump-on-exception)))
(ert-deftest py-ert-jython-command-test ()
(should (boundp 'py-jython-command)))
(ert-deftest py-ert-jython-command-args-test ()
(should (boundp 'py-jython-command-args)))
(ert-deftest py-ert-jython-packages-test ()
(should (boundp 'py-jython-packages)))
(ert-deftest py-ert-keep-shell-dir-when-execute-p-test ()
(should (boundp 'py-keep-shell-dir-when-execute-p)))
(ert-deftest py-ert-keep-windows-configuration-test ()
(should (boundp 'py-keep-windows-configuration)))
(ert-deftest py-ert-kill-empty-line-test ()
(should (boundp 'py-kill-empty-line)))
(ert-deftest py-ert-lhs-inbound-indent-test ()
(should (boundp 'py-lhs-inbound-indent)))
(ert-deftest py-ert-load-pymacs-p-test ()
(should (boundp 'py-load-pymacs-p)))
(ert-deftest py-ert-load-skeletons-p-test ()
(should (boundp 'py-load-skeletons-p)))
(ert-deftest py-ert-mark-decorators-test ()
(should (boundp 'py-mark-decorators)))
(ert-deftest py-ert-master-file-test ()
(should (boundp 'py-master-file)))
(ert-deftest py-ert-match-paren-key-test ()
(should (boundp 'py-match-paren-key)))
(ert-deftest py-ert-match-paren-mode-test ()
(should (boundp 'py-match-paren-mode)))
(ert-deftest py-ert-max-help-buffer-p-test ()
(should (boundp 'py-max-help-buffer-p)))
(ert-deftest py-ert-max-specpdl-size-test ()
(should (boundp 'py-max-specpdl-size)))
(ert-deftest py-ert-message-executing-temporary-file-test ()
(should (boundp 'py-message-executing-temporary-file)))
(ert-deftest py-ert-modeline-acronym-display-home-p-test ()
(should (boundp 'py-modeline-acronym-display-home-p)))
(ert-deftest py-ert-modeline-display-full-path-p-test ()
(should (boundp 'py-modeline-display-full-path-p)))
(ert-deftest py-ert-newline-delete-trailing-whitespace-p-test ()
(should (boundp 'py-newline-delete-trailing-whitespace-p)))
(ert-deftest py-ert-new-shell-delay-test ()
(should (boundp 'py-new-shell-delay)))
(ert-deftest py-ert-org-cycle-p-test ()
(should (boundp 'py-org-cycle-p)))
(ert-deftest py-ert-outline-minor-mode-p-test ()
(should (boundp 'py-outline-minor-mode-p)))
(ert-deftest py-ert-outline-mode-keywords-test ()
(should (boundp 'py-outline-mode-keywords)))
(ert-deftest py-ert-pdb-executable-test ()
(should (boundp 'py-pdb-executable)))
(ert-deftest py-ert-pdb-path-test ()
(should (boundp 'py-pdb-path)))
(ert-deftest py-ert-pdbtrack-do-tracking-p-test ()
(should (boundp 'py-pdbtrack-do-tracking-p)))
(ert-deftest py-ert-pdbtrack-filename-mapping-test ()
(should (boundp 'py-pdbtrack-filename-mapping)))
(ert-deftest py-ert-pdbtrack-minor-mode-string-test ()
(should (boundp 'py-pdbtrack-minor-mode-string)))
(ert-deftest py-ert-pep8-command-test ()
(should (boundp 'py-pep8-command)))
(ert-deftest py-ert-pep8-command-args-test ()
(should (boundp 'py-pep8-command-args)))
(ert-deftest py-ert-prompt-on-changed-p-test ()
(should (boundp 'py-prompt-on-changed-p)))
(ert-deftest py-ert-pychecker-command-test ()
(should (boundp 'py-pychecker-command)))
(ert-deftest py-ert-pychecker-command-args-test ()
(should (boundp 'py-pychecker-command-args)))
(ert-deftest py-ert-pyflakes-command-test ()
(should (boundp 'py-pyflakes-command)))
(ert-deftest py-ert-pyflakes-command-args-test ()
(should (boundp 'py-pyflakes-command-args)))
(ert-deftest py-ert-pyflakespep8-command-test ()
(should (boundp 'py-pyflakespep8-command)))
(ert-deftest py-ert-pyflakespep8-command-args-test ()
(should (boundp 'py-pyflakespep8-command-args)))
(ert-deftest py-ert-pylint-command-test ()
(should (boundp 'py-pylint-command)))
(ert-deftest py-ert-pylint-command-args-test ()
(should (boundp 'py-pylint-command-args)))
(ert-deftest py-ert-python2-command-test ()
(should (boundp 'py-python2-command)))
(ert-deftest py-ert-python2-command-args-test ()
(should (boundp 'py-python2-command-args)))
(ert-deftest py-ert-python3-command-test ()
(should (boundp 'py-python3-command)))
(ert-deftest py-ert-python3-command-args-test ()
(should (boundp 'py-python3-command-args)))
(ert-deftest py-ert-python-command-test ()
(should (boundp 'py-python-command)))
(ert-deftest py-ert-python-command-args-test ()
(should (boundp 'py-python-command-args)))
(ert-deftest py-ert-python-history-test ()
(should (boundp 'py-python-history)))
(ert-deftest py-ert-python-send-delay-test ()
(should (boundp 'py-python-send-delay)))
(ert-deftest py-ert-remove-cwd-from-path-test ()
(should (boundp 'py-remove-cwd-from-path)))
(ert-deftest py-ert-return-key-test ()
(should (boundp 'py-return-key)))
(ert-deftest py-ert-separator-char-test ()
(should (boundp 'py-separator-char)))
(ert-deftest py-ert-session-p-test ()
(should (boundp 'py-session-p)))
(ert-deftest py-ert-set-complete-keymap-p-test ()
(should (boundp 'py-set-complete-keymap-p)))
(ert-deftest py-ert-set-pager-cat-p-test ()
(should (boundp 'py-set-pager-cat-p)))
(ert-deftest py-ert-sexp-function-test ()
(should (boundp 'py-sexp-function)))
(ert-deftest py-ert-shebang-startstring-test ()
(should (boundp 'py-shebang-startstring)))
(ert-deftest py-ert-shell-input-prompt-1-regexp-test ()
(should (boundp 'py-shell-input-prompt-1-regexp)))
(ert-deftest py-ert-shell-input-prompt-2-regexp-test ()
(should (boundp 'py-shell-input-prompt-2-regexp)))
(ert-deftest py-ert-shell-local-path-test ()
(should (boundp 'py-shell-local-path)))
(ert-deftest py-ert-shell-name-test ()
(should (boundp 'py-shell-name)))
(ert-deftest py-ert-shell-prompt-output-regexp-test ()
(should (boundp 'py-shell-prompt-output-regexp)))
(ert-deftest py-ert-shell-prompt-read-only-test ()
(should (boundp 'py-shell-prompt-read-only)))
(ert-deftest py-ert-shell-prompt-regexp-test ()
(should (boundp 'py-shell-prompt-regexp)))
(ert-deftest py-ert-shell-toggle-1-test ()
(should (boundp 'py-shell-toggle-1)))
(ert-deftest py-ert-shell-toggle-2-test ()
(should (boundp 'py-shell-toggle-2)))
(ert-deftest py-ert-smart-indentation-test ()
(should (boundp 'py-smart-indentation)))
(ert-deftest py-ert-smart-operator-mode-p-test ()
(should (boundp 'py-smart-operator-mode-p)))
(ert-deftest py-ert-split-window-on-execute-test ()
(should (boundp 'py-split-window-on-execute)))
(ert-deftest py-ert-split-windows-on-execute-function-test ()
(should (boundp 'py-split-windows-on-execute-function)))
(ert-deftest py-ert-store-result-p-test ()
(should (boundp 'py-store-result-p)))
(ert-deftest py-ert-switch-buffers-on-execute-p-test ()
(should (boundp 'py-switch-buffers-on-execute-p)))
(ert-deftest py-ert-tab-indent-test ()
(should (boundp 'py-tab-indent)))
(ert-deftest py-ert-tab-indents-region-p-test ()
(should (boundp 'py-tab-indents-region-p)))
(ert-deftest py-ert-tab-shifts-region-p-test ()
(should (boundp 'py-tab-shifts-region-p)))
(ert-deftest py-ert-timer-close-completions-p-test ()
(should (boundp 'py-timer-close-completions-p)))
(ert-deftest py-ert-trailing-whitespace-smart-delete-p-test ()
(should (boundp 'py-trailing-whitespace-smart-delete-p)))
(ert-deftest py-ert-uncomment-indents-p-test ()
(should (boundp 'py-uncomment-indents-p)))
(ert-deftest py-ert-update-gud-pdb-history-p-test ()
(should (boundp 'py-update-gud-pdb-history-p)))
(ert-deftest py-ert-use-current-dir-when-execute-p-test ()
(should (boundp 'py-use-current-dir-when-execute-p)))
(ert-deftest py-ert-use-font-lock-doc-face-p-test ()
(should (boundp 'py-use-font-lock-doc-face-p)))
(ert-deftest py-ert-use-local-default-test ()
(should (boundp 'py-use-local-default)))
(ert-deftest py-ert-verbose-p-test ()
(should (boundp 'py-verbose-p)))
(ert-deftest py-ert--warn-tmp-files-left-p-test ()
(should (boundp 'py--warn-tmp-files-left-p)))
(ert-deftest py-ert-already-guessed-indent-offset-test ()
(should (boundp 'py-already-guessed-indent-offset)))
(ert-deftest py-ert-assignment-re-test ()
(should (boundp 'py-assignment-re)))
(ert-deftest py-ert--auto-complete-timer-test ()
(should (boundp 'py--auto-complete-timer)))
(ert-deftest py-ert-auto-completion-buffer-test ()
(should (boundp 'py-auto-completion-buffer)))
(ert-deftest py-ert-auto-completion-mode-p-test ()
(should (boundp 'py-auto-completion-mode-p)))
(ert-deftest py-ert-autofill-timer-test ()
(should (boundp 'py-autofill-timer)))
(ert-deftest py-ert-block-or-clause-re-test ()
(should (boundp 'py-block-or-clause-re)))
(ert-deftest py-ert-buffer-name-test ()
(should (boundp 'py-buffer-name)))
(ert-deftest py-ert-builtins-face-test ()
(should (boundp 'py-builtins-face)))
(ert-deftest py-ert-class-name-face-test ()
(should (boundp 'py-class-name-face)))
(ert-deftest py-ert-complete-last-modified-test ()
(should (boundp 'py-complete-last-modified)))
(ert-deftest py-ert-completion-last-window-configuration-test ()
(should (boundp 'py-last-window-configuration)))
(ert-deftest py-ert-decorators-face-test ()
(should (boundp 'py-decorators-face)))
(ert-deftest py-ert-default-interpreter-test ()
(should (boundp 'py-default-interpreter)))
(ert-deftest py-ert-def-class-face-test ()
(should (boundp 'py-def-class-face)))
(ert-deftest py-ert-delimiter-re-test ()
(should (boundp 'py-delimiter-re)))
(ert-deftest py-ert-dotted-expression-syntax-table-test ()
(should (boundp 'py-dotted-expression-syntax-table)))
(ert-deftest py-ert-eldoc-setup-code-test ()
(should (boundp 'py-eldoc-setup-code)))
(ert-deftest py-ert-encoding-string-re-test ()
(should (boundp 'py-encoding-string-re)))
(ert-deftest py-ert-error-test ()
(should (boundp 'py-error)))
(ert-deftest py-ert-ert-test-default-executables-test ()
(should (boundp 'py-ert-test-default-executables)))
(ert-deftest py-ert-exception-buffer-test ()
(should (boundp 'py-exception-buffer)))
(ert-deftest py-ert-exception-name-face-test ()
(should (boundp 'py-exception-name-face)))
(ert-deftest py-ert-exec-command-test ()
(should (boundp 'py-exec-command)))
(ert-deftest py-ert-expression-re-test ()
(should (boundp 'py-expression-re)))
(ert-deftest py-ert-expression-skip-chars-test ()
(should (boundp 'py-expression-skip-chars)))
(ert-deftest py-ert-expression-skip-regexp-test ()
(should (boundp 'py-expression-skip-regexp)))
(ert-deftest py-ert-fast-filter-re-test ()
(should (boundp 'py-fast-filter-re)))
(ert-deftest py-ert-ffap-test ()
(should (boundp 'py-ffap)))
(ert-deftest py-ert-ffap-p-test ()
(should (boundp 'py-ffap-p)))
(ert-deftest py-ert-ffap-setup-code-test ()
(should (boundp 'py-ffap-setup-code)))
(ert-deftest py-ert-ffap-string-code-test ()
(should (boundp 'py-ffap-string-code)))
(ert-deftest py-ert-file-queue-test ()
(should (boundp 'py-file-queue)))
(ert-deftest py-ert-fill-column-orig-test ()
(should (boundp 'py-fill-column-orig)))
(ert-deftest py-ert-flake8-history-test ()
(should (boundp 'py-flake8-history)))
(ert-deftest py-ert-force-local-shell-p-test ()
(should (boundp 'py-force-local-shell-p)))
(ert-deftest py-ert-import-from-face-test ()
(should (boundp 'py-import-from-face)))
(ert-deftest py-ert-ipython0.10-completion-command-string-test ()
(should (boundp 'py-ipython0.10-completion-command-string)))
(ert-deftest py-ert-ipython0.11-completion-command-string-test ()
(should (boundp 'py-ipython0.11-completion-command-string)))
(ert-deftest py-ert-ipython-completion-command-string-test ()
(should (boundp 'py-ipython-completion-command-string)))
(ert-deftest py-ert-ipython-completions-test ()
(should (boundp 'py-ipython-completions)))
(ert-deftest py-ert-ipython-input-prompt-re-test ()
(should (boundp 'py-ipython-input-prompt-re)))
(ert-deftest py-ert-ipython-module-completion-code-test ()
(should (boundp 'py-ipython-module-completion-code)))
(ert-deftest py-ert-ipython-module-completion-string-test ()
(should (boundp 'py-ipython-module-completion-string)))
(ert-deftest py-ert-ipython-output-prompt-re-test ()
(should (boundp 'py-ipython-output-prompt-re)))
(ert-deftest py-ert-labelled-re-test ()
(should (boundp 'py-labelled-re)))
(ert-deftest py-ert-line-number-offset-test ()
(should (boundp 'py-line-number-offset)))
(ert-deftest py-ert-local-command-test ()
(should (boundp 'py-local-command)))
(ert-deftest py-ert-local-versioned-command-test ()
(should (boundp 'py-local-versioned-command)))
(ert-deftest py-ert-match-paren-no-use-syntax-pps-test ()
(should (boundp 'py-match-paren-no-use-syntax-pps)))
(ert-deftest py-ert-mode-output-map-test ()
(should (boundp 'py-mode-output-map)))
(ert-deftest py-ert-new-session-p-test ()
(should (boundp 'py-new-session-p)))
(ert-deftest py-ert-not-expression-chars-test ()
(should (boundp 'py-not-expression-chars)))
(ert-deftest py-ert-not-expression-regexp-test ()
(should (boundp 'py-not-expression-regexp)))
(ert-deftest py-ert-number-face-test ()
(should (boundp 'py-number-face)))
(ert-deftest py-ert-object-reference-face-test ()
(should (boundp 'py-object-reference-face)))
(ert-deftest py-ert-operator-re-test ()
(should (boundp 'py-operator-re)))
(ert-deftest py-ert-orig-buffer-or-file-test ()
(should (boundp 'py-orig-buffer-or-file)))
(ert-deftest py-ert-output-buffer-test ()
(should (boundp 'py-output-buffer)))
(ert-deftest py-ert-partial-expression-backward-chars-test ()
(should (boundp 'py-partial-expression-backward-chars)))
(ert-deftest py-ert-partial-expression-forward-chars-test ()
(should (boundp 'py-partial-expression-forward-chars)))
(ert-deftest py-ert-pdbtrack-input-prompt-test ()
(should (boundp 'py-pdbtrack-input-prompt)))
(ert-deftest py-ert-pep8-history-test ()
(should (boundp 'py-pep8-history)))
(ert-deftest py-ert-pseudo-keyword-face-test ()
(should (boundp 'py-pseudo-keyword-face)))
(ert-deftest py-ert-pychecker-history-test ()
(should (boundp 'py-pychecker-history)))
(ert-deftest py-ert-pydbtrack-input-prompt-test ()
(should (boundp 'py-pydbtrack-input-prompt)))
(ert-deftest py-ert-pyflakes-history-test ()
(should (boundp 'py-pyflakes-history)))
(ert-deftest py-ert-pyflakespep8-history-test ()
(should (boundp 'py-pyflakespep8-history)))
(ert-deftest py-ert-pylint-history-test ()
(should (boundp 'py-pylint-history)))
(ert-deftest py-ert-python-completions-test ()
(should (boundp 'py-python-completions)))
(ert-deftest py-ert-result-test ()
(should (boundp 'py-result)))
(ert-deftest py-ert-return-result-p-test ()
(should (boundp 'py-return-result-p)))
(ert-deftest py-ert-separator-char-test ()
(should (boundp 'py-separator-char)))
(ert-deftest py-ert-shebang-regexp-test ()
(should (boundp 'py-shebang-regexp)))
(ert-deftest py-ert-shell-complete-debug-test ()
(should (boundp 'py-shell-complete-debug)))
(ert-deftest py-ert-shell-completion-setup-code-test ()
(should (boundp 'py-shell-completion-setup-code)))
(ert-deftest py-ert-shell-hook-test ()
(should (boundp 'py-shell-hook)))
(ert-deftest py-ert-shell-module-completion-code-test ()
(should (boundp 'py-shell-module-completion-code)))
(ert-deftest py-ert-shell-template-test ()
(should (boundp 'py-shell-template)))
(ert-deftest py-ert-string-delim-re-test ()
(should (boundp 'py-string-delim-re)))
(ert-deftest py-ert-temp-directory-test ()
(should (boundp 'py-temp-directory)))
(ert-deftest py-ert-this-abbrevs-changed-test ()
(should (boundp 'py-this-abbrevs-changed)))
(ert-deftest py-ert-traceback-line-re-test ()
(should (boundp 'py-traceback-line-re)))
(ert-deftest py-ert-try-if-face-test ()
(should (boundp 'py-try-if-face)))
(ert-deftest py-ert-underscore-word-syntax-p-test ()
(should (boundp 'py-underscore-word-syntax-p)))
(ert-deftest py-ert-variable-name-face-test ()
(should (boundp 'py-variable-name-face)))
(ert-deftest py-ert-which-bufname-test ()
(should (boundp 'py-which-bufname)))
(ert-deftest py-ert-windows-config-test ()
(should (boundp 'py-windows-config)))
(ert-deftest py-ert-XXX-tag-face-test ()
(should (boundp 'py-XXX-tag-face)))
(ert-deftest py-ert-block-closing-keywords-re-test ()
(should (boundp 'py-block-closing-keywords-re)))
(ert-deftest py-ert-ipython-input-prompt-re-test ()
(should (boundp 'py-ipython-input-prompt-re)))
(ert-deftest py-ert-imenu-class-regexp-test ()
(should (boundp 'py-imenu-class-regexp)))
(ert-deftest py-ert-imenu-generic-expression-test ()
(should (boundp 'py-imenu-generic-expression)))
(ert-deftest py-ert-imenu-generic-parens-test ()
(should (boundp 'py-imenu-generic-parens)))
(ert-deftest py-ert-imenu-generic-regexp-test ()
(should (boundp 'py-imenu-generic-regexp)))
(ert-deftest py-ert-imenu-method-arg-parens-test ()
(should (boundp 'py-imenu-method-arg-parens)))
(ert-deftest py-ert-imenu-method-no-arg-parens-test ()
(should (boundp 'py-imenu-method-no-arg-parens)))
(ert-deftest py-ert-imenu-method-regexp-test ()
(should (boundp 'py-imenu-method-regexp)))
python-mode.el-6.2.3/README_DEVEL.org 0000644 0000000 0000000 00000004473 12660433546 016730 0 ustar root root 0000000 0000000 * General
python-mode.el is composed from components-python-mode directory
using `components2pythonmode' shell-script
Get its source-files doing
bzr branch lp:python-mode/components-python-mode
An effective way users may contribute is telling
us how Python-mode is used and which command is missing
still.
For people who want to dig into the code:
Major parts deal with editing and running of
Python code - start with edit-commands.
It's built around the notion of a statement.
Putting `py-end-of-statement',
`py-beginning-of-statement' under edebug should deliver
a way into the code.
No need for compiling. However when compiled files exist, don't
forget to re-compile before running it, else an existing older
compiled file is loaded - see docstring of `load'.
* Output buffers
There will be
- one set internally to process, where the real work is done:
py-buffer-name
- a generic one, results may arrive finally, visible for user:
py-output-buffer
Commands might set their output-buffers, "*Python Completions*" for example.
* Organizing source code to edit Python
Commands are grouped by action WRT Python forms
** backward FORM / forward of FORM
*** forward FORM left corner
** mark FORM
** copy FORM
** kill FORM
** delete FORM
** up Form
** down form
Basically use `backward' and `forward' instead of beginning/end of
`py-beginning-of-statement' aliased `py-backward-statement' etc.
beginning/end of forms are reserved for booleans.
A separating convention, intended to make sripting easier.
* Organizing source code to run Python
A `py-python-' form may have a `py-ipython' sibling
Likewise `py--python'
* Bugs, feature requests
Please use bug-tracker at
http://launchpad.net/python-mode
* Testing
Tests in batch-mode are run via run-travis-ci.sh
However, there is no need to use batch-mode for a single
test. Batch-mode has some quirks and bugs. Tests in
test/py-ert-interactive-tests.el are expected to succeed when called
interactively, not in batch-mode.
Start tests from emacs -Q
All needed beside python-mode.el is
test/setup-ert-tests.el
and the file, which contains the test.
Run the test M-x ert TESTNAME RET
Instruments it for the debugger with M-x edebug-defun RET after or
inside the test . Use to step.
python-mode.el-6.2.3/doc/ 0000755 0000000 0000000 00000000000 13037475064 015100 5 ustar root root 0000000 0000000 python-mode.el-6.2.3/doc/commands-python-mode.org 0000644 0000000 0000000 00000537553 13037357637 021702 0 ustar root root 0000000 0000000 python-mode.el commands
** py-smart-operator-check
Check, if smart-operator-mode is loaded resp. available.
Give some hints, if not.
** py-autopair-check
Check, if autopair-mode is available.
Give some hints, if not.
** py--unfontify-banner
Unfontify the shell banner-text.
Cancels ‘py--timer’
Expects being called by ‘py--run-unfontify-timer’
** py-choose-shell-by-shebang
Choose shell by looking at #! on the first line.
If SHEBANG is non-nil, returns the shebang as string,
otherwise the Python resp. Jython shell command name.
** py-choose-shell-by-path
Select Python executable according to version desplayed in path, current buffer-file is selected from.
Returns versioned string, nil if nothing appropriate found
** py-which-python
Returns version of Python of current environment, a number.
** py-python-current-environment
Returns path of current Python installation.
** py-choose-shell
Return an appropriate executable as a string.
Returns nil, if no executable found.
This does the following:
- look for an interpreter with ‘py-choose-shell-by-shebang’
- examine imports using ‘py--choose-shell-by-import’
- look if Path/To/File indicates a Python version
- if not successful, return default value of ‘py-shell-name’
When interactivly called, messages the shell name, Emacs would in the given circumstances.
With C-u 4 is called ‘py-switch-shell’ see docu there.
** py-install-directory-check
Do some sanity check for ‘py-install-directory’.
Returns ‘t’ if successful.
** py-guess-py-install-directory
Takes value of user directory aka $HOME
if ‘(locate-library "python-mode")’ is not succesful.
Used only, if ‘py-install-directory’ is empty.
** py-load-pymacs
Load Pymacs as delivered.
Pymacs has been written by François Pinard and many others.
See original source: http://pymacs.progiciels-bpi.ca
** py-set-load-path
Include needed subdirs of python-mode directory.
** py-count-lines
Count lines in accessible part until current line.
See http://debbugs.gnu.org/cgi/bugreport.cgi?bug=7115
** py-toggle-highlight-indentation
If ‘highlight-indentation-p’ should be on or off.
** py-highlight-indentation-off
If ‘highlight-indentation-p’ should be on or off.
** py-highlight-indentation-on
If ‘highlight-indentation-p’ should be on or off.
** py-toggle-smart-indentation
If ‘py-smart-indentation’ should be on or off.
Returns value of ‘py-smart-indentation’ switched to.
** py-smart-indentation-on
Make sure, ‘py-smart-indentation’ is on.
Returns value of ‘py-smart-indentation’.
** py-smart-indentation-off
Make sure, ‘py-smart-indentation’ is off.
Returns value of ‘py-smart-indentation’.
** py-toggle-sexp-function
Opens customization
** py-toggle-autopair-mode
If ‘py-autopair-mode’ should be on or off.
Returns value of ‘py-autopair-mode’ switched to.
** py-autopair-mode-on
Make sure, py-autopair-mode’ is on.
Returns value of ‘py-autopair-mode’.
** py-autopair-mode-off
Make sure, py-autopair-mode’ is off.
Returns value of ‘py-autopair-mode’.
** toggle-py-smart-operator-mode-p
If ‘py-smart-operator-mode-p’ should be on or off.
Returns value of ‘py-smart-operator-mode-p’ switched to.
** py-smart-operator-mode-p-on
Make sure, py-smart-operator-mode-p’ is on.
Returns value of ‘py-smart-operator-mode-p’.
** py-smart-operator-mode-p-off
Make sure, py-smart-operator-mode-p’ is off.
Returns value of ‘py-smart-operator-mode-p’.
** toggle-py-switch-buffers-on-execute-p
If ‘py-switch-buffers-on-execute-p’ should be on or off.
Returns value of ‘py-switch-buffers-on-execute-p’ switched to.
** py-switch-buffers-on-execute-p-on
Make sure, ‘py-py-switch-buffers-on-execute-p’ is on.
Returns value of ‘py-switch-buffers-on-execute-p’.
** py-switch-buffers-on-execute-p-off
Make sure, ‘py-switch-buffers-on-execute-p’ is off.
Returns value of ‘py-switch-buffers-on-execute-p’.
** toggle-py-split-window-on-execute
If ‘py-split-window-on-execute’ should be on or off.
Returns value of ‘py-split-window-on-execute’ switched to.
** py-split-window-on-execute-on
Make sure, ‘py-py-split-window-on-execute’ is on.
Returns value of ‘py-split-window-on-execute’.
** py-split-window-on-execute-off
Make sure, ‘py-split-window-on-execute’ is off.
Returns value of ‘py-split-window-on-execute’.
** toggle-py-fontify-shell-buffer-p
If ‘py-fontify-shell-buffer-p’ should be on or off.
Returns value of ‘py-fontify-shell-buffer-p’ switched to.
** py-fontify-shell-buffer-p-on
Make sure, ‘py-py-fontify-shell-buffer-p’ is on.
Returns value of ‘py-fontify-shell-buffer-p’.
** py-fontify-shell-buffer-p-off
Make sure, ‘py-fontify-shell-buffer-p’ is off.
Returns value of ‘py-fontify-shell-buffer-p’.
** toggle-python-mode-v5-behavior-p
If ‘python-mode-v5-behavior-p’ should be on or off.
Returns value of ‘python-mode-v5-behavior-p’ switched to.
** python-mode-v5-behavior-p-on
Make sure, ‘python-mode-v5-behavior-p’ is on.
Returns value of ‘python-mode-v5-behavior-p’.
** python-mode-v5-behavior-p-off
Make sure, ‘python-mode-v5-behavior-p’ is off.
Returns value of ‘python-mode-v5-behavior-p’.
** toggle-py-jump-on-exception
If ‘py-jump-on-exception’ should be on or off.
Returns value of ‘py-jump-on-exception’ switched to.
** py-jump-on-exception-on
Make sure, py-jump-on-exception’ is on.
Returns value of ‘py-jump-on-exception’.
** py-jump-on-exception-off
Make sure, ‘py-jump-on-exception’ is off.
Returns value of ‘py-jump-on-exception’.
** toggle-py-use-current-dir-when-execute-p
If ‘py-use-current-dir-when-execute-p’ should be on or off.
Returns value of ‘py-use-current-dir-when-execute-p’ switched to.
** py-use-current-dir-when-execute-p-on
Make sure, py-use-current-dir-when-execute-p’ is on.
Returns value of ‘py-use-current-dir-when-execute-p’.
** py-use-current-dir-when-execute-p-off
Make sure, ‘py-use-current-dir-when-execute-p’ is off.
Returns value of ‘py-use-current-dir-when-execute-p’.
** toggle-py-electric-comment-p
If ‘py-electric-comment-p’ should be on or off.
Returns value of ‘py-electric-comment-p’ switched to.
** py-electric-comment-p-on
Make sure, py-electric-comment-p’ is on.
Returns value of ‘py-electric-comment-p’.
** py-electric-comment-p-off
Make sure, ‘py-electric-comment-p’ is off.
Returns value of ‘py-electric-comment-p’.
** toggle-py-underscore-word-syntax-p
If ‘py-underscore-word-syntax-p’ should be on or off.
Returns value of ‘py-underscore-word-syntax-p’ switched to.
** py-underscore-word-syntax-p-on
Make sure, py-underscore-word-syntax-p’ is on.
Returns value of ‘py-underscore-word-syntax-p’.
** py-underscore-word-syntax-p-off
Make sure, ‘py-underscore-word-syntax-p’ is off.
Returns value of ‘py-underscore-word-syntax-p’.
** py-insert-default-shebang
Insert in buffer shebang of installed default Python.
** py-indent-line-outmost
Indent the current line to the outmost reasonable indent.
With optional C-u an indent with length ‘py-indent-offset’ is inserted unconditionally
** py-indent-line
Indent the current line according to Python rules.
When called interactivly with C-u, ignore dedenting rules for block closing statements
(e.g. return, raise, break, continue, pass)
An optional C-u followed by a numeric argument neither 1 nor 4 will switch off ‘py-smart-indentation’ for this execution. This permits to correct allowed but unwanted indents.
Similar to ‘toggle-py-smart-indentation’ resp. ‘py-smart-indentation-off’ followed by TAB.
This function is normally used by ‘indent-line-function’ resp.
TAB.
When bound to TAB, C-q TAB inserts a TAB.
OUTMOST-ONLY stops circling possible indent.
When ‘py-tab-shifts-region-p’ is ‘t’, not just the current line,
but the region is shiftet that way.
If ‘py-tab-indents-region-p’ is ‘t’ and first TAB doesn’t shift
--as indent is at outmost reasonable--, indent-region is called.
C-q TAB inserts a literal TAB-character.
** py-newline-and-indent
Add a newline and indent to outmost reasonable indent.
When indent is set back manually, this is honoured in following lines.
** py-newline-and-dedent
Add a newline and indent to one level below current.
Returns column.
** py-toggle-indent-tabs-mode
Toggle ‘indent-tabs-mode’.
Returns value of ‘indent-tabs-mode’ switched to.
** py-indent-tabs-mode
With positive ARG switch ‘indent-tabs-mode’ on.
With negative ARG switch ‘indent-tabs-mode’ off.
Returns value of ‘indent-tabs-mode’ switched to.
** py-indent-tabs-mode-on
Switch ‘indent-tabs-mode’ on.
** py-indent-tabs-mode-off
Switch ‘indent-tabs-mode’ off.
** py-guess-indent-offset
Guess ‘py-indent-offset’.
Set local value of ‘py-indent-offset’, return it
Might change local value of ‘py-indent-offset’ only when called
downwards from beginning of block followed by a statement. Otherwise default-value is returned.
** py-indent-and-forward
Indent current line according to mode, move one line forward.
If optional INDENT is given, use it
** py-indent-region
Reindent a region of Python code.
In case first line accepts an indent, keep the remaining
lines relative.
Otherwise lines in region get outmost indent,
same with optional argument
In order to shift a chunk of code, where the first line is okay, start with second line.
** py-backward-declarations
Got to the beginning of assigments resp. statements in current level which don’t open blocks.
** py-forward-declarations
Got to the end of assigments resp. statements in current level which don’t open blocks.
** py-declarations
Copy and mark assigments resp. statements in current level which don’t open blocks or start with a keyword.
See also ‘py-statements’, which is more general, taking also simple statements starting with a keyword.
** py-kill-declarations
Delete variables declared in current level.
Store deleted variables in kill-ring
** py--bounds-of-statements
Bounds of consecutive multitude of statements around point.
Indented same level, which don’t open blocks.
** py-backward-statements
Got to the beginning of statements in current level which don’t open blocks.
** py-forward-statements
Got to the end of statements in current level which don’t open blocks.
** py-statements
Copy and mark simple statements in current level which don’t open blocks.
More general than py-declarations, which would stop at keywords like a print-statement.
** py-kill-statements
Delete statements declared in current level.
Store deleted statements in kill-ring
** py-insert-super
Insert a function "super()" from current environment.
As example given in Python v3.1 documentation » The Python Standard Library »
class C(B):
def method(self, arg):
super().method(arg) # This does the same thing as:
# super(C, self).method(arg)
Returns the string inserted.
** py-delete-comments-in-def-or-class
Delete all commented lines in def-or-class at point
** py-delete-comments-in-class
Delete all commented lines in class at point
** py-delete-comments-in-block
Delete all commented lines in block at point
** py-delete-comments-in-region
Delete all commented lines in region.
** py-edit-docstring
Edit docstring or active region in python-mode.
** py-backward-region
Go to the beginning of current region
** py-backward-block
Go to beginning of ‘block’.
If already at beginning, go one ‘block’ backward.
Returns beginning of ‘block’ if successful, nil otherwise
** py-backward-block-or-clause
Go to beginning of ‘block-or-clause’.
If already at beginning, go one ‘block-or-clause’ backward.
Returns beginning of ‘block-or-clause’ if successful, nil otherwise
** py-backward-class
Go to beginning of ‘class’.
If already at beginning, go one ‘class’ backward.
Returns beginning of ‘class’ if successful, nil otherwise
** py-backward-clause
Go to beginning of ‘clause’.
If already at beginning, go one ‘clause’ backward.
Returns beginning of ‘clause’ if successful, nil otherwise
** py-backward-def
Go to beginning of ‘def’.
If already at beginning, go one ‘def’ backward.
Returns beginning of ‘def’ if successful, nil otherwise
** py-backward-def-or-class
Go to beginning of ‘def-or-class’.
If already at beginning, go one ‘def-or-class’ backward.
Returns beginning of ‘def-or-class’ if successful, nil otherwise
** py-backward-elif-block
Go to beginning of ‘elif-block’.
If already at beginning, go one ‘elif-block’ backward.
Returns beginning of ‘elif-block’ if successful, nil otherwise
** py-backward-else-block
Go to beginning of ‘else-block’.
If already at beginning, go one ‘else-block’ backward.
Returns beginning of ‘else-block’ if successful, nil otherwise
** py-backward-except-block
Go to beginning of ‘except-block’.
If already at beginning, go one ‘except-block’ backward.
Returns beginning of ‘except-block’ if successful, nil otherwise
** py-backward-for-block
Go to beginning of ‘for-block’.
If already at beginning, go one ‘for-block’ backward.
Returns beginning of ‘for-block’ if successful, nil otherwise
** py-backward-if-block
Go to beginning of ‘if-block’.
If already at beginning, go one ‘if-block’ backward.
Returns beginning of ‘if-block’ if successful, nil otherwise
** py-backward-minor-block
Go to beginning of ‘minor-block’.
If already at beginning, go one ‘minor-block’ backward.
Returns beginning of ‘minor-block’ if successful, nil otherwise
** py-backward-try-block
Go to beginning of ‘try-block’.
If already at beginning, go one ‘try-block’ backward.
Returns beginning of ‘try-block’ if successful, nil otherwise
** py-backward-block-bol
Go to beginning of ‘block’, go to BOL.
If already at beginning, go one ‘block’ backward.
Returns beginning of ‘block’ if successful, nil otherwise
** py-backward-block-or-clause-bol
Go to beginning of ‘block-or-clause’, go to BOL.
If already at beginning, go one ‘block-or-clause’ backward.
Returns beginning of ‘block-or-clause’ if successful, nil otherwise
** py-backward-class-bol
Go to beginning of ‘class’, go to BOL.
If already at beginning, go one ‘class’ backward.
Returns beginning of ‘class’ if successful, nil otherwise
** py-backward-clause-bol
Go to beginning of ‘clause’, go to BOL.
If already at beginning, go one ‘clause’ backward.
Returns beginning of ‘clause’ if successful, nil otherwise
** py-backward-def-bol
Go to beginning of ‘def’, go to BOL.
If already at beginning, go one ‘def’ backward.
Returns beginning of ‘def’ if successful, nil otherwise
** py-backward-def-or-class-bol
Go to beginning of ‘def-or-class’, go to BOL.
If already at beginning, go one ‘def-or-class’ backward.
Returns beginning of ‘def-or-class’ if successful, nil otherwise
** py-backward-elif-block-bol
Go to beginning of ‘elif-block’, go to BOL.
If already at beginning, go one ‘elif-block’ backward.
Returns beginning of ‘elif-block’ if successful, nil otherwise
** py-backward-else-block-bol
Go to beginning of ‘else-block’, go to BOL.
If already at beginning, go one ‘else-block’ backward.
Returns beginning of ‘else-block’ if successful, nil otherwise
** py-backward-except-block-bol
Go to beginning of ‘except-block’, go to BOL.
If already at beginning, go one ‘except-block’ backward.
Returns beginning of ‘except-block’ if successful, nil otherwise
** py-backward-for-block-bol
Go to beginning of ‘for-block’, go to BOL.
If already at beginning, go one ‘for-block’ backward.
Returns beginning of ‘for-block’ if successful, nil otherwise
** py-backward-if-block-bol
Go to beginning of ‘if-block’, go to BOL.
If already at beginning, go one ‘if-block’ backward.
Returns beginning of ‘if-block’ if successful, nil otherwise
** py-backward-minor-block-bol
Go to beginning of ‘minor-block’, go to BOL.
If already at beginning, go one ‘minor-block’ backward.
Returns beginning of ‘minor-block’ if successful, nil otherwise
** py-backward-try-block-bol
Go to beginning of ‘try-block’, go to BOL.
If already at beginning, go one ‘try-block’ backward.
Returns beginning of ‘try-block’ if successful, nil otherwise
** py-forward-region
Go to the end of current region
** py-forward-block
Go to end of block.
Returns end of block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-block-bol
Goto beginning of line following end of block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-block’: down from current definition to next beginning of block below.
** py-forward-block-or-clause
Go to end of block-or-clause.
Returns end of block-or-clause if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-block-or-clause-bol
Goto beginning of line following end of block-or-clause.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-block-or-clause’: down from current definition to next beginning of block-or-clause below.
** py-forward-class
Go to end of class.
Returns end of class if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-class-bol
Goto beginning of line following end of class.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-class’: down from current definition to next beginning of class below.
** py-forward-clause
Go to end of clause.
Returns end of clause if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-clause-bol
Goto beginning of line following end of clause.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-clause’: down from current definition to next beginning of clause below.
** py-forward-def-or-class
Go to end of def-or-class.
Returns end of def-or-class if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-def-or-class-bol
Goto beginning of line following end of def-or-class.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-def-or-class’: down from current definition to next beginning of def-or-class below.
** py-forward-def
Go to end of def.
Returns end of def if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-def-bol
Goto beginning of line following end of def.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-def’: down from current definition to next beginning of def below.
** py-forward-if-block
Go to end of if-block.
Returns end of if-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-if-block-bol
Goto beginning of line following end of if-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-if-block’: down from current definition to next beginning of if-block below.
** py-forward-elif-block
Go to end of elif-block.
Returns end of elif-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-elif-block-bol
Goto beginning of line following end of elif-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-elif-block’: down from current definition to next beginning of elif-block below.
** py-forward-else-block
Go to end of else-block.
Returns end of else-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-else-block-bol
Goto beginning of line following end of else-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-else-block’: down from current definition to next beginning of else-block below.
** py-forward-for-block
Go to end of for-block.
Returns end of for-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-for-block-bol
Goto beginning of line following end of for-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-for-block’: down from current definition to next beginning of for-block below.
** py-forward-except-block
Go to end of except-block.
Returns end of except-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-except-block-bol
Goto beginning of line following end of except-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-except-block’: down from current definition to next beginning of except-block below.
** py-forward-try-block
Go to end of try-block.
Returns end of try-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-try-block-bol
Goto beginning of line following end of try-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-try-block’: down from current definition to next beginning of try-block below.
** py-forward-minor-block
Go to end of minor-block.
Returns end of minor-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
** py-forward-minor-block-bol
Goto beginning of line following end of minor-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-minor-block’: down from current definition to next beginning of minor-block below.
** py-backward-indent
Go to the beginning of a section of equal indent.
If already at the beginning or before a indent, go to next indent in buffer upwards
Returns final position when called from inside section, nil otherwise
** py-backward-indent-bol
Go to the beginning of line of a section of equal indent.
If already at the beginning or before an indent, go to next indent in buffer upwards
Returns final position when called from inside section, nil otherwise
** py-forward-indent
Go to the end of a section of equal indentation.
If already at the end, go down to next indent in buffer
Returns final position when called from inside section, nil otherwise
** py-forward-indent-bol
Go to beginning of line following of a section of equal indentation.
If already at the end, go down to next indent in buffer
Returns final position when called from inside section, nil otherwise
** py-backward-expression
Go to the beginning of a python expression.
If already at the beginning or before a expression, go to next expression in buffer upwards
** py-forward-expression
Go to the end of a compound python expression.
Operators are ignored.
** py-backward-line
Go to beginning-of-line, return position.
If already at beginning-of-line and not at BOB, go to beginning of previous line.
** py-forward-line
Go to end-of-line, return position.
If already at end-of-line and not at EOB, go to end of next line.
** py-backward-statement
Go to the initial line of a simple statement.
For beginning of compound statement use py-backward-block.
For beginning of clause py-backward-clause.
‘ignore-in-string-p’ allows moves inside a docstring, used when
computing indents
** py-backward-statement-bol
Goto beginning of line where statement starts.
Returns position reached, if successful, nil otherwise.
See also ‘py-up-statement’: up from current definition to next beginning of statement above.
** py-forward-statement
Go to the last char of current statement.
Optional argument REPEAT, the number of loops done already, is checked for py-max-specpdl-size error. Avoid eternal loops due to missing string delimters etc.
** py-forward-statement-bol
Go to the beginning-of-line following current statement.
** py-backward-decorator
Go to the beginning of a decorator.
Returns position if succesful
** py-forward-decorator
Go to the end of a decorator.
Returns position if succesful
** py-backward-comment
Got to beginning of a commented section.
** py-forward-comment
Go to end of commented section.
Optional args position and comment-start character
Travel empty lines
** py-go-to-beginning-of-comment
Go to the beginning of current line’s comment, if any.
From a programm use macro ‘py-backward-comment’ instead
** py-leave-comment-or-string-backward
If inside a comment or string, leave it backward.
** py-beginning-of-list-pps
Go to the beginning of a list.
Optional ARG indicates a start-position for ‘parse-partial-sexp’.
Return beginning position, nil if not inside.
** py-forward-into-nomenclature
Move forward to end of a nomenclature symbol.
With C-u (programmatically, optional argument ARG), do it that many times.
A ‘nomenclature’ is a fancy way of saying AWordWithMixedCaseNotUnderscores.
** py-backward-into-nomenclature
Move backward to beginning of a nomenclature symbol.
With optional ARG, move that many times. If ARG is negative, move
forward.
A ‘nomenclature’ is a fancy way of saying AWordWithMixedCaseNotUnderscores.
** py-beginning-of-block-current-column
Reach next beginning of block upwards which starts at current column.
Return position
** py-backward-section
Go to next section start upward in buffer.
Return position if successful
** py-forward-section
Go to next section end downward in buffer.
Return position if successful
** py-kill-comment
Delete comment at point.
Stores data in kill ring
** py-kill-line
Delete line at point.
Stores data in kill ring
** py-kill-paragraph
Delete paragraph at point.
Stores data in kill ring
** py-kill-expression
Delete expression at point.
Stores data in kill ring
** py-kill-partial-expression
Delete partial-expression at point.
Stores data in kill ring
** py-kill-section
Delete section at point.
Stores data in kill ring
** py-kill-top-level
Delete top-level at point.
Stores data in kill ring
** py-kill-block
Delete block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-block-or-clause
Delete block-or-clause at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-class
Delete class at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-clause
Delete clause at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-def
Delete def at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-def-or-class
Delete def-or-class at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-elif-block
Delete elif-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-else-block
Delete else-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-except-block
Delete except-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-for-block
Delete for-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-if-block
Delete if-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-indent
Delete indent at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-minor-block
Delete minor-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-statement
Delete statement at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-kill-try-block
Delete try-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-close-block
Close block at point.
Set indent level to that of beginning of function definition.
If final line isn’t empty and ‘py-close-block-provides-newline’ non-nil, insert a newline.
** py-close-class
Close class at point.
Set indent level to that of beginning of function definition.
If final line isn’t empty and ‘py-close-block-provides-newline’ non-nil, insert a newline.
** py-close-def
Close def at point.
Set indent level to that of beginning of function definition.
If final line isn’t empty and ‘py-close-block-provides-newline’ non-nil, insert a newline.
** py-close-def-or-class
Close def-or-class at point.
Set indent level to that of beginning of function definition.
If final line isn’t empty and ‘py-close-block-provides-newline’ non-nil, insert a newline.
** py-close-minor-block
Close minor-block at point.
Set indent level to that of beginning of function definition.
If final line isn’t empty and ‘py-close-block-provides-newline’ non-nil, insert a newline.
** py-close-statement
Close statement at point.
Set indent level to that of beginning of function definition.
If final line isn’t empty and ‘py-close-block-provides-newline’ non-nil, insert a newline.
** py-mark-comment
Mark comment at point.
Returns beginning and end positions of marked area, a cons.
** py-mark-line
Mark line at point.
Returns beginning and end positions of marked area, a cons.
** py-mark-paragraph
Mark paragraph at point.
Returns beginning and end positions of marked area, a cons.
** py-mark-expression
Mark expression at point.
Returns beginning and end positions of marked area, a cons.
** py-mark-partial-expression
Mark partial-expression at point.
Returns beginning and end positions of marked area, a cons.
** py-mark-section
Mark section at point.
Returns beginning and end positions of marked area, a cons.
** py-mark-top-level
Mark top-level at point.
Returns beginning and end positions of marked area, a cons.
** py-mark-block
Mark block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
** py-mark-block-or-clause
Mark block-or-clause, take beginning of line positions.
Returns beginning and end positions of region, a cons.
** py-mark-class
Mark class, take beginning of line positions.
With C-u or ‘py-mark-decorators’ set to ‘t’, decorators are marked too.
Returns beginning and end positions of region, a cons.
** py-mark-clause
Mark clause, take beginning of line positions.
Returns beginning and end positions of region, a cons.
** py-mark-def
Mark def, take beginning of line positions.
With C-u or ‘py-mark-decorators’ set to ‘t’, decorators are marked too.
Returns beginning and end positions of region, a cons.
** py-mark-def-or-class
Mark def-or-class, take beginning of line positions.
With C-u or ‘py-mark-decorators’ set to ‘t’, decorators are marked too.
Returns beginning and end positions of region, a cons.
** py-mark-elif-block
Mark elif-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
** py-mark-else-block
Mark else-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
** py-mark-except-block
Mark except-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
** py-mark-for-block
Mark for-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
** py-mark-if-block
Mark if-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
** py-mark-indent
Mark indent, take beginning of line positions.
Returns beginning and end positions of region, a cons.
** py-mark-minor-block
Mark minor-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
** py-mark-statement
Mark statement, take beginning of line positions.
Returns beginning and end positions of region, a cons.
** py-mark-try-block
Mark try-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
** py-copy-block
Copy block at point.
Store data in kill ring, so it might yanked back.
** py-copy-block-or-clause
Copy block-or-clause at point.
Store data in kill ring, so it might yanked back.
** py-copy-buffer
Copy buffer at point.
Store data in kill ring, so it might yanked back.
** py-copy-class
Copy class at point.
Store data in kill ring, so it might yanked back.
** py-copy-clause
Copy clause at point.
Store data in kill ring, so it might yanked back.
** py-copy-def
Copy def at point.
Store data in kill ring, so it might yanked back.
** py-copy-def-or-class
Copy def-or-class at point.
Store data in kill ring, so it might yanked back.
** py-copy-expression
Copy expression at point.
Store data in kill ring, so it might yanked back.
** py-copy-indent
Copy indent at point.
Store data in kill ring, so it might yanked back.
** py-copy-line
Copy line at point.
Store data in kill ring, so it might yanked back.
** py-copy-minor-block
Copy minor-block at point.
Store data in kill ring, so it might yanked back.
** py-copy-paragraph
Copy paragraph at point.
Store data in kill ring, so it might yanked back.
** py-copy-partial-expression
Copy partial-expression at point.
Store data in kill ring, so it might yanked back.
** py-copy-region
Copy region at point.
Store data in kill ring, so it might yanked back.
** py-copy-statement
Copy statement at point.
Store data in kill ring, so it might yanked back.
** py-copy-top-level
Copy top-level at point.
Store data in kill ring, so it might yanked back.
** py-copy-block-bol
Delete block bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-block-or-clause-bol
Delete block-or-clause bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-buffer-bol
Delete buffer bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-class-bol
Delete class bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-clause-bol
Delete clause bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-def-bol
Delete def bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-def-or-class-bol
Delete def-or-class bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-expression-bol
Delete expression bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-indent-bol
Delete indent bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-line-bol
Delete line bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-minor-block-bol
Delete minor-block bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-paragraph-bol
Delete paragraph bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-partial-expression-bol
Delete partial-expression bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-region-bol
Delete region bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-statement-bol
Delete statement bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-copy-top-level-bol
Delete top-level bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
** py-delete-block
Delete BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
** py-delete-block-or-clause
Delete BLOCK-OR-CLAUSE at point until beginning-of-line.
Don’t store data in kill ring.
** py-delete-class
Delete CLASS at point until beginning-of-line.
Don’t store data in kill ring.
With C-u or ‘py-mark-decorators’ set to ‘t’, ‘decorators’ are included.
** py-delete-clause
Delete CLAUSE at point until beginning-of-line.
Don’t store data in kill ring.
** py-delete-def
Delete DEF at point until beginning-of-line.
Don’t store data in kill ring.
With C-u or ‘py-mark-decorators’ set to ‘t’, ‘decorators’ are included.
** py-delete-def-or-class
Delete DEF-OR-CLASS at point until beginning-of-line.
Don’t store data in kill ring.
With C-u or ‘py-mark-decorators’ set to ‘t’, ‘decorators’ are included.
** py-delete-elif-block
Delete ELIF-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
** py-delete-else-block
Delete ELSE-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
** py-delete-except-block
Delete EXCEPT-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
** py-delete-for-block
Delete FOR-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
** py-delete-if-block
Delete IF-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
** py-delete-indent
Delete INDENT at point until beginning-of-line.
Don’t store data in kill ring.
** py-delete-minor-block
Delete MINOR-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
** py-delete-statement
Delete STATEMENT at point until beginning-of-line.
Don’t store data in kill ring.
** py-delete-try-block
Delete TRY-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
** py-delete-comment
Delete COMMENT at point.
Don’t store data in kill ring.
** py-delete-line
Delete LINE at point.
Don’t store data in kill ring.
** py-delete-paragraph
Delete PARAGRAPH at point.
Don’t store data in kill ring.
** py-delete-expression
Delete EXPRESSION at point.
Don’t store data in kill ring.
** py-delete-partial-expression
Delete PARTIAL-EXPRESSION at point.
Don’t store data in kill ring.
** py-delete-section
Delete SECTION at point.
Don’t store data in kill ring.
** py-delete-top-level
Delete TOP-LEVEL at point.
Don’t store data in kill ring.
** py-switch-to-python
Switch to the Python process buffer, maybe starting new process.
With prefix arg, position cursor at end of buffer.
** py-send-file
Send FILE-NAME to Python PROCESS.
If TEMP-FILE-NAME is passed then that file is used for processing
instead, while internally the shell will continue to use
FILE-NAME.
** toggle-force-local-shell
If locally indicated Python shell should be taken and
enforced upon sessions execute commands.
Toggles boolean ‘py-force-local-shell-p’ along with ‘py-force-py-shell-name-p’
Returns value of ‘toggle-force-local-shell’ switched to.
When on, kind of an option ’follow’, local shell sets ‘py-shell-name’, enforces its use afterwards.
See also commands
‘py-force-local-shell-on’
‘py-force-local-shell-off’
** py-force-local-shell-on
Make sure, ‘py-force-local-shell-p’ is on.
Returns value of ‘py-force-local-shell-p’.
Kind of an option ’follow’, local shell sets ‘py-shell-name’, enforces its use afterwards
** py-force-local-shell-off
Restore ‘py-shell-name’ default value and ‘behaviour’.
** toggle-force-py-shell-name-p
If customized default ‘py-shell-name’ should be enforced upon execution.
If ‘py-force-py-shell-name-p’ should be on or off.
Returns value of ‘py-force-py-shell-name-p’ switched to.
See also commands
force-py-shell-name-p-on
force-py-shell-name-p-off
Caveat: Completion might not work that way.
** force-py-shell-name-p-on
Switches ‘py-force-py-shell-name-p’ on.
Customized default ‘py-shell-name’ will be enforced upon execution.
Returns value of ‘py-force-py-shell-name-p’.
Caveat: Completion might not work that way.
** force-py-shell-name-p-off
Make sure, ‘py-force-py-shell-name-p’ is off.
Function to use by executes will be guessed from environment.
Returns value of ‘py-force-py-shell-name-p’.
** py-toggle-split-windows-on-execute
If ‘py-split-window-on-execute’ should be on or off.
Returns value of ‘py-split-window-on-execute’ switched to.
** py-split-windows-on-execute-on
Make sure, ‘py-split-window-on-execute’ is on.
Returns value of ‘py-split-window-on-execute’.
** py-split-windows-on-execute-off
Make sure, ‘py-split-window-on-execute’ is off.
Returns value of ‘py-split-window-on-execute’.
** py-toggle-shell-switch-buffers-on-execute
If ‘py-switch-buffers-on-execute-p’ should be on or off.
Returns value of ‘py-switch-buffers-on-execute-p’ switched to.
** py-shell-switch-buffers-on-execute-on
Make sure, ‘py-switch-buffers-on-execute-p’ is on.
Returns value of ‘py-switch-buffers-on-execute-p’.
** py-shell-switch-buffers-on-execute-off
Make sure, ‘py-switch-buffers-on-execute-p’ is off.
Returns value of ‘py-switch-buffers-on-execute-p’.
** py-guess-default-python
Defaults to "python", if guessing didn’t succeed.
** py-shell-dedicated
Start an interactive Python interpreter in another window.
With optional C-u user is prompted by
‘py-choose-shell’ for command and options to pass to the Python
interpreter.
** py-set-ipython-completion-command-string
Set and return ‘py-ipython-completion-command-string’.
** py-ipython--module-completion-import
Import module-completion
** py-toggle-split-window-function
If window is splitted vertically or horizontally.
When code is executed and ‘py-split-window-on-execute’ is ‘t’, the result is displays in an output-buffer, "*Python*" by default.
Customizable variable ‘py-split-windows-on-execute-function’ tells how to split the screen.
** py--manage-windows-split
If one window, split according to ‘py-split-windows-on-execute-function.
** py-kill-shell-unconditional
With optional argument SHELL.
Otherwise kill default (I)Python shell.
Kill buffer and its process.
Receives a buffer-name as argument
** py-kill-default-shell-unconditional
Kill buffer "*Python*" and its process.
** py-shell
Start an interactive Python interpreter in another window.
Interactively, C-u prompts for a new buffer-name.
C-u 2 prompts for ‘py-python-command-args’.
If ‘default-directory’ is a remote file name, it is also prompted
to change if called with a prefix arg.
Optional string SHELL overrides default ‘py-shell-name’.
Returns py-shell’s buffer-name.
BUFFER allows specifying a name, the Python process is connected to
FAST process not in comint-mode buffer
EXCEPTION-BUFFER point to error
SPLIT see var ‘py-split-window-on-execute’
SWITCH see var ‘py-switch-buffers-on-execute-p’
** py-shell-get-process
Get appropriate Python process for current buffer and return it.
** py-switch-to-shell
Switch to Python process buffer.
** py-execute-file
When called interactively, user is prompted for filename.
** py-execute-string
Send the argument STRING to Python default interpreter.
See also ‘py-execute-region’.
** py-execute-string-dedicated
Send the argument STRING to an unique Python interpreter.
See also ‘py-execute-region’.
** py-fetch-py-master-file
Lookup if a ‘py-master-file’ is specified.
See also doku of variable ‘py-master-file’
** py-execute-import-or-reload
Import the current buffer’s file in a Python interpreter.
If the file has already been imported, then do reload instead to get
the latest version.
If the file’s name does not end in ".py", then do execfile instead.
If the current buffer is not visiting a file, do ‘py-execute-buffer’
instead.
If the file local variable ‘py-master-file’ is non-nil, import or
reload the named file instead of the buffer’s file. The file may be
saved based on the value of ‘py-execute-import-or-reload-save-p’.
See also ‘M-x py-execute-region’.
This may be preferable to ‘M-x py-execute-buffer’ because:
- Definitions stay in their module rather than appearing at top
level, where they would clutter the global namespace and not affect
uses of qualified names (MODULE.NAME).
- The Python debugger gets line number information about the functions.
** py-execute-defun
Send the current defun (class or method) to the Python process.
** py-process-file
Process "python filename".
Optional OUTPUT-BUFFER and ERROR-BUFFER might be given.
** py-remove-overlays-at-point
Remove overlays as set when ‘py-highlight-error-source-p’ is non-nil.
** py-mouseto-exception
Jump to the code which caused the Python exception at EVENT.
EVENT is usually a mouse click.
** py-goto-exception
Go to the line indicated by the traceback.
** py-down-exception
Go to the next line down in the traceback.
With M-x univeral-argument (programmatically, optional argument
BOTTOM), jump to the bottom (innermost) exception in the exception
stack.
** py-up-exception
Go to the previous line up in the traceback.
With C-u (programmatically, optional argument TOP)
jump to the top (outermost) exception in the exception stack.
** py-output-buffer-filter
Clear output buffer from py-shell-input prompt etc.
** py-output-filter
Clear output buffer from py-shell-input prompt etc.
** py-send-string
Evaluate STRING in Python process.
** py-shell-complete
Complete word before point, if any.
** py-indent-or-complete
Complete or indent depending on the context.
If cursor is at end of a symbol, try to complete
Otherwise call ‘py-indent-line’
If ‘(use-region-p)’ returns ‘t’, indent region.
Use ‘C-q TAB’ to insert a literally TAB-character
In python-mode ‘py-complete-function’ is called,
in (I)Python shell-modes ‘py-shell-complete’
** py-pdbtrack-toggle-stack-tracking
Set variable ‘py-pdbtrack-do-tracking-p’.
** py-execute-statement-pdb
Execute statement running pdb.
** py-pdb-help
Print generic pdb.help() message
** py--pdb-versioned
Guess existing pdb version from py-shell-name
Return "pdb[VERSION]" if executable found, just "pdb" otherwise
** py-pdb
Run pdb on program FILE in buffer ‘*gud-FILE*’.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
At GNU Linux systems required pdb version should be detected by ‘py--pdb-version’, at Windows configure ‘py-python-ms-pdb-command’
lp:963253
** py-update-gud-pdb-history
If pdb is called at a Python buffer, put it’s file name at the head of ‘gud-pdb-history’.
** py-fetch-docu
Lookup in current buffer for the doku for the symbol at point.
Useful for newly defined symbol, not known to python yet.
** py-info-current-defun
Return name of surrounding function with Python compatible dotted expression syntax.
Optional argument INCLUDE-TYPE indicates to include the type of the defun.
This function is compatible to be used as
‘add-log-current-defun-function’ since it returns nil if point is
not inside a defun.
** py-help-at-point
Print help on symbol at point.
If symbol is defined in current buffer, jump to it’s definition
** py-describe-mode
Dump long form of ‘python-mode’ docs.
** py-find-definition
Find source of definition of SYMBOL.
Interactively, prompt for SYMBOL.
** py-find-imports
Find top-level imports.
Returns imports
** py-update-imports
Returns imports.
Imports done are displayed in message buffer.
** py-pep8-run
*Run pep8, check formatting - default on the file currently visited.
** py-pep8-help
Display pep8 command line help messages.
** py-pylint-run
Run pylint (default on the file currently visited).
For help see M-x pylint-help resp. M-x pylint-long-help.
Home-page: http://www.logilab.org/project/pylint
** py-pylint-help
Display Pylint command line help messages.
Let’s have this until more Emacs-like help is prepared
** py-pylint-doku
Display Pylint Documentation.
Calls ‘pylint --full-documentation’
** py-pyflakes-run
*Run pyflakes (default on the file currently visited).
For help see M-x pyflakes-help resp. M-x pyflakes-long-help.
Home-page: http://www.logilab.org/project/pyflakes
** py-pyflakes-help
Display Pyflakes command line help messages.
Let’s have this until more Emacs-like help is prepared
** py-pyflakespep8-run
*Run pyflakespep8, check formatting (default on the file currently visited).
** py-pyflakespep8-help
Display pyflakespep8 command line help messages.
** py-pychecker-run
*Run pychecker (default on the file currently visited).
** py-check-command
Check a Python file (default current buffer’s file).
Runs COMMAND, a shell command, as if by ‘compile’.
See ‘py-check-command’ for the default.
** py-flake8-run
Flake8 is a wrapper around these tools:
- PyFlakes
- pep8
- Ned Batchelder’s McCabe script
It also adds features:
- files that contain this line are skipped::
# flake8: noqa
- lines that contain a ‘‘# noqa‘‘ comment at the end will not issue warnings.
- a Git and a Mercurial hook.
- a McCabe complexity checker.
- extendable through ‘‘flake8.extension‘‘ entry points.
** py-flake8-help
Display flake8 command line help messages.
** py-nesting-level
Accepts the output of ‘parse-partial-sexp’.
** py-flycheck-mode
Toggle ‘flycheck-mode’.
With negative argument switch off flycheck-mode
See menu "Tools/Syntax Checking"
** pylint-flymake-mode
Toggle ‘pylint’ ‘flymake-mode’.
** pyflakes-flymake-mode
Toggle ‘pyflakes’ ‘flymake-mode’.
** pychecker-flymake-mode
Toggle ‘pychecker’ ‘flymake-mode’.
** pep8-flymake-mode
Toggle ‘pep8’ ‘flymake-mode’.
** pyflakespep8-flymake-mode
Toggle ‘pyflakespep8’ ‘flymake-mode’.
Joint call to pyflakes and pep8 as proposed by
Keegan Carruthers-Smith
** variables-state
Diplays state of python-mode variables in an org-mode buffer.
Reads variables from python-mode.el as current buffer.
Variables which would produce a large output are left out:
- syntax-tables
- python-mode-map
Maybe call M-x describe-variable RET to query its value.
** py-indent-forward-line
Indent and move one line forward to next indentation.
Returns column of line reached.
If ‘py-kill-empty-line’ is non-nil, delete an empty line.
When closing a form, use py-close-block et al, which will move and indent likewise.
With M-x universal argument just indent.
** py-dedent-forward-line
Dedent line and move one line forward.
** py-dedent
Dedent line according to ‘py-indent-offset’.
With arg, do it that many times.
If point is between indent levels, dedent to next level.
Return indentation reached, if dedent done, nil otherwise.
Affected by ‘py-dedent-keep-relative-column’.
** py-class-at-point
Return class definition as string.
With interactive call, send it to the message buffer too.
** py-function-at-point
Return functions definition as string.
With interactive call, send it to the message buffer too.
** py-backward-function
Jump to the beginning of defun. Returns point.
** py-forward-function
Jump to the end of function.
** py-line-at-point
Return line as string.
With interactive call, send it to the message buffer too.
** py-match-paren-mode
py-match-paren-mode nil oder t
** py-match-paren
If at a beginning, jump to end and vice versa.
When called from within, go to the start.
Matches lists, but also block, statement, string and comment.
** py-documentation
Launch PyDOC on the Word at Point
** eva
Put "eval(...)" forms around strings at point.
** pst-here
Kill previous "pdb.set_trace()" and insert it at point.
** py-printform-insert
Inserts a print statement out of current ‘(car kill-ring)’ by default, inserts STRING if delivered.
With optional C-u print as string
** py-line-to-printform-python2
Transforms the item on current in a print statement.
** py-boolswitch
Edit the assignment of a boolean variable, revert them.
I.e. switch it from "True" to "False" and vice versa
** py-switch-imenu-index-function
Switch between series 5. index machine ‘py--imenu-create-index’ and ‘py--imenu-create-index-new’, which also lists modules variables
** ipython
Start an IPython interpreter.
Optional C-u prompts for path to the interpreter.
** ipython2\.7
Start an IPython2.7 interpreter.
Optional C-u prompts for path to the interpreter.
** ipython3
Start an IPython3 interpreter.
Optional C-u prompts for path to the interpreter.
** jython
Start an Jython interpreter.
Optional C-u prompts for path to the interpreter.
** python
Start an Python interpreter.
Optional C-u prompts for path to the interpreter.
** python2
Start an Python2 interpreter.
Optional C-u prompts for path to the interpreter.
** python3
Start an Python3 interpreter.
Optional C-u prompts for path to the interpreter.
** ipython-dedicated
Start an unique IPython interpreter in another window.
Optional C-u prompts for path to the interpreter.
** ipython2\.7-dedicated
Start an unique IPython2.7 interpreter in another window.
Optional C-u prompts for path to the interpreter.
** ipython3-dedicated
Start an unique IPython3 interpreter in another window.
Optional C-u prompts for path to the interpreter.
** jython-dedicated
Start an unique Jython interpreter in another window.
Optional C-u prompts for path to the interpreter.
** python-dedicated
Start an unique Python interpreter in another window.
Optional C-u prompts for path to the interpreter.
** python2-dedicated
Start an unique Python2 interpreter in another window.
Optional C-u prompts for path to the interpreter.
** python3-dedicated
Start an unique Python3 interpreter in another window.
Optional C-u prompts for path to the interpreter.
** ipython-switch
Switch to IPython interpreter in another window.
Optional C-u prompts for path to the interpreter.
** ipython2\.7-switch
Switch to IPython2.7 interpreter in another window.
Optional C-u prompts for path to the interpreter.
** ipython3-switch
Switch to IPython3 interpreter in another window.
Optional C-u prompts for path to the interpreter.
** jython-switch
Switch to Jython interpreter in another window.
Optional C-u prompts for path to the interpreter.
** python-switch
Switch to Python interpreter in another window.
Optional C-u prompts for path to the interpreter.
** python2-switch
Switch to Python2 interpreter in another window.
Optional C-u prompts for path to the interpreter.
** python3-switch
Switch to Python3 interpreter in another window.
Optional C-u prompts for path to the interpreter.
** ipython-no-switch
Open an IPython interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
** ipython2\.7-no-switch
Open an IPython2.7 interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
** ipython3-no-switch
Open an IPython3 interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
** jython-no-switch
Open an Jython interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
** python-no-switch
Open an Python interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
** python2-no-switch
Open an Python2 interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
** python3-no-switch
Open an Python3 interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
** ipython-switch-dedicated
Switch to an unique IPython interpreter in another window.
Optional C-u prompts for path to the interpreter.
** ipython2\.7-switch-dedicated
Switch to an unique IPython2.7 interpreter in another window.
Optional C-u prompts for path to the interpreter.
** ipython3-switch-dedicated
Switch to an unique IPython3 interpreter in another window.
Optional C-u prompts for path to the interpreter.
** jython-switch-dedicated
Switch to an unique Jython interpreter in another window.
Optional C-u prompts for path to the interpreter.
** python-switch-dedicated
Switch to an unique Python interpreter in another window.
Optional C-u prompts for path to the interpreter.
** python2-switch-dedicated
Switch to an unique Python2 interpreter in another window.
Optional C-u prompts for path to the interpreter.
** python3-switch-dedicated
Switch to an unique Python3 interpreter in another window.
Optional C-u prompts for path to the interpreter.
** py-electric-colon
Insert a colon and indent accordingly.
If a numeric argument ARG is provided, that many colons are inserted
non-electrically.
Electric behavior is inhibited inside a string or
comment or by universal prefix C-u.
Switched by ‘py-electric-colon-active-p’, default is nil
See also ‘py-electric-colon-greedy-p’
** py-electric-close
Close completion buffer when it’s sure, it’s no longer needed, i.e. when inserting a space.
Works around a bug in ‘choose-completion’.
** py-electric-comment
Insert a comment. If starting a comment, indent accordingly.
If a numeric argument ARG is provided, that many "#" are inserted
non-electrically.
With C-u "#" electric behavior is inhibited inside a string or comment.
** py-empty-out-list-backward
Deletes all elements from list before point.
** py-electric-backspace
Delete preceding character or level of indentation.
When ‘delete-active-region’ and (use-region-p), delete region.
Unless at indentation:
With ‘py-electric-kill-backward-p’ delete whitespace before point.
With ‘py-electric-kill-backward-p’ at end of a list, empty that list.
Returns column reached.
** py-electric-delete
Delete following character or levels of whitespace.
When ‘delete-active-region’ and (use-region-p), delete region
** py-electric-yank
Perform command ‘yank’ followed by an ‘indent-according-to-mode’
** virtualenv-current
Barfs the current activated virtualenv
** virtualenv-activate
Activate the virtualenv located in DIR
** virtualenv-deactivate
Deactivate the current virtual enviroment
** virtualenv-workon
Issue a virtualenvwrapper-like virtualenv-workon command
** py-up-statement
Go to the beginning of next statement upwards in buffer.
Return position if statement found, nil otherwise.
** py-down-statement
Go to the beginning of next statement downwards in buffer.
Return position if statement found, nil otherwise.
** py-up-block
Go to the beginning of next block upwards in buffer.
Return position if block found, nil otherwise.
** py-up-class
Go to the beginning of next class upwards in buffer.
Return position if class found, nil otherwise.
** py-up-def
Go to the beginning of next def upwards in buffer.
Return position if def found, nil otherwise.
** py-up-def-or-class
Go to the beginning of next def-or-class upwards in buffer.
Return position if def-or-class found, nil otherwise.
** py-up-minor-block
Go to the beginning of next minor-block upwards in buffer.
Return position if minor-block found, nil otherwise.
** py-down-block
Go to the beginning of next block below in buffer.
Return position if block found, nil otherwise.
** py-down-class
Go to the beginning of next class below in buffer.
Return position if class found, nil otherwise.
** py-down-def
Go to the beginning of next def below in buffer.
Return position if def found, nil otherwise.
** py-down-def-or-class
Go to the beginning of next def-or-class below in buffer.
Return position if def-or-class found, nil otherwise.
** py-down-minor-block
Go to the beginning of next minor-block below in buffer.
Return position if minor-block found, nil otherwise.
** py-up-block-bol
Go to the beginning of next block upwards in buffer.
Go to beginning of line.
Return position if block found, nil otherwise.
** py-up-class-bol
Go to the beginning of next class upwards in buffer.
Go to beginning of line.
Return position if class found, nil otherwise.
** py-up-def-bol
Go to the beginning of next def upwards in buffer.
Go to beginning of line.
Return position if def found, nil otherwise.
** py-up-def-or-class-bol
Go to the beginning of next def-or-class upwards in buffer.
Go to beginning of line.
Return position if def-or-class found, nil otherwise.
** py-up-minor-block-bol
Go to the beginning of next minor-block upwards in buffer.
Go to beginning of line.
Return position if minor-block found, nil otherwise.
** py-down-block-bol
Go to the beginning of next block below in buffer.
Go to beginning of line
Return position if block found, nil otherwise
** py-down-class-bol
Go to the beginning of next class below in buffer.
Go to beginning of line
Return position if class found, nil otherwise
** py-down-def-bol
Go to the beginning of next def below in buffer.
Go to beginning of line
Return position if def found, nil otherwise
** py-down-def-or-class-bol
Go to the beginning of next def-or-class below in buffer.
Go to beginning of line
Return position if def-or-class found, nil otherwise
** py-down-minor-block-bol
Go to the beginning of next minor-block below in buffer.
Go to beginning of line
Return position if minor-block found, nil otherwise
** py-execute-try-block
Send try-block at point to Python default interpreter.
** py-execute-if-block
Send if-block at point to Python default interpreter.
** py-execute-for-block
Send for-block at point to Python default interpreter.
** py-execute-block
Send block at point to interpreter.
** py-execute-block-switch
Send block at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-no-switch
Send block at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-dedicated
Send block at point to unique interpreter.
** py-execute-block-dedicated-switch
Send block at point to unique interpreter and switch to result.
** py-execute-block-ipython
Send block at point to IPython interpreter.
** py-execute-block-ipython-switch
Send block at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-ipython-no-switch
Send block at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-ipython-dedicated
Send block at point to IPython unique interpreter.
** py-execute-block-ipython-dedicated-switch
Send block at point to IPython unique interpreter and switch to result.
** py-execute-block-ipython2\.7
Send block at point to IPython interpreter.
** py-execute-block-ipython2\.7-switch
Send block at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-ipython2\.7-no-switch
Send block at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-ipython2\.7-dedicated
Send block at point to IPython unique interpreter.
** py-execute-block-ipython2\.7-dedicated-switch
Send block at point to IPython unique interpreter and switch to result.
** py-execute-block-ipython3
Send block at point to IPython interpreter.
** py-execute-block-ipython3-switch
Send block at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-ipython3-no-switch
Send block at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-ipython3-dedicated
Send block at point to IPython unique interpreter.
** py-execute-block-ipython3-dedicated-switch
Send block at point to IPython unique interpreter and switch to result.
** py-execute-block-jython
Send block at point to Jython interpreter.
** py-execute-block-jython-switch
Send block at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-jython-no-switch
Send block at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-jython-dedicated
Send block at point to Jython unique interpreter.
** py-execute-block-jython-dedicated-switch
Send block at point to Jython unique interpreter and switch to result.
** py-execute-block-python
Send block at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-block-python-switch
Send block at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-block-python-no-switch
Send block at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-block-python-dedicated
Send block at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-block-python-dedicated-switch
Send block at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-block-python2
Send block at point to Python2 interpreter.
** py-execute-block-python2-switch
Send block at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-python2-no-switch
Send block at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-python2-dedicated
Send block at point to Python2 unique interpreter.
** py-execute-block-python2-dedicated-switch
Send block at point to Python2 unique interpreter and switch to result.
** py-execute-block-python3
Send block at point to Python3 interpreter.
** py-execute-block-python3-switch
Send block at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-python3-no-switch
Send block at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-python3-dedicated
Send block at point to Python3 unique interpreter.
** py-execute-block-python3-dedicated-switch
Send block at point to Python3 unique interpreter and switch to result.
** py-execute-block-or-clause
Send block-or-clause at point to interpreter.
** py-execute-block-or-clause-switch
Send block-or-clause at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-or-clause-no-switch
Send block-or-clause at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-or-clause-dedicated
Send block-or-clause at point to unique interpreter.
** py-execute-block-or-clause-dedicated-switch
Send block-or-clause at point to unique interpreter and switch to result.
** py-execute-block-or-clause-ipython
Send block-or-clause at point to IPython interpreter.
** py-execute-block-or-clause-ipython-switch
Send block-or-clause at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-or-clause-ipython-no-switch
Send block-or-clause at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-or-clause-ipython-dedicated
Send block-or-clause at point to IPython unique interpreter.
** py-execute-block-or-clause-ipython-dedicated-switch
Send block-or-clause at point to IPython unique interpreter and switch to result.
** py-execute-block-or-clause-ipython2\.7
Send block-or-clause at point to IPython interpreter.
** py-execute-block-or-clause-ipython2\.7-switch
Send block-or-clause at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-or-clause-ipython2\.7-no-switch
Send block-or-clause at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-or-clause-ipython2\.7-dedicated
Send block-or-clause at point to IPython unique interpreter.
** py-execute-block-or-clause-ipython2\.7-dedicated-switch
Send block-or-clause at point to IPython unique interpreter and switch to result.
** py-execute-block-or-clause-ipython3
Send block-or-clause at point to IPython interpreter.
** py-execute-block-or-clause-ipython3-switch
Send block-or-clause at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-or-clause-ipython3-no-switch
Send block-or-clause at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-or-clause-ipython3-dedicated
Send block-or-clause at point to IPython unique interpreter.
** py-execute-block-or-clause-ipython3-dedicated-switch
Send block-or-clause at point to IPython unique interpreter and switch to result.
** py-execute-block-or-clause-jython
Send block-or-clause at point to Jython interpreter.
** py-execute-block-or-clause-jython-switch
Send block-or-clause at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-or-clause-jython-no-switch
Send block-or-clause at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-or-clause-jython-dedicated
Send block-or-clause at point to Jython unique interpreter.
** py-execute-block-or-clause-jython-dedicated-switch
Send block-or-clause at point to Jython unique interpreter and switch to result.
** py-execute-block-or-clause-python
Send block-or-clause at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-block-or-clause-python-switch
Send block-or-clause at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-block-or-clause-python-no-switch
Send block-or-clause at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-block-or-clause-python-dedicated
Send block-or-clause at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-block-or-clause-python-dedicated-switch
Send block-or-clause at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-block-or-clause-python2
Send block-or-clause at point to Python2 interpreter.
** py-execute-block-or-clause-python2-switch
Send block-or-clause at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-or-clause-python2-no-switch
Send block-or-clause at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-or-clause-python2-dedicated
Send block-or-clause at point to Python2 unique interpreter.
** py-execute-block-or-clause-python2-dedicated-switch
Send block-or-clause at point to Python2 unique interpreter and switch to result.
** py-execute-block-or-clause-python3
Send block-or-clause at point to Python3 interpreter.
** py-execute-block-or-clause-python3-switch
Send block-or-clause at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-block-or-clause-python3-no-switch
Send block-or-clause at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-block-or-clause-python3-dedicated
Send block-or-clause at point to Python3 unique interpreter.
** py-execute-block-or-clause-python3-dedicated-switch
Send block-or-clause at point to Python3 unique interpreter and switch to result.
** py-execute-buffer
:around advice: ‘ad-Advice-py-execute-buffer’
Send buffer at point to interpreter.
(fn &optional SHELL DEDICATED FAST SPLIT SWITCH PROC WHOLEBUF)
** py-execute-buffer-switch
Send buffer at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-buffer-no-switch
Send buffer at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-buffer-dedicated
Send buffer at point to unique interpreter.
** py-execute-buffer-dedicated-switch
Send buffer at point to unique interpreter and switch to result.
** py-execute-buffer-ipython
Send buffer at point to IPython interpreter.
** py-execute-buffer-ipython-switch
Send buffer at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-buffer-ipython-no-switch
Send buffer at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-buffer-ipython-dedicated
Send buffer at point to IPython unique interpreter.
** py-execute-buffer-ipython-dedicated-switch
Send buffer at point to IPython unique interpreter and switch to result.
** py-execute-buffer-ipython2\.7
Send buffer at point to IPython interpreter.
** py-execute-buffer-ipython2\.7-switch
Send buffer at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-buffer-ipython2\.7-no-switch
Send buffer at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-buffer-ipython2\.7-dedicated
Send buffer at point to IPython unique interpreter.
** py-execute-buffer-ipython2\.7-dedicated-switch
Send buffer at point to IPython unique interpreter and switch to result.
** py-execute-buffer-ipython3
Send buffer at point to IPython interpreter.
** py-execute-buffer-ipython3-switch
Send buffer at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-buffer-ipython3-no-switch
Send buffer at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-buffer-ipython3-dedicated
Send buffer at point to IPython unique interpreter.
** py-execute-buffer-ipython3-dedicated-switch
Send buffer at point to IPython unique interpreter and switch to result.
** py-execute-buffer-jython
Send buffer at point to Jython interpreter.
** py-execute-buffer-jython-switch
Send buffer at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-buffer-jython-no-switch
Send buffer at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-buffer-jython-dedicated
Send buffer at point to Jython unique interpreter.
** py-execute-buffer-jython-dedicated-switch
Send buffer at point to Jython unique interpreter and switch to result.
** py-execute-buffer-python
Send buffer at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-buffer-python-switch
Send buffer at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-buffer-python-no-switch
Send buffer at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-buffer-python-dedicated
Send buffer at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-buffer-python-dedicated-switch
Send buffer at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-buffer-python2
Send buffer at point to Python2 interpreter.
** py-execute-buffer-python2-switch
Send buffer at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-buffer-python2-no-switch
Send buffer at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-buffer-python2-dedicated
Send buffer at point to Python2 unique interpreter.
** py-execute-buffer-python2-dedicated-switch
Send buffer at point to Python2 unique interpreter and switch to result.
** py-execute-buffer-python3
Send buffer at point to Python3 interpreter.
** py-execute-buffer-python3-switch
Send buffer at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-buffer-python3-no-switch
Send buffer at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-buffer-python3-dedicated
Send buffer at point to Python3 unique interpreter.
** py-execute-buffer-python3-dedicated-switch
Send buffer at point to Python3 unique interpreter and switch to result.
** py-execute-class
Send class at point to interpreter.
** py-execute-class-switch
Send class at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-class-no-switch
Send class at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-class-dedicated
Send class at point to unique interpreter.
** py-execute-class-dedicated-switch
Send class at point to unique interpreter and switch to result.
** py-execute-class-ipython
Send class at point to IPython interpreter.
** py-execute-class-ipython-switch
Send class at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-class-ipython-no-switch
Send class at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-class-ipython-dedicated
Send class at point to IPython unique interpreter.
** py-execute-class-ipython-dedicated-switch
Send class at point to IPython unique interpreter and switch to result.
** py-execute-class-ipython2\.7
Send class at point to IPython interpreter.
** py-execute-class-ipython2\.7-switch
Send class at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-class-ipython2\.7-no-switch
Send class at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-class-ipython2\.7-dedicated
Send class at point to IPython unique interpreter.
** py-execute-class-ipython2\.7-dedicated-switch
Send class at point to IPython unique interpreter and switch to result.
** py-execute-class-ipython3
Send class at point to IPython interpreter.
** py-execute-class-ipython3-switch
Send class at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-class-ipython3-no-switch
Send class at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-class-ipython3-dedicated
Send class at point to IPython unique interpreter.
** py-execute-class-ipython3-dedicated-switch
Send class at point to IPython unique interpreter and switch to result.
** py-execute-class-jython
Send class at point to Jython interpreter.
** py-execute-class-jython-switch
Send class at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-class-jython-no-switch
Send class at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-class-jython-dedicated
Send class at point to Jython unique interpreter.
** py-execute-class-jython-dedicated-switch
Send class at point to Jython unique interpreter and switch to result.
** py-execute-class-python
Send class at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-class-python-switch
Send class at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-class-python-no-switch
Send class at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-class-python-dedicated
Send class at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-class-python-dedicated-switch
Send class at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-class-python2
Send class at point to Python2 interpreter.
** py-execute-class-python2-switch
Send class at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-class-python2-no-switch
Send class at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-class-python2-dedicated
Send class at point to Python2 unique interpreter.
** py-execute-class-python2-dedicated-switch
Send class at point to Python2 unique interpreter and switch to result.
** py-execute-class-python3
Send class at point to Python3 interpreter.
** py-execute-class-python3-switch
Send class at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-class-python3-no-switch
Send class at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-class-python3-dedicated
Send class at point to Python3 unique interpreter.
** py-execute-class-python3-dedicated-switch
Send class at point to Python3 unique interpreter and switch to result.
** py-execute-clause
Send clause at point to interpreter.
** py-execute-clause-switch
Send clause at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-clause-no-switch
Send clause at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-clause-dedicated
Send clause at point to unique interpreter.
** py-execute-clause-dedicated-switch
Send clause at point to unique interpreter and switch to result.
** py-execute-clause-ipython
Send clause at point to IPython interpreter.
** py-execute-clause-ipython-switch
Send clause at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-clause-ipython-no-switch
Send clause at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-clause-ipython-dedicated
Send clause at point to IPython unique interpreter.
** py-execute-clause-ipython-dedicated-switch
Send clause at point to IPython unique interpreter and switch to result.
** py-execute-clause-ipython2\.7
Send clause at point to IPython interpreter.
** py-execute-clause-ipython2\.7-switch
Send clause at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-clause-ipython2\.7-no-switch
Send clause at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-clause-ipython2\.7-dedicated
Send clause at point to IPython unique interpreter.
** py-execute-clause-ipython2\.7-dedicated-switch
Send clause at point to IPython unique interpreter and switch to result.
** py-execute-clause-ipython3
Send clause at point to IPython interpreter.
** py-execute-clause-ipython3-switch
Send clause at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-clause-ipython3-no-switch
Send clause at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-clause-ipython3-dedicated
Send clause at point to IPython unique interpreter.
** py-execute-clause-ipython3-dedicated-switch
Send clause at point to IPython unique interpreter and switch to result.
** py-execute-clause-jython
Send clause at point to Jython interpreter.
** py-execute-clause-jython-switch
Send clause at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-clause-jython-no-switch
Send clause at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-clause-jython-dedicated
Send clause at point to Jython unique interpreter.
** py-execute-clause-jython-dedicated-switch
Send clause at point to Jython unique interpreter and switch to result.
** py-execute-clause-python
Send clause at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-clause-python-switch
Send clause at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-clause-python-no-switch
Send clause at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-clause-python-dedicated
Send clause at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-clause-python-dedicated-switch
Send clause at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-clause-python2
Send clause at point to Python2 interpreter.
** py-execute-clause-python2-switch
Send clause at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-clause-python2-no-switch
Send clause at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-clause-python2-dedicated
Send clause at point to Python2 unique interpreter.
** py-execute-clause-python2-dedicated-switch
Send clause at point to Python2 unique interpreter and switch to result.
** py-execute-clause-python3
Send clause at point to Python3 interpreter.
** py-execute-clause-python3-switch
Send clause at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-clause-python3-no-switch
Send clause at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-clause-python3-dedicated
Send clause at point to Python3 unique interpreter.
** py-execute-clause-python3-dedicated-switch
Send clause at point to Python3 unique interpreter and switch to result.
** py-execute-def
Send def at point to interpreter.
** py-execute-def-switch
Send def at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-no-switch
Send def at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-dedicated
Send def at point to unique interpreter.
** py-execute-def-dedicated-switch
Send def at point to unique interpreter and switch to result.
** py-execute-def-ipython
Send def at point to IPython interpreter.
** py-execute-def-ipython-switch
Send def at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-ipython-no-switch
Send def at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-ipython-dedicated
Send def at point to IPython unique interpreter.
** py-execute-def-ipython-dedicated-switch
Send def at point to IPython unique interpreter and switch to result.
** py-execute-def-ipython2\.7
Send def at point to IPython interpreter.
** py-execute-def-ipython2\.7-switch
Send def at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-ipython2\.7-no-switch
Send def at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-ipython2\.7-dedicated
Send def at point to IPython unique interpreter.
** py-execute-def-ipython2\.7-dedicated-switch
Send def at point to IPython unique interpreter and switch to result.
** py-execute-def-ipython3
Send def at point to IPython interpreter.
** py-execute-def-ipython3-switch
Send def at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-ipython3-no-switch
Send def at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-ipython3-dedicated
Send def at point to IPython unique interpreter.
** py-execute-def-ipython3-dedicated-switch
Send def at point to IPython unique interpreter and switch to result.
** py-execute-def-jython
Send def at point to Jython interpreter.
** py-execute-def-jython-switch
Send def at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-jython-no-switch
Send def at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-jython-dedicated
Send def at point to Jython unique interpreter.
** py-execute-def-jython-dedicated-switch
Send def at point to Jython unique interpreter and switch to result.
** py-execute-def-python
Send def at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-def-python-switch
Send def at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-def-python-no-switch
Send def at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-def-python-dedicated
Send def at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-def-python-dedicated-switch
Send def at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-def-python2
Send def at point to Python2 interpreter.
** py-execute-def-python2-switch
Send def at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-python2-no-switch
Send def at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-python2-dedicated
Send def at point to Python2 unique interpreter.
** py-execute-def-python2-dedicated-switch
Send def at point to Python2 unique interpreter and switch to result.
** py-execute-def-python3
Send def at point to Python3 interpreter.
** py-execute-def-python3-switch
Send def at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-python3-no-switch
Send def at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-python3-dedicated
Send def at point to Python3 unique interpreter.
** py-execute-def-python3-dedicated-switch
Send def at point to Python3 unique interpreter and switch to result.
** py-execute-def-or-class
Send def-or-class at point to interpreter.
** py-execute-def-or-class-switch
Send def-or-class at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-or-class-no-switch
Send def-or-class at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-or-class-dedicated
Send def-or-class at point to unique interpreter.
** py-execute-def-or-class-dedicated-switch
Send def-or-class at point to unique interpreter and switch to result.
** py-execute-def-or-class-ipython
Send def-or-class at point to IPython interpreter.
** py-execute-def-or-class-ipython-switch
Send def-or-class at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-or-class-ipython-no-switch
Send def-or-class at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-or-class-ipython-dedicated
Send def-or-class at point to IPython unique interpreter.
** py-execute-def-or-class-ipython-dedicated-switch
Send def-or-class at point to IPython unique interpreter and switch to result.
** py-execute-def-or-class-ipython2\.7
Send def-or-class at point to IPython interpreter.
** py-execute-def-or-class-ipython2\.7-switch
Send def-or-class at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-or-class-ipython2\.7-no-switch
Send def-or-class at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-or-class-ipython2\.7-dedicated
Send def-or-class at point to IPython unique interpreter.
** py-execute-def-or-class-ipython2\.7-dedicated-switch
Send def-or-class at point to IPython unique interpreter and switch to result.
** py-execute-def-or-class-ipython3
Send def-or-class at point to IPython interpreter.
** py-execute-def-or-class-ipython3-switch
Send def-or-class at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-or-class-ipython3-no-switch
Send def-or-class at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-or-class-ipython3-dedicated
Send def-or-class at point to IPython unique interpreter.
** py-execute-def-or-class-ipython3-dedicated-switch
Send def-or-class at point to IPython unique interpreter and switch to result.
** py-execute-def-or-class-jython
Send def-or-class at point to Jython interpreter.
** py-execute-def-or-class-jython-switch
Send def-or-class at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-or-class-jython-no-switch
Send def-or-class at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-or-class-jython-dedicated
Send def-or-class at point to Jython unique interpreter.
** py-execute-def-or-class-jython-dedicated-switch
Send def-or-class at point to Jython unique interpreter and switch to result.
** py-execute-def-or-class-python
Send def-or-class at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-def-or-class-python-switch
Send def-or-class at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-def-or-class-python-no-switch
Send def-or-class at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-def-or-class-python-dedicated
Send def-or-class at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-def-or-class-python-dedicated-switch
Send def-or-class at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-def-or-class-python2
Send def-or-class at point to Python2 interpreter.
** py-execute-def-or-class-python2-switch
Send def-or-class at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-or-class-python2-no-switch
Send def-or-class at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-or-class-python2-dedicated
Send def-or-class at point to Python2 unique interpreter.
** py-execute-def-or-class-python2-dedicated-switch
Send def-or-class at point to Python2 unique interpreter and switch to result.
** py-execute-def-or-class-python3
Send def-or-class at point to Python3 interpreter.
** py-execute-def-or-class-python3-switch
Send def-or-class at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-def-or-class-python3-no-switch
Send def-or-class at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-def-or-class-python3-dedicated
Send def-or-class at point to Python3 unique interpreter.
** py-execute-def-or-class-python3-dedicated-switch
Send def-or-class at point to Python3 unique interpreter and switch to result.
** py-execute-expression
Send expression at point to interpreter.
** py-execute-expression-switch
Send expression at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-expression-no-switch
Send expression at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-expression-dedicated
Send expression at point to unique interpreter.
** py-execute-expression-dedicated-switch
Send expression at point to unique interpreter and switch to result.
** py-execute-expression-ipython
Send expression at point to IPython interpreter.
** py-execute-expression-ipython-switch
Send expression at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-expression-ipython-no-switch
Send expression at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-expression-ipython-dedicated
Send expression at point to IPython unique interpreter.
** py-execute-expression-ipython-dedicated-switch
Send expression at point to IPython unique interpreter and switch to result.
** py-execute-expression-ipython2\.7
Send expression at point to IPython interpreter.
** py-execute-expression-ipython2\.7-switch
Send expression at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-expression-ipython2\.7-no-switch
Send expression at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-expression-ipython2\.7-dedicated
Send expression at point to IPython unique interpreter.
** py-execute-expression-ipython2\.7-dedicated-switch
Send expression at point to IPython unique interpreter and switch to result.
** py-execute-expression-ipython3
Send expression at point to IPython interpreter.
** py-execute-expression-ipython3-switch
Send expression at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-expression-ipython3-no-switch
Send expression at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-expression-ipython3-dedicated
Send expression at point to IPython unique interpreter.
** py-execute-expression-ipython3-dedicated-switch
Send expression at point to IPython unique interpreter and switch to result.
** py-execute-expression-jython
Send expression at point to Jython interpreter.
** py-execute-expression-jython-switch
Send expression at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-expression-jython-no-switch
Send expression at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-expression-jython-dedicated
Send expression at point to Jython unique interpreter.
** py-execute-expression-jython-dedicated-switch
Send expression at point to Jython unique interpreter and switch to result.
** py-execute-expression-python
Send expression at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-expression-python-switch
Send expression at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-expression-python-no-switch
Send expression at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-expression-python-dedicated
Send expression at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-expression-python-dedicated-switch
Send expression at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-expression-python2
Send expression at point to Python2 interpreter.
** py-execute-expression-python2-switch
Send expression at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-expression-python2-no-switch
Send expression at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-expression-python2-dedicated
Send expression at point to Python2 unique interpreter.
** py-execute-expression-python2-dedicated-switch
Send expression at point to Python2 unique interpreter and switch to result.
** py-execute-expression-python3
Send expression at point to Python3 interpreter.
** py-execute-expression-python3-switch
Send expression at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-expression-python3-no-switch
Send expression at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-expression-python3-dedicated
Send expression at point to Python3 unique interpreter.
** py-execute-expression-python3-dedicated-switch
Send expression at point to Python3 unique interpreter and switch to result.
** py-execute-indent
Send indent at point to interpreter.
** py-execute-indent-switch
Send indent at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-indent-no-switch
Send indent at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-indent-dedicated
Send indent at point to unique interpreter.
** py-execute-indent-dedicated-switch
Send indent at point to unique interpreter and switch to result.
** py-execute-indent-ipython
Send indent at point to IPython interpreter.
** py-execute-indent-ipython-switch
Send indent at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-indent-ipython-no-switch
Send indent at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-indent-ipython-dedicated
Send indent at point to IPython unique interpreter.
** py-execute-indent-ipython-dedicated-switch
Send indent at point to IPython unique interpreter and switch to result.
** py-execute-indent-ipython2\.7
Send indent at point to IPython interpreter.
** py-execute-indent-ipython2\.7-switch
Send indent at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-indent-ipython2\.7-no-switch
Send indent at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-indent-ipython2\.7-dedicated
Send indent at point to IPython unique interpreter.
** py-execute-indent-ipython2\.7-dedicated-switch
Send indent at point to IPython unique interpreter and switch to result.
** py-execute-indent-ipython3
Send indent at point to IPython interpreter.
** py-execute-indent-ipython3-switch
Send indent at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-indent-ipython3-no-switch
Send indent at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-indent-ipython3-dedicated
Send indent at point to IPython unique interpreter.
** py-execute-indent-ipython3-dedicated-switch
Send indent at point to IPython unique interpreter and switch to result.
** py-execute-indent-jython
Send indent at point to Jython interpreter.
** py-execute-indent-jython-switch
Send indent at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-indent-jython-no-switch
Send indent at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-indent-jython-dedicated
Send indent at point to Jython unique interpreter.
** py-execute-indent-jython-dedicated-switch
Send indent at point to Jython unique interpreter and switch to result.
** py-execute-indent-python
Send indent at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-indent-python-switch
Send indent at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-indent-python-no-switch
Send indent at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-indent-python-dedicated
Send indent at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-indent-python-dedicated-switch
Send indent at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-indent-python2
Send indent at point to Python2 interpreter.
** py-execute-indent-python2-switch
Send indent at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-indent-python2-no-switch
Send indent at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-indent-python2-dedicated
Send indent at point to Python2 unique interpreter.
** py-execute-indent-python2-dedicated-switch
Send indent at point to Python2 unique interpreter and switch to result.
** py-execute-indent-python3
Send indent at point to Python3 interpreter.
** py-execute-indent-python3-switch
Send indent at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-indent-python3-no-switch
Send indent at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-indent-python3-dedicated
Send indent at point to Python3 unique interpreter.
** py-execute-indent-python3-dedicated-switch
Send indent at point to Python3 unique interpreter and switch to result.
** py-execute-line
Send line at point to interpreter.
** py-execute-line-switch
Send line at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-line-no-switch
Send line at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-line-dedicated
Send line at point to unique interpreter.
** py-execute-line-dedicated-switch
Send line at point to unique interpreter and switch to result.
** py-execute-line-ipython
Send line at point to IPython interpreter.
** py-execute-line-ipython-switch
Send line at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-line-ipython-no-switch
Send line at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-line-ipython-dedicated
Send line at point to IPython unique interpreter.
** py-execute-line-ipython-dedicated-switch
Send line at point to IPython unique interpreter and switch to result.
** py-execute-line-ipython2\.7
Send line at point to IPython interpreter.
** py-execute-line-ipython2\.7-switch
Send line at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-line-ipython2\.7-no-switch
Send line at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-line-ipython2\.7-dedicated
Send line at point to IPython unique interpreter.
** py-execute-line-ipython2\.7-dedicated-switch
Send line at point to IPython unique interpreter and switch to result.
** py-execute-line-ipython3
Send line at point to IPython interpreter.
** py-execute-line-ipython3-switch
Send line at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-line-ipython3-no-switch
Send line at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-line-ipython3-dedicated
Send line at point to IPython unique interpreter.
** py-execute-line-ipython3-dedicated-switch
Send line at point to IPython unique interpreter and switch to result.
** py-execute-line-jython
Send line at point to Jython interpreter.
** py-execute-line-jython-switch
Send line at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-line-jython-no-switch
Send line at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-line-jython-dedicated
Send line at point to Jython unique interpreter.
** py-execute-line-jython-dedicated-switch
Send line at point to Jython unique interpreter and switch to result.
** py-execute-line-python
Send line at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-line-python-switch
Send line at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-line-python-no-switch
Send line at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-line-python-dedicated
Send line at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-line-python-dedicated-switch
Send line at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-line-python2
Send line at point to Python2 interpreter.
** py-execute-line-python2-switch
Send line at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-line-python2-no-switch
Send line at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-line-python2-dedicated
Send line at point to Python2 unique interpreter.
** py-execute-line-python2-dedicated-switch
Send line at point to Python2 unique interpreter and switch to result.
** py-execute-line-python3
Send line at point to Python3 interpreter.
** py-execute-line-python3-switch
Send line at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-line-python3-no-switch
Send line at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-line-python3-dedicated
Send line at point to Python3 unique interpreter.
** py-execute-line-python3-dedicated-switch
Send line at point to Python3 unique interpreter and switch to result.
** py-execute-minor-block
Send minor-block at point to interpreter.
** py-execute-minor-block-switch
Send minor-block at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-minor-block-no-switch
Send minor-block at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-minor-block-dedicated
Send minor-block at point to unique interpreter.
** py-execute-minor-block-dedicated-switch
Send minor-block at point to unique interpreter and switch to result.
** py-execute-minor-block-ipython
Send minor-block at point to IPython interpreter.
** py-execute-minor-block-ipython-switch
Send minor-block at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-minor-block-ipython-no-switch
Send minor-block at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-minor-block-ipython-dedicated
Send minor-block at point to IPython unique interpreter.
** py-execute-minor-block-ipython-dedicated-switch
Send minor-block at point to IPython unique interpreter and switch to result.
** py-execute-minor-block-ipython2\.7
Send minor-block at point to IPython interpreter.
** py-execute-minor-block-ipython2\.7-switch
Send minor-block at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-minor-block-ipython2\.7-no-switch
Send minor-block at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-minor-block-ipython2\.7-dedicated
Send minor-block at point to IPython unique interpreter.
** py-execute-minor-block-ipython2\.7-dedicated-switch
Send minor-block at point to IPython unique interpreter and switch to result.
** py-execute-minor-block-ipython3
Send minor-block at point to IPython interpreter.
** py-execute-minor-block-ipython3-switch
Send minor-block at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-minor-block-ipython3-no-switch
Send minor-block at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-minor-block-ipython3-dedicated
Send minor-block at point to IPython unique interpreter.
** py-execute-minor-block-ipython3-dedicated-switch
Send minor-block at point to IPython unique interpreter and switch to result.
** py-execute-minor-block-jython
Send minor-block at point to Jython interpreter.
** py-execute-minor-block-jython-switch
Send minor-block at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-minor-block-jython-no-switch
Send minor-block at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-minor-block-jython-dedicated
Send minor-block at point to Jython unique interpreter.
** py-execute-minor-block-jython-dedicated-switch
Send minor-block at point to Jython unique interpreter and switch to result.
** py-execute-minor-block-python
Send minor-block at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-minor-block-python-switch
Send minor-block at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-minor-block-python-no-switch
Send minor-block at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-minor-block-python-dedicated
Send minor-block at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-minor-block-python-dedicated-switch
Send minor-block at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-minor-block-python2
Send minor-block at point to Python2 interpreter.
** py-execute-minor-block-python2-switch
Send minor-block at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-minor-block-python2-no-switch
Send minor-block at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-minor-block-python2-dedicated
Send minor-block at point to Python2 unique interpreter.
** py-execute-minor-block-python2-dedicated-switch
Send minor-block at point to Python2 unique interpreter and switch to result.
** py-execute-minor-block-python3
Send minor-block at point to Python3 interpreter.
** py-execute-minor-block-python3-switch
Send minor-block at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-minor-block-python3-no-switch
Send minor-block at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-minor-block-python3-dedicated
Send minor-block at point to Python3 unique interpreter.
** py-execute-minor-block-python3-dedicated-switch
Send minor-block at point to Python3 unique interpreter and switch to result.
** py-execute-paragraph
Send paragraph at point to interpreter.
** py-execute-paragraph-switch
Send paragraph at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-paragraph-no-switch
Send paragraph at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-paragraph-dedicated
Send paragraph at point to unique interpreter.
** py-execute-paragraph-dedicated-switch
Send paragraph at point to unique interpreter and switch to result.
** py-execute-paragraph-ipython
Send paragraph at point to IPython interpreter.
** py-execute-paragraph-ipython-switch
Send paragraph at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-paragraph-ipython-no-switch
Send paragraph at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-paragraph-ipython-dedicated
Send paragraph at point to IPython unique interpreter.
** py-execute-paragraph-ipython-dedicated-switch
Send paragraph at point to IPython unique interpreter and switch to result.
** py-execute-paragraph-ipython2\.7
Send paragraph at point to IPython interpreter.
** py-execute-paragraph-ipython2\.7-switch
Send paragraph at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-paragraph-ipython2\.7-no-switch
Send paragraph at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-paragraph-ipython2\.7-dedicated
Send paragraph at point to IPython unique interpreter.
** py-execute-paragraph-ipython2\.7-dedicated-switch
Send paragraph at point to IPython unique interpreter and switch to result.
** py-execute-paragraph-ipython3
Send paragraph at point to IPython interpreter.
** py-execute-paragraph-ipython3-switch
Send paragraph at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-paragraph-ipython3-no-switch
Send paragraph at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-paragraph-ipython3-dedicated
Send paragraph at point to IPython unique interpreter.
** py-execute-paragraph-ipython3-dedicated-switch
Send paragraph at point to IPython unique interpreter and switch to result.
** py-execute-paragraph-jython
Send paragraph at point to Jython interpreter.
** py-execute-paragraph-jython-switch
Send paragraph at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-paragraph-jython-no-switch
Send paragraph at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-paragraph-jython-dedicated
Send paragraph at point to Jython unique interpreter.
** py-execute-paragraph-jython-dedicated-switch
Send paragraph at point to Jython unique interpreter and switch to result.
** py-execute-paragraph-python
Send paragraph at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-paragraph-python-switch
Send paragraph at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-paragraph-python-no-switch
Send paragraph at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-paragraph-python-dedicated
Send paragraph at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-paragraph-python-dedicated-switch
Send paragraph at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-paragraph-python2
Send paragraph at point to Python2 interpreter.
** py-execute-paragraph-python2-switch
Send paragraph at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-paragraph-python2-no-switch
Send paragraph at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-paragraph-python2-dedicated
Send paragraph at point to Python2 unique interpreter.
** py-execute-paragraph-python2-dedicated-switch
Send paragraph at point to Python2 unique interpreter and switch to result.
** py-execute-paragraph-python3
Send paragraph at point to Python3 interpreter.
** py-execute-paragraph-python3-switch
Send paragraph at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-paragraph-python3-no-switch
Send paragraph at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-paragraph-python3-dedicated
Send paragraph at point to Python3 unique interpreter.
** py-execute-paragraph-python3-dedicated-switch
Send paragraph at point to Python3 unique interpreter and switch to result.
** py-execute-partial-expression
Send partial-expression at point to interpreter.
** py-execute-partial-expression-switch
Send partial-expression at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-partial-expression-no-switch
Send partial-expression at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-partial-expression-dedicated
Send partial-expression at point to unique interpreter.
** py-execute-partial-expression-dedicated-switch
Send partial-expression at point to unique interpreter and switch to result.
** py-execute-partial-expression-ipython
Send partial-expression at point to IPython interpreter.
** py-execute-partial-expression-ipython-switch
Send partial-expression at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-partial-expression-ipython-no-switch
Send partial-expression at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-partial-expression-ipython-dedicated
Send partial-expression at point to IPython unique interpreter.
** py-execute-partial-expression-ipython-dedicated-switch
Send partial-expression at point to IPython unique interpreter and switch to result.
** py-execute-partial-expression-ipython2\.7
Send partial-expression at point to IPython interpreter.
** py-execute-partial-expression-ipython2\.7-switch
Send partial-expression at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-partial-expression-ipython2\.7-no-switch
Send partial-expression at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-partial-expression-ipython2\.7-dedicated
Send partial-expression at point to IPython unique interpreter.
** py-execute-partial-expression-ipython2\.7-dedicated-switch
Send partial-expression at point to IPython unique interpreter and switch to result.
** py-execute-partial-expression-ipython3
Send partial-expression at point to IPython interpreter.
** py-execute-partial-expression-ipython3-switch
Send partial-expression at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-partial-expression-ipython3-no-switch
Send partial-expression at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-partial-expression-ipython3-dedicated
Send partial-expression at point to IPython unique interpreter.
** py-execute-partial-expression-ipython3-dedicated-switch
Send partial-expression at point to IPython unique interpreter and switch to result.
** py-execute-partial-expression-jython
Send partial-expression at point to Jython interpreter.
** py-execute-partial-expression-jython-switch
Send partial-expression at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-partial-expression-jython-no-switch
Send partial-expression at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-partial-expression-jython-dedicated
Send partial-expression at point to Jython unique interpreter.
** py-execute-partial-expression-jython-dedicated-switch
Send partial-expression at point to Jython unique interpreter and switch to result.
** py-execute-partial-expression-python
Send partial-expression at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-partial-expression-python-switch
Send partial-expression at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-partial-expression-python-no-switch
Send partial-expression at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-partial-expression-python-dedicated
Send partial-expression at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-partial-expression-python-dedicated-switch
Send partial-expression at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-partial-expression-python2
Send partial-expression at point to Python2 interpreter.
** py-execute-partial-expression-python2-switch
Send partial-expression at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-partial-expression-python2-no-switch
Send partial-expression at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-partial-expression-python2-dedicated
Send partial-expression at point to Python2 unique interpreter.
** py-execute-partial-expression-python2-dedicated-switch
Send partial-expression at point to Python2 unique interpreter and switch to result.
** py-execute-partial-expression-python3
Send partial-expression at point to Python3 interpreter.
** py-execute-partial-expression-python3-switch
Send partial-expression at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-partial-expression-python3-no-switch
Send partial-expression at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-partial-expression-python3-dedicated
Send partial-expression at point to Python3 unique interpreter.
** py-execute-partial-expression-python3-dedicated-switch
Send partial-expression at point to Python3 unique interpreter and switch to result.
** py-execute-region
Send region at point to interpreter.
** py-execute-region-switch
Send region at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-region-no-switch
Send region at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-region-dedicated
Send region at point to unique interpreter.
** py-execute-region-dedicated-switch
Send region at point to unique interpreter and switch to result.
** py-execute-region-ipython
Send region at point to IPython interpreter.
** py-execute-region-ipython-switch
Send region at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-region-ipython-no-switch
Send region at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-region-ipython-dedicated
Send region at point to IPython unique interpreter.
** py-execute-region-ipython-dedicated-switch
Send region at point to IPython unique interpreter and switch to result.
** py-execute-region-ipython2\.7
Send region at point to IPython interpreter.
** py-execute-region-ipython2\.7-switch
Send region at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-region-ipython2\.7-no-switch
Send region at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-region-ipython2\.7-dedicated
Send region at point to IPython unique interpreter.
** py-execute-region-ipython2\.7-dedicated-switch
Send region at point to IPython unique interpreter and switch to result.
** py-execute-region-ipython3
Send region at point to IPython interpreter.
** py-execute-region-ipython3-switch
Send region at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-region-ipython3-no-switch
Send region at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-region-ipython3-dedicated
Send region at point to IPython unique interpreter.
** py-execute-region-ipython3-dedicated-switch
Send region at point to IPython unique interpreter and switch to result.
** py-execute-region-jython
Send region at point to Jython interpreter.
** py-execute-region-jython-switch
Send region at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-region-jython-no-switch
Send region at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-region-jython-dedicated
Send region at point to Jython unique interpreter.
** py-execute-region-jython-dedicated-switch
Send region at point to Jython unique interpreter and switch to result.
** py-execute-region-python
Send region at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-region-python-switch
Send region at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-region-python-no-switch
Send region at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-region-python-dedicated
Send region at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-region-python-dedicated-switch
Send region at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-region-python2
Send region at point to Python2 interpreter.
** py-execute-region-python2-switch
Send region at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-region-python2-no-switch
Send region at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-region-python2-dedicated
Send region at point to Python2 unique interpreter.
** py-execute-region-python2-dedicated-switch
Send region at point to Python2 unique interpreter and switch to result.
** py-execute-region-python3
Send region at point to Python3 interpreter.
** py-execute-region-python3-switch
Send region at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-region-python3-no-switch
Send region at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-region-python3-dedicated
Send region at point to Python3 unique interpreter.
** py-execute-region-python3-dedicated-switch
Send region at point to Python3 unique interpreter and switch to result.
** py-execute-statement
Send statement at point to interpreter.
** py-execute-statement-switch
Send statement at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-statement-no-switch
Send statement at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-statement-dedicated
Send statement at point to unique interpreter.
** py-execute-statement-dedicated-switch
Send statement at point to unique interpreter and switch to result.
** py-execute-statement-ipython
Send statement at point to IPython interpreter.
** py-execute-statement-ipython-switch
Send statement at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-statement-ipython-no-switch
Send statement at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-statement-ipython-dedicated
Send statement at point to IPython unique interpreter.
** py-execute-statement-ipython-dedicated-switch
Send statement at point to IPython unique interpreter and switch to result.
** py-execute-statement-ipython2\.7
Send statement at point to IPython interpreter.
** py-execute-statement-ipython2\.7-switch
Send statement at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-statement-ipython2\.7-no-switch
Send statement at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-statement-ipython2\.7-dedicated
Send statement at point to IPython unique interpreter.
** py-execute-statement-ipython2\.7-dedicated-switch
Send statement at point to IPython unique interpreter and switch to result.
** py-execute-statement-ipython3
Send statement at point to IPython interpreter.
** py-execute-statement-ipython3-switch
Send statement at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-statement-ipython3-no-switch
Send statement at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-statement-ipython3-dedicated
Send statement at point to IPython unique interpreter.
** py-execute-statement-ipython3-dedicated-switch
Send statement at point to IPython unique interpreter and switch to result.
** py-execute-statement-jython
Send statement at point to Jython interpreter.
** py-execute-statement-jython-switch
Send statement at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-statement-jython-no-switch
Send statement at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-statement-jython-dedicated
Send statement at point to Jython unique interpreter.
** py-execute-statement-jython-dedicated-switch
Send statement at point to Jython unique interpreter and switch to result.
** py-execute-statement-python
Send statement at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-statement-python-switch
Send statement at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-statement-python-no-switch
Send statement at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-statement-python-dedicated
Send statement at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-statement-python-dedicated-switch
Send statement at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-statement-python2
Send statement at point to Python2 interpreter.
** py-execute-statement-python2-switch
Send statement at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-statement-python2-no-switch
Send statement at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-statement-python2-dedicated
Send statement at point to Python2 unique interpreter.
** py-execute-statement-python2-dedicated-switch
Send statement at point to Python2 unique interpreter and switch to result.
** py-execute-statement-python3
Send statement at point to Python3 interpreter.
** py-execute-statement-python3-switch
Send statement at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-statement-python3-no-switch
Send statement at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-statement-python3-dedicated
Send statement at point to Python3 unique interpreter.
** py-execute-statement-python3-dedicated-switch
Send statement at point to Python3 unique interpreter and switch to result.
** py-execute-top-level
Send top-level at point to interpreter.
** py-execute-top-level-switch
Send top-level at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-top-level-no-switch
Send top-level at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-top-level-dedicated
Send top-level at point to unique interpreter.
** py-execute-top-level-dedicated-switch
Send top-level at point to unique interpreter and switch to result.
** py-execute-top-level-ipython
Send top-level at point to IPython interpreter.
** py-execute-top-level-ipython-switch
Send top-level at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-top-level-ipython-no-switch
Send top-level at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-top-level-ipython-dedicated
Send top-level at point to IPython unique interpreter.
** py-execute-top-level-ipython-dedicated-switch
Send top-level at point to IPython unique interpreter and switch to result.
** py-execute-top-level-ipython2\.7
Send top-level at point to IPython interpreter.
** py-execute-top-level-ipython2\.7-switch
Send top-level at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-top-level-ipython2\.7-no-switch
Send top-level at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-top-level-ipython2\.7-dedicated
Send top-level at point to IPython unique interpreter.
** py-execute-top-level-ipython2\.7-dedicated-switch
Send top-level at point to IPython unique interpreter and switch to result.
** py-execute-top-level-ipython3
Send top-level at point to IPython interpreter.
** py-execute-top-level-ipython3-switch
Send top-level at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-top-level-ipython3-no-switch
Send top-level at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-top-level-ipython3-dedicated
Send top-level at point to IPython unique interpreter.
** py-execute-top-level-ipython3-dedicated-switch
Send top-level at point to IPython unique interpreter and switch to result.
** py-execute-top-level-jython
Send top-level at point to Jython interpreter.
** py-execute-top-level-jython-switch
Send top-level at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-top-level-jython-no-switch
Send top-level at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-top-level-jython-dedicated
Send top-level at point to Jython unique interpreter.
** py-execute-top-level-jython-dedicated-switch
Send top-level at point to Jython unique interpreter and switch to result.
** py-execute-top-level-python
Send top-level at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-top-level-python-switch
Send top-level at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
** py-execute-top-level-python-no-switch
Send top-level at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
** py-execute-top-level-python-dedicated
Send top-level at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
** py-execute-top-level-python-dedicated-switch
Send top-level at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
** py-execute-top-level-python2
Send top-level at point to Python2 interpreter.
** py-execute-top-level-python2-switch
Send top-level at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-top-level-python2-no-switch
Send top-level at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-top-level-python2-dedicated
Send top-level at point to Python2 unique interpreter.
** py-execute-top-level-python2-dedicated-switch
Send top-level at point to Python2 unique interpreter and switch to result.
** py-execute-top-level-python3
Send top-level at point to Python3 interpreter.
** py-execute-top-level-python3-switch
Send top-level at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
** py-execute-top-level-python3-no-switch
Send top-level at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
** py-execute-top-level-python3-dedicated
Send top-level at point to Python3 unique interpreter.
** py-execute-top-level-python3-dedicated-switch
Send top-level at point to Python3 unique interpreter and switch to result.
** py-edit-abbrevs
Jumps to ‘python-mode-abbrev-table’ in a buffer containing lists of abbrev definitions.
You can edit them and type C-c C-c to redefine abbrevs
according to your editing.
Buffer contains a header line for each abbrev table,
which is the abbrev table name in parentheses.
This is followed by one line per abbrev in that table:
NAME USECOUNT EXPANSION HOOK
where NAME and EXPANSION are strings with quotes,
USECOUNT is an integer, and HOOK is any valid function
or may be omitted (it is usually omitted).
** py-add-abbrev
Defines python-mode specific abbrev for last expressions before point.
Argument is how many ‘py-partial-expression’s form the expansion; or zero means the region is the expansion.
Reads the abbreviation in the minibuffer; with numeric arg it displays a proposal for an abbrev.
Proposal is composed from the initial character(s) of the
expansion.
Don’t use this function in a Lisp program; use ‘define-abbrev’ instead.
** py-fill-paren
Paren fill function for ‘py-fill-paragraph’.
JUSTIFY should be used (if applicable) as in ‘fill-paragraph’.
** py-fill-string-django
Fill docstring according to Django’s coding standards style.
"""
Process foo, return bar.
"""
"""
Process foo, return bar.
If processing fails throw ProcessingError.
"""
See available styles at ‘py-fill-paragraph’ or var ‘py-docstring-style’
** py-fill-string-onetwo
One newline and start and Two at end style.
"""Process foo, return bar."""
"""
Process foo, return bar.
If processing fails throw ProcessingError.
"""
See available styles at ‘py-fill-paragraph’ or var ‘py-docstring-style’
** py-fill-string-pep-257
PEP-257 with 2 newlines at end of string.
"""Process foo, return bar."""
"""Process foo, return bar.
If processing fails throw ProcessingError.
"""
See available styles at ‘py-fill-paragraph’ or var ‘py-docstring-style’
** py-fill-string-pep-257-nn
PEP-257 with 1 newline at end of string.
"""Process foo, return bar."""
"""Process foo, return bar.
If processing fails throw ProcessingError.
"""
See available styles at ‘py-fill-paragraph’ or var ‘py-docstring-style’
** py-fill-string-symmetric
Symmetric style.
"""Process foo, return bar."""
"""
Process foo, return bar.
If processing fails throw ProcessingError.
"""
See available styles at ‘py-fill-paragraph’ or var ‘py-docstring-style’
** py-set-nil-docstring-style
Set py-docstring-style to ’nil
** py-set-pep-257-nn-docstring-style
Set py-docstring-style to ’pep-257-nn
** py-set-pep-257-docstring-style
Set py-docstring-style to ’pep-257
** py-set-django-docstring-style
Set py-docstring-style to ’django
** py-set-symmetric-docstring-style
Set py-docstring-style to ’symmetric
** py-set-onetwo-docstring-style
Set py-docstring-style to ’onetwo
** py-fill-comment
Fill the comment paragraph at point
** py-fill-labelled-string
Fill string or paragraph containing lines starting with label
See lp:1066489
** py--string-fence-delete-spaces
Delete spaces following or preceding delimiters of string at point.
** py-fill-string
String fill function for ‘py-fill-paragraph’.
JUSTIFY should be used (if applicable) as in ‘fill-paragraph’.
Fill according to ‘py-docstring-style’
** py-shift-left
Dedent region according to ‘py-indent-offset’ by COUNT times.
If no region is active, current line is dedented.
Returns indentation reached.
** py-shift-right
Indent region according to ‘py-indent-offset’ by COUNT times.
If no region is active, current line is indented.
Returns indentation reached.
** py-shift-block-right
Indent block by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-block-left
Dedent block by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-block-or-clause-right
Indent block-or-clause by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-block-or-clause-left
Dedent block-or-clause by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-class-right
Indent class by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-class-left
Dedent class by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-clause-right
Indent clause by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-clause-left
Dedent clause by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-comment-right
Indent comment by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-comment-left
Dedent comment by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-def-right
Indent def by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-def-left
Dedent def by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-def-or-class-right
Indent def-or-class by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-def-or-class-left
Dedent def-or-class by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-indent-right
Indent indent by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-indent-left
Dedent indent by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-minor-block-right
Indent minor-block by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-minor-block-left
Dedent minor-block by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-paragraph-right
Indent paragraph by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-paragraph-left
Dedent paragraph by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-region-right
Indent region by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-region-left
Dedent region by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-statement-right
Indent statement by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-statement-left
Dedent statement by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-top-level-right
Indent top-level by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-shift-top-level-left
Dedent top-level by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
** py-execute-file-python
Send file to Python default interpreter.
** py-execute-file-python-switch
Send file to Python default interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-python-no-switch
Send file to Python default interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
** py-execute-file-python-dedicated
Send file to Python default interpreter.
Uses a dedicated shell.
** py-execute-file-python-dedicated-switch
Send file to Python default interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-ipython
Send file to a Ipython interpreter.
** py-execute-file-ipython-switch
Send file to a Ipython interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-ipython-no-switch
Send file to a Ipython interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
** py-execute-file-ipython-dedicated
Send file to a Ipython interpreter.
Uses a dedicated shell.
** py-execute-file-ipython-dedicated-switch
Send file to a Ipython interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-python3
Send file to a Python3 interpreter.
** py-execute-file-python3-switch
Send file to a Python3 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-python3-no-switch
Send file to a Python3 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
** py-execute-file-python3-dedicated
Send file to a Python3 interpreter.
Uses a dedicated shell.
** py-execute-file-python3-dedicated-switch
Send file to a Python3 interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-python2
Send file to a Python2 interpreter.
** py-execute-file-python2-switch
Send file to a Python2 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-python2-no-switch
Send file to a Python2 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
** py-execute-file-python2-dedicated
Send file to a Python2 interpreter.
Uses a dedicated shell.
** py-execute-file-python2-dedicated-switch
Send file to a Python2 interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-python2\.7
Send file to a Python2.7 interpreter.
** py-execute-file-python2\.7-switch
Send file to a Python2.7 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-python2\.7-no-switch
Send file to a Python2.7 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
** py-execute-file-python2\.7-dedicated
Send file to a Python2.7 interpreter.
Uses a dedicated shell.
** py-execute-file-python2\.7-dedicated-switch
Send file to a Python2.7 interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-jython
Send file to a Jython interpreter.
** py-execute-file-jython-switch
Send file to a Jython interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-jython-no-switch
Send file to a Jython interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
** py-execute-file-jython-dedicated
Send file to a Jython interpreter.
Uses a dedicated shell.
** py-execute-file-jython-dedicated-switch
Send file to a Jython interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-python3\.2
Send file to a Python3.2 interpreter.
** py-execute-file-python3\.2-switch
Send file to a Python3.2 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-python3\.2-no-switch
Send file to a Python3.2 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
** py-execute-file-python3\.2-dedicated
Send file to a Python3.2 interpreter.
Uses a dedicated shell.
** py-execute-file-python3\.2-dedicated-switch
Send file to a Python3.2 interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-python3\.3
Send file to a Python3.3 interpreter.
** py-execute-file-python3\.3-switch
Send file to a Python3.3 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-file-python3\.3-no-switch
Send file to a Python3.3 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
** py-execute-file-python3\.3-dedicated
Send file to a Python3.3 interpreter.
Uses a dedicated shell.
** py-execute-file-python3\.3-dedicated-switch
Send file to a Python3.3 interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
** py-execute-section
Execute section at point.
** py-execute-section-python
Execute section at point using python interpreter.
** py-execute-section-python2
Execute section at point using python2 interpreter.
** py-execute-section-python3
Execute section at point using python3 interpreter.
** py-execute-section-ipython
Execute section at point using ipython interpreter.
** py-execute-section-ipython2\.7
Execute section at point using ipython2.7 interpreter.
** py-execute-section-ipython3
Execute section at point using ipython3 interpreter.
** py-execute-section-jython
Execute section at point using jython interpreter.
** py-comment-region
Like ‘comment-region’ but uses double hash (‘#’) comment starter.
** py-comment-block
Comments block at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
** py-comment-block-or-clause
Comments block-or-clause at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
** py-comment-class
Comments class at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
** py-comment-clause
Comments clause at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
** py-comment-def
Comments def at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
** py-comment-def-or-class
Comments def-or-class at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
** py-comment-indent
Comments indent at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
** py-comment-minor-block
Comments minor-block at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
** py-comment-section
Comments section at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
** py-comment-statement
Comments statement at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
** py-comment-top-level
Comments top-level at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
** py-block
Block at point.
Return code of ‘py-block’ at point, a string.
** py-block-or-clause
Block-Or-Clause at point.
Return code of ‘py-block-or-clause’ at point, a string.
** py-buffer
Buffer at point.
Return code of ‘py-buffer’ at point, a string.
** py-class
Class at point.
Return code of ‘py-class’ at point, a string.
** py-clause
Clause at point.
Return code of ‘py-clause’ at point, a string.
** py-def
Def at point.
Return code of ‘py-def’ at point, a string.
** py-def-or-class
Def-Or-Class at point.
Return code of ‘py-def-or-class’ at point, a string.
** py-expression
Expression at point.
Return code of ‘py-expression’ at point, a string.
** py-indent
Indent at point.
Return code of ‘py-indent’ at point, a string.
** py-line
Line at point.
Return code of ‘py-line’ at point, a string.
** py-minor-block
Minor-Block at point.
Return code of ‘py-minor-block’ at point, a string.
** py-paragraph
Paragraph at point.
Return code of ‘py-paragraph’ at point, a string.
** py-partial-expression
Partial-Expression at point.
Return code of ‘py-partial-expression’ at point, a string.
** py-region
Region at point.
Return code of ‘py-region’ at point, a string.
** py-statement
Statement at point.
Return code of ‘py-statement’ at point, a string.
** py-top-level
Top-Level at point.
Return code of ‘py-top-level’ at point, a string.
** py-fast-process
Connect am (I)Python process suitable for large output.
Output buffer displays "Fast" by default
It is not in interactive, i.e. comint-mode, as its bookkeepings seem linked to the freeze reported by lp:1253907
** py-execute-block-fast
Process block at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
** py-execute-block-or-clause-fast
Process block-or-clause at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
** py-execute-class-fast
Process class at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
** py-execute-clause-fast
Process clause at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
** py-execute-def-fast
Process def at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
** py-execute-def-or-class-fast
Process def-or-class at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
** py-execute-expression-fast
Process expression at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
** py-execute-partial-expression-fast
Process partial-expression at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
** py-execute-section-fast
Process section at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
** py-execute-statement-fast
Process statement at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
** py-execute-top-level-fast
Process top-level at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
** py-narrow-to-block
Narrow to block at point.
** py-narrow-to-block-or-clause
Narrow to block-or-clause at point.
** py-narrow-to-class
Narrow to class at point.
** py-narrow-to-clause
Narrow to clause at point.
** py-narrow-to-def
Narrow to def at point.
** py-narrow-to-def-or-class
Narrow to def-or-class at point.
** py-narrow-to-statement
Narrow to statement at point.
** py-comment-auto-fill
Toggles comment-auto-fill mode
** py-hide-show
Toggle visibility of existing forms at point.
** py-hide-region
Hide active region.
** py-show-region
Un-hide active region.
** py-hide-block
Hide block at point.
** py-show-block
Show block at point.
** py-hide-block-or-clause
Hide block-or-clause at point.
** py-show-block-or-clause
Show block-or-clause at point.
** py-hide-class
Hide class at point.
** py-show-class
Show class at point.
** py-hide-clause
Hide clause at point.
** py-show-clause
Show clause at point.
** py-hide-comment
Hide comment at point.
** py-show-comment
Show comment at point.
** py-hide-def
Hide def at point.
** py-show-def
Show def at point.
** py-hide-def-or-class
Hide def-or-class at point.
** py-show-def-or-class
Show def-or-class at point.
** py-hide-elif-block
Hide elif-block at point.
** py-show-elif-block
Show elif-block at point.
** py-hide-else-block
Hide else-block at point.
** py-show-else-block
Show else-block at point.
** py-hide-except-block
Hide except-block at point.
** py-show-except-block
Show except-block at point.
** py-hide-expression
Hide expression at point.
** py-show-expression
Show expression at point.
** py-hide-for-block
Hide for-block at point.
** py-show-for-block
Show for-block at point.
** py-hide-if-block
Hide if-block at point.
** py-show-if-block
Show if-block at point.
** py-hide-indent
Hide indent at point.
** py-show-indent
Show indent at point.
** py-hide-line
Hide line at point.
** py-show-line
Show line at point.
** py-hide-minor-block
Hide minor-block at point.
** py-show-minor-block
Show minor-block at point.
** py-hide-paragraph
Hide paragraph at point.
** py-show-paragraph
Show paragraph at point.
** py-hide-partial-expression
Hide partial-expression at point.
** py-show-partial-expression
Show partial-expression at point.
** py-hide-section
Hide section at point.
** py-show-section
Show section at point.
** py-hide-statement
Hide statement at point.
** py-show-statement
Show statement at point.
** py-hide-top-level
Hide top-level at point.
** py-show-top-level
Show top-level at point.
** py-fast-complete
Complete word before point, if any.
Use ‘py-fast-process’
** ar--beginning-of-form-intern
Go to beginning of FORM.
With INDENT, go to beginning one level above.
Whit IACT, print result in message buffer.
Returns beginning of FORM if successful, nil otherwise
** py-in-comment-p
Return the beginning of current line’s comment, if inside.
** py-forward-buffer
A complementary form used by auto-generated commands.
Returns position reached if successful
** py-backward-buffer
A complementary form used by auto-generated commands.
Returns position reached if successful
** py-load-skeletons
Load skeletons from extensions.
** py-python-version
Returns versions number of a Python EXECUTABLE, string.
If no EXECUTABLE given, ‘py-shell-name’ is used.
Interactively output of ‘--version’ is displayed.
** py-version
Echo the current version of ‘python-mode’ in the minibuffer.
** py-load-file
Load a Python file FILE-NAME into the Python process.
If the file has extension ‘.py’ import or reload it as a module.
Treating it as a module keeps the global namespace clean, provides
function location information for debugging, and supports users of
module-qualified names.
** py-proc
Return the current Python process.
Start a new process if necessary.
** py-guess-pdb-path
If py-pdb-path isn’t set, find location of pdb.py.
** py-switch-shell
Toggles between the interpreter customized in ‘py-shell-toggle-1’ resp. ‘py-shell-toggle-2’. Was hard-coded CPython and Jython in earlier versions, now starts with Python2 and Python3 by default.
ARG might be a python-version string to set to.
C-u ‘py-toggle-shell’ prompts to specify a reachable Python command.
C-u followed by numerical arg 2 or 3, ‘py-toggle-shell’ opens a respective Python shell.
C-u followed by numerical arg 5 opens a Jython shell.
Should you need more shells to select, extend this command by adding inside the first cond:
((eq NUMBER (prefix-numeric-value arg))
"MY-PATH-TO-SHELL")
** py-uncomment
Uncomment commented lines at point.
If region is active, restrict uncommenting at region
** py-set-command-args
Set Python arguments on the fly, override defaults in this session.
Use ‘defcustom’ to keep value across sessions
** py-symbol-at-point
Return the current Python symbol.
** py-kill-buffer-unconditional
Kill buffer unconditional, kill buffer-process if existing.
** py-compute-indentation
Compute Python indentation.
When HONOR-BLOCK-CLOSE-P is non-nil, statements such as ‘return’,
‘raise’, ‘break’, ‘continue’, and ‘pass’ force one level of dedenting.
Optional arguments are flags resp. values set and used by ‘py-compute-indentation’ internally:
ORIG keeps original position
ORIGLINE keeps line where compute started
CLOSING is t when started at a char delimiting a list as "]})"
LINE indicates being not at origline now
NESTING is currently ignored, if executing from inside a list
REPEAT counter enables checks against ‘py-max-specpdl-size’
INDENT-OFFSET allows calculation of block-local values
LIEP stores line-end-position at point-of-interest
** py-continuation-offset
With numeric ARG different from 1 py-continuation-offset is set to that value; returns py-continuation-offset.
** py-indentation-of-statement
Returns the indenation of the statement at point.
** py-end-of-list-position
Return end position, nil if not inside.
Optional ARG indicates a start-position for ‘parse-partial-sexp’.
** py-in-triplequoted-string-p
Returns character address of start tqs-string, nil if not inside.
** py-in-string-p
if inside a double- triple- or singlequoted string,
If non-nil, return a list composed of
- beginning position
- the character used as string-delimiter (in decimal)
- and length of delimiter, commonly 1 or 3
** py-in-statement-p
Returns list of beginning and end-position if inside.
Result is useful for booleans too: (when (py-in-statement-p)...)
will work.
** py-backward-top-level-p
Returns position, if cursor is at the beginning of a top-level, nil otherwise.
** py-look-downward-for-clause
If beginning of other clause exists downward in current block.
If succesful return position.
** py-current-defun
Go to the outermost method or class definition in current scope.
Python value for ‘add-log-current-defun-function’.
This tells add-log.el how to find the current function/method/variable.
Returns name of class or methods definition, if found, nil otherwise.
See customizable variables ‘py-current-defun-show’ and ‘py-current-defun-delay’.
** py-sort-imports
Sort multiline imports.
Put point inside the parentheses of a multiline import and hit
M-x py-sort-imports to sort the imports lexicographically
** py-install-local-shells
Builds Python-shell commands from executable found in LOCAL.
If LOCAL is empty, shell-command ‘find’ searches beneath current directory.
Eval resulting buffer to install it, see customizable ‘py-extensions’.
** py-end-of-string
Go to end of string at point if any, if successful return position.
** py-which-def-or-class
Returns concatenated ‘def’ and ‘class’ names in hierarchical order, if cursor is inside.
Returns "???" otherwise
Used by variable ‘which-func-functions’
** py--beginning-of-form-intern
Go to beginning of FORM.
With INDENT, go to beginning one level above.
Whit IACT, print result in message buffer.
Returns beginning of FORM if successful, nil otherwise
** py-unload-python-el
Unloads python-mode delivered by shipped python.el
Removes python-skeleton forms from abbrevs.
These would interfere when inserting forms heading a block
** py-backward-top-level
Go up to beginning of statments until level of indentation is null.
Returns position if successful, nil otherwise
** py-forward-top-level
Go to end of top-level form at point.
Returns position if successful, nil otherwise
** py-down-top-level
Go to beginning of next top-level form downward.
Returns position if successful, nil otherwise
** py-forward-top-level-bol
Go to end of top-level form at point, stop at next beginning-of-line.
Returns position successful, nil otherwise
** py-down
Go to beginning one level below of compound statement or definition at point.
If no statement or block below, but a delimited form --string or list-- go to its beginning. Repeated call from there will behave like down-list.
Returns position if successful, nil otherwise
** py-beginning
Go to beginning of compound statement or definition at point.
With C-u, go to beginning one level above.
Returns position if successful, nil otherwise
** py-end
Go to end of of compound statement or definition at point.
Returns position block if successful, nil otherwise
** py-backward-same-level
Go form backward keeping indent level if possible.
If inside a delimited form --string or list-- go to its beginning.
If not at beginning of a statement or block, go to its beginning.
If at beginning of a statement or block, go to previous beginning of compound statement or definition at point.
If no further element at same level, go one level up.
** py-sectionize-region
Markup code in region as section.
Use current region unless optional args BEG END are delivered.
** py-rotate-shell-fontify-style
Rotates between possible values ’all, ’input and nil.
python-mode.el-6.2.3/doc/variables-python-mode.rst 0000644 0000000 0000000 00000105536 13037357637 022062 0 ustar root root 0000000 0000000 Variables
====================
py-install-directory
--------------------
Directory where python-mode.el and it’s subdirectories should be installed. Needed for completion and other environment stuff only.
py-pythonpath
-------------
Define $PYTHONPATH here, if needed.
Emacs doesn’t read .bashrc
python-mode-modeline-display
----------------------------
String to display in Emacs modeline
py-extensions
-------------
File where extensions to python-mode.el should be installed. Used by virtualenv support.
info-lookup-mode
----------------
Which Python documentation should be queried.
Make sure it’s accessible from Emacs by M-x info RET ...
See INSTALL-INFO-FILES for help.
py-fast-process-p
-----------------
Use ‘py-fast-process’.
Commands prefixed "py-fast-..." suitable for large output
See: large output makes Emacs freeze, lp:1253907
Results arrive in output buffer, which is not in comint-mode
py-comment-auto-fill-p
----------------------
When non-nil, fill comments.
Defaut is nil
py-sexp-use-expression-p
------------------------
If non-nil, C-M-s call py-forward-expression.
Respective C-M-b will call py-backward-expression
Default is t
py-session-p
------------
If commands would use an existing process.
If nil, a maybe existing process at py-buffer-name would be killed and re-started
See also ‘py-dedicated-process-p’
py-max-help-buffer-p
--------------------
If "*Python-Help*"-buffer should appear as the only visible.
Default is nil. In help-buffer, "q" will close it.
py-highlight-error-source-p
---------------------------
When py-execute-... commands raise an error, respective code in source-buffer will be highlighted. Default is nil.
M-x ‘py-remove-overlays-at-point’ removes that highlighting.
py-set-pager-cat-p
------------------
If the shell environment variable $PAGER should set to ‘cat’.
If ‘t’, use ‘C-c C-r’ to jump to beginning of output. Then scroll normally.
Avoids lp:783828, "Terminal not fully functional", for help(’COMMAND’) in python-shell
When non-nil, imports module ‘os’
py-empty-line-closes-p
----------------------
When non-nil, dedent after empty line following block
if True:
print("Part of the if-statement")
print("Not part of the if-statement")
Default is nil
If non-nil, a C-j from empty line dedents.
py-prompt-on-changed-p
----------------------
When called interactively, ask for save before a changed buffer is sent to interpreter.
Default is ‘t’
py-dedicated-process-p
----------------------
If commands executing code use a dedicated shell.
Default is nil
When non-nil and ‘py-session-p’, an existing dedicated process is re-used instead of default - which allows executing stuff in parallel.
py-store-result-p
-----------------
When non-nil, put resulting string of ‘py-execute-...’ into kill-ring, so it might be yanked.
Default is nil
py--execute-use-temp-file-p
---------------------------
Assume execution at a remote machine.
where write-access is not given.
py-electric-close-active-p
--------------------------
Close completion buffer when it’s sure, it’s no longer needed, i.e. when inserting a space.
Works around a bug in ‘choose-completion’.
Default is ‘nil’
py-update-gud-pdb-history-p
---------------------------
If pdb should provide suggestions WRT file to check and py-pdb-path.
Default is t
See lp:963253
py-pdb-executable
-----------------
Indicate PATH/TO/pdb.
Default is nil
See lp:963253
py-hide-show-minor-mode-p
-------------------------
If hide-show minor-mode should be on, default is nil.
py-load-skeletons-p
-------------------
If skeleton definitions should be loaded, default is nil.
If non-nil and abbrev-mode on, block-skeletons will inserted.
Pressing "if" for example will prompt for the if-condition.
py-if-name-main-permission-p
----------------------------
Allow execution of code inside blocks started
by "if __name__== ’__main__’:".
Default is non-nil
py-use-font-lock-doc-face-p
---------------------------
If documention string inside of def or class get ‘font-lock-doc-face’.
‘font-lock-doc-face’ inherits ‘font-lock-string-face’.
Call M-x ‘customize-face’ in order to have a visible effect.
py-empty-comment-line-separates-paragraph-p
-------------------------------------------
Consider paragraph start/end lines with nothing inside but comment sign.
Default is non-nil
py-indent-honors-inline-comment
-------------------------------
If non-nil, indents to column of inlined comment start.
Default is nil.
py-auto-fill-mode
-----------------
If python-mode should set fill-column
according values in ‘py-comment-fill-column’ and ‘py-docstring-fill-column’.
Default is nil
py-error-markup-delay
---------------------
Seconds error’s are highlighted in exception buffer.
py-fast-completion-delay
------------------------
Used by py--fast-send-string-intern.
py-new-shell-delay
------------------
If a new comint buffer is connected to Python, commands like completion might need some delay.
py-autofill-timer-delay
-----------------------
Delay when idle before functions ajusting ‘py-docstring-fill-column’ resp. ‘py-comment-fill-column’ are called.
py-docstring-fill-column
------------------------
Value of ‘fill-column’ to use when filling a docstring.
Any non-integer value means do not use a different value of
‘fill-column’ when filling docstrings.
py-comment-fill-column
----------------------
Value of ‘fill-column’ to use when filling a comment.
Any non-integer value means do not use a different value of
‘fill-column’ when filling docstrings.
py-fontify-shell-buffer-p
-------------------------
If code in Python shell should be highlighted as in script buffer.
Default is nil.
If ‘t’, related vars like ‘comment-start’ will be set too.
Seems convenient when playing with stuff in IPython shell
Might not be TRT when a lot of output arrives
py-modeline-display-full-path-p
-------------------------------
If the full PATH/TO/PYTHON should be displayed in shell modeline.
Default is nil. Note: when ‘py-shell-name’ is specified with path, it’s shown as an acronym in buffer-name already.
py-modeline-acronym-display-home-p
----------------------------------
If the modeline acronym should contain chars indicating the home-directory.
Default is nil
py-timer-close-completions-p
----------------------------
If ‘py-timer-close-completion-buffer’ should run, default is non-nil.
py-smart-operator-mode-p
------------------------
If python-mode calls ‘smart-operator-mode-on’
Default is nil.
py-autopair-mode
----------------
If python-mode calls (autopair-mode-on)
Default is nil
Load ‘autopair-mode’ written by Joao Tavora
URL: http://autopair.googlecode.com
py-indent-no-completion-p
-------------------------
If completion function should insert a TAB when no completion found.
Default is ‘nil’
py-company-pycomplete-p
-----------------------
Load company-pycomplete stuff. Default is nil
py-auto-complete-p
------------------
Run python-mode’s built-in auto-completion via py-complete-function. Default is nil
py-tab-shifts-region-p
----------------------
If ‘t’, TAB will indent/cycle the region, not just the current line.
Default is nil
See also ‘py-tab-indents-region-p’
py-tab-indents-region-p
-----------------------
When ‘t’ and first TAB doesn’t shift, indent-region is called.
Default is nil
See also ‘py-tab-shifts-region-p’
py-block-comment-prefix-p
-------------------------
If py-comment inserts py-block-comment-prefix.
Default is t
py-org-cycle-p
--------------
When non-nil, command ‘org-cycle’ is available at shift-TAB,
Default is nil.
py-set-complete-keymap-p
------------------------
If ‘py-complete-initialize’, which sets up enviroment for Pymacs based py-complete, should load it’s keys into ‘python-mode-map’
Default is nil.
See also resp. edit ‘py-complete-set-keymap’
py-outline-minor-mode-p
-----------------------
If outline minor-mode should be on, default is ‘t’.
py-guess-py-install-directory-p
-------------------------------
If in cases, ‘py-install-directory’ isn’t set, ‘py-set-load-path’should guess it from ‘buffer-file-name’.
py-load-pymacs-p
----------------
If Pymacs related stuff should be loaded.
Default is nil.
Pymacs has been written by François Pinard and many others.
See original source: http://pymacs.progiciels-bpi.ca
py-verbose-p
------------
If functions should report results.
Default is nil.
py-sexp-function
----------------
When set, it’s value is called instead of ‘forward-sexp’, ‘backward-sexp’
Default is nil.
py-close-provides-newline
-------------------------
If a newline is inserted, when line after block isn’t empty. Default is non-nil.
When non-nil, ‘py-end-of-def’ and related will work faster
py-dedent-keep-relative-column
------------------------------
If point should follow dedent or kind of electric move to end of line. Default is t - keep relative position.
py-indent-honors-multiline-listing
----------------------------------
If ‘t’, indents to 1+ column of opening delimiter. If ‘nil’, indent adds one level to the beginning of statement. Default is ‘nil’.
py-indent-paren-spanned-multilines-p
------------------------------------
If non-nil, indents elements of list a value of ‘py-indent-offset’ to first element:
def foo():
if (foo &&
baz):
bar()
Default lines up with first element:
def foo():
if (foo &&
baz):
bar()
Default is ‘t’
py-closing-list-dedents-bos
---------------------------
When non-nil, indent list’s closing delimiter like start-column.
It will be lined up under the first character of
the line that starts the multi-line construct, as in:
my_list = [
1, 2, 3,
4, 5, 6,
]
result = some_function_that_takes_arguments(
’a’, ’b’, ’c’,
’d’, ’e’, ’f’,
)
Default is nil, i.e.
my_list = [
1, 2, 3,
4, 5, 6,
]
result = some_function_that_takes_arguments(
’a’, ’b’, ’c’,
’d’, ’e’, ’f’,
)
Examples from PEP8
py-imenu-max-items
------------------
Python-mode specific ‘imenu-max-items’
py-closing-list-space
---------------------
Number of chars, closing parenthesis outdent from opening, default is 1
py-max-specpdl-size
-------------------
Heuristic exit. Limiting number of recursive calls by py-forward-statement and related functions. Default is max-specpdl-size.
This threshold is just an approximation. It might set far higher maybe.
See lp:1235375. In case code is not to navigate due to errors, ‘which-function-mode’ and others might make Emacs hang. Rather exit than.
py-closing-list-keeps-space
---------------------------
If non-nil, closing parenthesis dedents onto column of opening plus ‘py-closing-list-space’, default is nil
py-electric-kill-backward-p
---------------------------
Affects ‘py-electric-backspace’. Default is nil.
If behind a delimited form of braces, brackets or parentheses,
backspace will kill it’s contents
With when cursor after
my_string[0:1]
--------------^
==>
my_string[]
----------^
In result cursor is insided emptied delimited form.
py-electric-colon-active-p
--------------------------
‘py-electric-colon’ feature. Default is ‘nil’. See lp:837065 for discussions.
See also ‘py-electric-colon-bobl-only’
py-electric-colon-bobl-only
---------------------------
When inserting a colon, do not indent lines unless at beginning of block
See lp:1207405 resp. ‘py-electric-colon-active-p’
py-electric-yank-active-p
-------------------------
When non-nil, ‘yank’ will be followed by an ‘indent-according-to-mode’.
Default is nil
py-electric-colon-greedy-p
--------------------------
If py-electric-colon should indent to the outmost reasonable level.
If nil, default, it will not move from at any reasonable level.
py-electric-colon-newline-and-indent-p
--------------------------------------
If non-nil, ‘py-electric-colon’ will call ‘newline-and-indent’. Default is ‘nil’.
py-electric-comment-p
---------------------
If "#" should call ‘py-electric-comment’. Default is ‘nil’.
py-electric-comment-add-space-p
-------------------------------
If py-electric-comment should add a space. Default is ‘nil’.
py-mark-decorators
------------------
If py-mark-def-or-class functions should mark decorators too. Default is ‘nil’.
py-defun-use-top-level-p
------------------------
When non-nil, keys C-M-a, C-M-e address top-level form.
Default is nil.
Beginning- end-of-defun forms use
commands ‘py-beginning-of-top-level’, ‘py-end-of-top-level’
mark-defun marks top-level form at point etc.
py-tab-indent
-------------
Non-nil means TAB in Python mode calls ‘py-indent-line’.
py-return-key
-------------
Which command should call.
py-complete-function
--------------------
When set, enforces function todo completion, default is ‘py-fast-complete’.
Might not affect IPython, as ‘py-shell-complete’ is the only known working here.
Normally python-mode knows best which function to use.
py-encoding-string
------------------
Default string specifying encoding of a Python file.
py-shebang-startstring
----------------------
Detecting the shell in head of file.
py-flake8-command
-----------------
Which command to call flake8.
If empty, python-mode will guess some
py-flake8-command-args
----------------------
Arguments used by flake8.
Default is the empty string.
py-message-executing-temporary-file
-----------------------------------
If execute functions using a temporary file should message it. Default is ‘t’.
Messaging increments the prompt counter of IPython shell.
py-execute-no-temp-p
--------------------
Seems Emacs-24.3 provided a way executing stuff without temporary files.
py-lhs-inbound-indent
---------------------
When line starts a multiline-assignment: How many colums indent should be more than opening bracket, brace or parenthesis.
py-continuation-offset
----------------------
Additional amount of offset to give for some continuation lines.
Continuation lines are those that immediately follow a backslash
terminated line.
py-indent-tabs-mode
-------------------
Python-mode starts ‘indent-tabs-mode’ with the value specified here, default is nil.
py-smart-indentation
--------------------
Should ‘python-mode’ try to automagically set some indentation variables?
When this variable is non-nil, two things happen when a buffer is set
to ‘python-mode’:
1. ‘py-indent-offset’ is guessed from existing code in the buffer.
Only guessed values between 2 and 8 are considered. If a valid
guess can’t be made (perhaps because you are visiting a new
file), then the value in ‘py-indent-offset’ is used.
2. ‘tab-width’ is setq to ‘py-indent-offset’ if not equal
already. ‘indent-tabs-mode’ inserts one tab one
indentation level, otherwise spaces are used.
Note that both these settings occur *after* ‘python-mode-hook’ is run,
so if you want to defeat the automagic configuration, you must also
set ‘py-smart-indentation’ to nil in your ‘python-mode-hook’.
py-block-comment-prefix
-----------------------
String used by M-x comment-region to comment out a block of code.
This should follow the convention for non-indenting comment lines so
that the indentation commands won’t get confused (i.e., the string
should be of the form ‘#x...’ where ‘x’ is not a blank or a tab, and
‘...’ is arbitrary). However, this string should not end in whitespace.
py-indent-offset
----------------
Amount of offset per level of indentation.
‘M-x py-guess-indent-offset’ can usually guess a good value when
you’re editing someone else’s Python code.
py-backslashed-lines-indent-offset
----------------------------------
Amount of offset per level of indentation of backslashed.
No semantic indent, which diff to ‘py-indent-offset’ indicates
py-pdb-path
-----------
Where to find pdb.py. Edit this according to your system.
If you ignore the location ‘M-x py-guess-pdb-path’ might display it.
py-indent-comments
------------------
When t, comment lines are indented.
py-uncomment-indents-p
----------------------
When non-nil, after uncomment indent lines.
py-separator-char
-----------------
Values set by defcustom only will not be seen in batch-mode.
py-custom-temp-directory
------------------------
If set, will take precedence over guessed values from ‘py-temp-directory’. Default is the empty string.
py-beep-if-tab-change
---------------------
Ring the bell if ‘tab-width’ is changed.
If a comment of the form
# vi:set tabsize=:
is found before the first code line when the file is entered, and the
current value of (the general Emacs variable) ‘tab-width’ does not
equal , ‘tab-width’ is set to , a message saying so is
displayed in the echo area, and if ‘py-beep-if-tab-change’ is non-nil
the Emacs bell is also rung as a warning.
py-jump-on-exception
--------------------
Jump to innermost exception frame in Python output buffer.
When this variable is non-nil and an exception occurs when running
Python code synchronously in a subprocess, jump immediately to the
source code of the innermost traceback frame.
py-ask-about-save
-----------------
If not nil, ask about which buffers to save before executing some code.
Otherwise, all modified buffers are saved without asking.
py-delete-function
------------------
Function called by ‘py-electric-delete’ when deleting forwards.
py-pdbtrack-do-tracking-p
-------------------------
Controls whether the pdbtrack feature is enabled or not.
When non-nil, pdbtrack is enabled in all comint-based buffers,
e.g. shell buffers and the *Python* buffer. When using pdb to debug a
Python program, pdbtrack notices the pdb prompt and displays the
source file and line that the program is stopped at, much the same way
as gud-mode does for debugging C programs with gdb.
py-pdbtrack-filename-mapping
----------------------------
Supports mapping file paths when opening file buffers in pdbtrack.
When non-nil this is an alist mapping paths in the Python interpreter
to paths in Emacs.
py-pdbtrack-minor-mode-string
-----------------------------
String to use in the minor mode list when pdbtrack is enabled.
py-import-check-point-max
-------------------------
Maximum number of characters to search for a Java-ish import statement.
When ‘python-mode’ tries to calculate the shell to use (either a
CPython or a Jython shell), it looks at the so-called ‘shebang’ line
-- i.e. #! line. If that’s not available, it looks at some of the
file heading imports to see if they look Java-like.
py-jython-packages
------------------
Imported packages that imply ‘jython-mode’.
py-current-defun-show
---------------------
If ‘py-current-defun’ should jump to the definition, highlight it while waiting PY-WHICH-FUNC-DELAY seconds, before returning to previous position.
Default is ‘t’.
py-current-defun-delay
----------------------
When called interactively, ‘py-current-defun’ should wait PY-WHICH-FUNC-DELAY seconds at the definition name found, before returning to previous position.
py--delete-temp-file-delay
--------------------------
Used by ‘py--delete-temp-file’
py-python-send-delay
--------------------
Seconds to wait for output, used by ‘py--send-...’ functions.
See also py-ipython-send-delay
py-ipython-send-delay
---------------------
Seconds to wait for output, used by ‘py--send-...’ functions.
See also py-python-send-delay
py-master-file
--------------
If non-nil, M-x py-execute-buffer executes the named
master file instead of the buffer’s file. If the file name has a
relative path, the value of variable ‘default-directory’ for the
buffer is prepended to come up with a file name.
Beside you may set this variable in the file’s local
variable section, e.g.:
# Local Variables:
# py-master-file: "master.py"
# End:
py-pychecker-command
--------------------
Shell command used to run Pychecker.
py-pychecker-command-args
-------------------------
String arguments to be passed to pychecker.
py-pyflakes-command
-------------------
Shell command used to run Pyflakes.
py-pyflakes-command-args
------------------------
String arguments to be passed to pyflakes.
Default is ""
py-pep8-command
---------------
Shell command used to run pep8.
py-pep8-command-args
--------------------
String arguments to be passed to pylint.
Default is ""
py-pyflakespep8-command
-----------------------
Shell command used to run ‘pyflakespep8’.
py-pyflakespep8-command-args
----------------------------
string arguments to be passed to pyflakespep8.
Default is ""
py-pylint-command
-----------------
Shell command used to run Pylint.
py-pylint-command-args
----------------------
String arguments to be passed to pylint.
Default is "--errors-only"
py-shell-input-prompt-1-regexp
------------------------------
A regular expression to match the input prompt of the shell.
py-shell-input-prompt-2-regexp
------------------------------
A regular expression to match the input prompt of the shell after the
first line of input.
py-shell-prompt-read-only
-------------------------
If non-nil, the python prompt is read only. Setting this
variable will only effect new shells.
py-honor-IPYTHONDIR-p
---------------------
When non-nil ipython-history file is constructed by $IPYTHONDIR
followed by "/history". Default is nil.
Otherwise value of py-ipython-history is used.
py-ipython-history
------------------
ipython-history default file. Used when py-honor-IPYTHONDIR-p is nil (default)
py-honor-PYTHONHISTORY-p
------------------------
When non-nil python-history file is set by $PYTHONHISTORY
Default is nil.
Otherwise value of py-python-history is used.
py-python-history
-----------------
python-history default file. Used when py-honor-PYTHONHISTORY-p is nil (default)
py-switch-buffers-on-execute-p
------------------------------
When non-nil switch to the Python output buffer.
If ‘py-keep-windows-configuration’ is t, this will take precedence over setting here.
py-split-window-on-execute
--------------------------
When non-nil split windows.
Default is just-two - when code is send to interpreter, split screen into source-code buffer and current py-shell result.
Other buffer will be hidden that way.
When set to ‘t’, python-mode tries to reuse existing windows and will split only if needed.
With ’always, results will displayed in a new window.
Both ‘t’ and ‘always’ is experimental still.
For the moment: If a multitude of python-shells/buffers should be
visible, open them manually and set ‘py-keep-windows-configuration’ to ‘t’.
See also ‘py-keep-windows-configuration’
py-split-window-on-execute-threshold
------------------------------------
Maximal number of displayed windows.
Honored, when ‘py-split-window-on-execute’ is ‘t’, i.e. "reuse".
Don’t split when max number of displayed windows is reached.
py-split-windows-on-execute-function
------------------------------------
How window should get splitted to display results of py-execute-... functions.
py-shell-fontify-style
----------------------
Fontify current input resp. output in Python shell. Default is nil.
INPUT will leave output unfontified.
ALL keeps output fontified.
At any case only current input gets fontified.
py-hide-show-keywords
---------------------
Keywords composing visible heads.
py-hide-show-hide-docstrings
----------------------------
Controls if doc strings can be hidden by hide-show
py-hide-comments-when-hiding-all
--------------------------------
Hide the comments too when you do an ‘hs-hide-all’.
py-outline-mode-keywords
------------------------
Keywords composing visible heads.
python-mode-hook
----------------
Hook run after entering python-mode-modeline-display mode.
No problems result if this variable is not bound.
‘add-hook’ automatically binds it. (This is true for all hook variables.)
py-shell-name
-------------
A PATH/TO/EXECUTABLE or default value ‘py-shell’ may look for, if no shell is specified by command.
On Windows default is C:/Python27/python
--there is no garantee it exists, please check your system--
Else python
py-python-command
-----------------
Make sure, the directory where python.exe resides in in the PATH-variable.
Windows: If needed, edit in "Advanced System Settings/Environment Variables" Commonly "C:\\Python27\\python.exe"
With Anaconda for example the following works here:
"C:\\Users\\My-User-Name\\Anaconda\\Scripts\\python.exe"
Else /usr/bin/python
py-python-command-args
----------------------
String arguments to be used when starting a Python shell.
py-python2-command
------------------
Make sure, the directory where python.exe resides in in the PATH-variable.
Windows: If needed, edit in "Advanced System Settings/Environment Variables" Commonly "C:\\Python27\\python.exe"
With Anaconda for example the following works here:
"C:\\Users\\My-User-Name\\Anaconda\\Scripts\\python.exe"
Else /usr/bin/python
py-python2-command-args
-----------------------
String arguments to be used when starting a Python shell.
py-python3-command
------------------
A PATH/TO/EXECUTABLE or default value ‘py-shell’ may look for, if
no shell is specified by command.
On Windows see C:/Python3/python.exe
--there is no garantee it exists, please check your system--
At GNU systems see /usr/bin/python3
py-python3-command-args
-----------------------
String arguments to be used when starting a Python3 shell.
py-ipython-command
------------------
A PATH/TO/EXECUTABLE or default value ‘M-x IPython RET’ may look for, if no IPython-shell is specified by command.
On Windows default is "C:\\Python27\\python.exe"
While with Anaconda for example the following works here:
"C:\\Users\\My-User-Name\\Anaconda\\Scripts\\ipython.exe"
Else /usr/bin/ipython
py-ipython-command-args
-----------------------
String arguments to be used when starting a Python shell.
At Windows make sure ipython-script.py is PATH. Also setting PATH/TO/SCRIPT here should work, for example;
C:\Python27\Scripts\ipython-script.py
With Anaconda the following is known to work:
"C:\\Users\\My-User-Name\\Anaconda\\Scripts\\ipython-script-py"
py-jython-command
-----------------
A PATH/TO/EXECUTABLE or default value ‘M-x Jython RET’ may look for, if no Jython-shell is specified by command.
Not known to work at windows
Default /usr/bin/jython
py-jython-command-args
----------------------
String arguments to be used when starting a Python shell.
py-shell-toggle-1
-----------------
A PATH/TO/EXECUTABLE or default value used by ‘py-toggle-shell’.
py-shell-toggle-2
-----------------
A PATH/TO/EXECUTABLE or default value used by ‘py-toggle-shell’.
py--imenu-create-index-p
------------------------
Non-nil means Python mode creates and displays an index menu of functions and global variables.
py-match-paren-mode
-------------------
Non-nil means, cursor will jump to beginning or end of a block.
This vice versa, to beginning first.
Sets ‘py-match-paren-key’ in python-mode-map.
Customize ‘py-match-paren-key’ which key to use.
py-match-paren-key
------------------
String used by M-x comment-region to comment out a block of code.
This should follow the convention for non-indenting comment lines so
that the indentation commands won’t get confused (i.e., the string
should be of the form ‘#x...’ where ‘x’ is not a blank or a tab, and
‘...’ is arbitrary). However, this string should not end in whitespace.
py-kill-empty-line
------------------
If t, py-indent-forward-line kills empty lines.
py-imenu-show-method-args-p
---------------------------
Controls echoing of arguments of functions & methods in the Imenu buffer.
When non-nil, arguments are printed.
py-use-local-default
--------------------
If ‘t’, py-shell will use ‘py-shell-local-path’ instead
of default Python.
Making switch between several virtualenv’s easier,
‘python-mode’ should deliver an installer, so named-shells pointing to virtualenv’s will be available.
py-edit-only-p
--------------
When ‘t’ ‘python-mode’ will not take resort nor check for installed Python executables. Default is nil.
See bug report at launchpad, lp:944093.
py-force-py-shell-name-p
------------------------
When ‘t’, execution with kind of Python specified in ‘py-shell-name’ is enforced, possibly shebang doesn’t take precedence.
python-mode-v5-behavior-p
-------------------------
Execute region through ‘shell-command-on-region’ as
v5 did it - lp:990079. This might fail with certain chars - see UnicodeEncodeError lp:550661
py-trailing-whitespace-smart-delete-p
-------------------------------------
Default is nil. When t, python-mode calls
(add-hook ’before-save-hook ’delete-trailing-whitespace nil ’local)
Also commands may delete trailing whitespace by the way.
When editing other peoples code, this may produce a larger diff than expected
py-newline-delete-trailing-whitespace-p
---------------------------------------
Delete trailing whitespace maybe left by ‘py-newline-and-indent’.
Default is ‘t’. See lp:1100892
py--warn-tmp-files-left-p
-------------------------
Messages a warning, when ‘py-temp-directory’ contains files susceptible being left by previous Python-mode sessions. See also lp:987534
py-complete-ac-sources
----------------------
List of auto-complete sources assigned to ‘ac-sources’ in ‘py-complete-initialize’.
Default is known to work an Ubuntu 14.10 - having python-
mode, pymacs and auto-complete-el, with the following minimal
emacs initialization:
(require ’pymacs)
(require ’auto-complete-config)
(ac-config-default)
py-remove-cwd-from-path
-----------------------
Whether to allow loading of Python modules from the current directory.
If this is non-nil, Emacs removes ’’ from sys.path when starting
a Python process. This is the default, for security
reasons, as it is easy for the Python process to be started
without the user’s realization (e.g. to perform completion).
py-shell-local-path
-------------------
If ‘py-use-local-default’ is non-nil, ‘py-shell’ will use EXECUTABLE indicated here incl. path.
py-python-edit-version
----------------------
When not empty, fontify according to Python version specified.
Default is the empty string, a useful value "python3" maybe.
When empty, version is guessed via ‘py-choose-shell’.
py-ipython-execute-delay
------------------------
Delay needed by execute functions when no IPython shell is running.
py--imenu-create-index-function
-------------------------------
Switch between ‘py--imenu-create-index-new’, which also lists modules variables, and series 5. index-machine
py-docstring-style
------------------
Implemented styles are DJANGO, ONETWO, PEP-257, PEP-257-NN,
SYMMETRIC, and NIL.
A value of NIL won’t care about quotes
position and will treat docstrings a normal string, any other
value may result in one of the following docstring styles:
DJANGO:
"""
Process foo, return bar.
"""
"""
Process foo, return bar.
If processing fails throw ProcessingError.
"""
ONETWO:
"""Process foo, return bar."""
"""
Process foo, return bar.
If processing fails throw ProcessingError.
"""
PEP-257:
"""Process foo, return bar."""
"""Process foo, return bar.
If processing fails throw ProcessingError.
"""
PEP-257-NN:
"""Process foo, return bar."""
"""Process foo, return bar.
If processing fails throw ProcessingError.
"""
SYMMETRIC:
"""Process foo, return bar."""
"""
Process foo, return bar.
If processing fails throw ProcessingError.
"""
py-execute-directory
--------------------
When set, stores the file’s default directory-name py-execute-... functions act upon.
Used by Python-shell for output of ‘py-execute-buffer’ and related commands. See also ‘py-use-current-dir-when-execute-p’
py-use-current-dir-when-execute-p
---------------------------------
When ‘t’, current directory is used by Python-shell for output of ‘py-execute-buffer’ and related commands.
See also ‘py-execute-directory’
py-keep-shell-dir-when-execute-p
--------------------------------
Don’t change Python shell’s current working directory when sending code.
See also ‘py-execute-directory’
py-fileless-buffer-use-default-directory-p
------------------------------------------
When ‘py-use-current-dir-when-execute-p’ is non-nil and no buffer-file exists, value of ‘default-directory’ sets current working directory of Python output shell
py-check-command
----------------
Command used to check a Python file.
py-ffap-p
---------
Select python-modes way to find file at point.
Default is nil
py-keep-windows-configuration
-----------------------------
Takes precedence over ‘py-split-window-on-execute’ and ‘py-switch-buffers-on-execute-p’.
See lp:1239498
To suppres window-changes due to error-signaling also, set ‘py-keep-windows-configuration’ onto ’force
Default is nil
py-shell-prompt-regexp
----------------------
Regular Expression matching top-level input prompt of python shell.
It should not contain a caret (^) at the beginning.
py-shell-prompt-output-regexp
-----------------------------
Regular Expression matching output prompt of python shell.
It should not contain a caret (^) at the beginning.
py-debug-p
----------
When non-nil, keep resp. store information useful for debugging.
Temporary files are not deleted. Other functions might implement
some logging etc.
py-section-start
----------------
Delimit arbitrary chunks of code.
py-section-end
--------------
Delimit arbitrary chunks of code.
py-paragraph-re
---------------
Allow Python specific paragraph-start var
py-outdent-re-raw
-----------------
py-no-outdent-re-raw
--------------------
py-block-or-clause-re-raw
-------------------------
Matches the beginning of a compound statement or it’s clause.
py-block-re-raw
---------------
Matches the beginning of a compound statement but not it’s clause.
py-extended-block-or-clause-re-raw
----------------------------------
Matches the beginning of a compound statement or it’s clause.
py-top-level-re
---------------
A form which starts at zero indent level, but is not a comment.
py-clause-re-raw
----------------
Matches the beginning of a clause.
py-compilation-regexp-alist
---------------------------
Fetch errors from Py-shell.
hooked into ‘compilation-error-regexp-alist’
py-shell-unfontify-p
--------------------
Run ‘py--run-unfontify-timer’ unfontifying the shell banner-text.
Default is nil
py-underscore-word-syntax-p
---------------------------
If underscore chars should be of syntax-class ‘word’, not of ‘symbol’.
Underscores in word-class makes ‘forward-word’ etc. travel the indentifiers. Default is ‘t’.
See bug report at launchpad, lp:940812
python-mode.el-6.2.3/doc/variables-python-mode.org 0000644 0000000 0000000 00000077147 13037357637 022047 0 ustar root root 0000000 0000000 python-mode.el variables
** py-install-directory
Directory where python-mode.el and it’s subdirectories should be installed. Needed for completion and other environment stuff only.
** py-pythonpath
Define $PYTHONPATH here, if needed.
Emacs doesn’t read .bashrc
** python-mode-modeline-display
String to display in Emacs modeline
** py-extensions
File where extensions to python-mode.el should be installed. Used by virtualenv support.
** info-lookup-mode
Which Python documentation should be queried.
Make sure it’s accessible from Emacs by M-x info RET ...
See INSTALL-INFO-FILES for help.
** py-fast-process-p
Use ‘py-fast-process’.
Commands prefixed "py-fast-..." suitable for large output
See: large output makes Emacs freeze, lp:1253907
Results arrive in output buffer, which is not in comint-mode
** py-comment-auto-fill-p
When non-nil, fill comments.
Defaut is nil
** py-sexp-use-expression-p
If non-nil, C-M-s call py-forward-expression.
Respective C-M-b will call py-backward-expression
Default is t
** py-session-p
If commands would use an existing process.
If nil, a maybe existing process at py-buffer-name would be killed and re-started
See also ‘py-dedicated-process-p’
** py-max-help-buffer-p
If "*Python-Help*"-buffer should appear as the only visible.
Default is nil. In help-buffer, "q" will close it.
** py-highlight-error-source-p
When py-execute-... commands raise an error, respective code in source-buffer will be highlighted. Default is nil.
M-x ‘py-remove-overlays-at-point’ removes that highlighting.
** py-set-pager-cat-p
If the shell environment variable $PAGER should set to ‘cat’.
If ‘t’, use ‘C-c C-r’ to jump to beginning of output. Then scroll normally.
Avoids lp:783828, "Terminal not fully functional", for help(’COMMAND’) in python-shell
When non-nil, imports module ‘os’
** py-empty-line-closes-p
When non-nil, dedent after empty line following block
if True:
print("Part of the if-statement")
print("Not part of the if-statement")
Default is nil
If non-nil, a C-j from empty line dedents.
** py-prompt-on-changed-p
When called interactively, ask for save before a changed buffer is sent to interpreter.
Default is ‘t’
** py-dedicated-process-p
If commands executing code use a dedicated shell.
Default is nil
When non-nil and ‘py-session-p’, an existing dedicated process is re-used instead of default - which allows executing stuff in parallel.
** py-store-result-p
When non-nil, put resulting string of ‘py-execute-...’ into kill-ring, so it might be yanked.
Default is nil
** py--execute-use-temp-file-p
Assume execution at a remote machine.
where write-access is not given.
** py-electric-close-active-p
Close completion buffer when it’s sure, it’s no longer needed, i.e. when inserting a space.
Works around a bug in ‘choose-completion’.
Default is ‘nil’
** py-update-gud-pdb-history-p
If pdb should provide suggestions WRT file to check and py-pdb-path.
Default is t
See lp:963253
** py-pdb-executable
Indicate PATH/TO/pdb.
Default is nil
See lp:963253
** py-hide-show-minor-mode-p
If hide-show minor-mode should be on, default is nil.
** py-load-skeletons-p
If skeleton definitions should be loaded, default is nil.
If non-nil and abbrev-mode on, block-skeletons will inserted.
Pressing "if" for example will prompt for the if-condition.
** py-if-name-main-permission-p
Allow execution of code inside blocks started
by "if __name__== ’__main__’:".
Default is non-nil
** py-use-font-lock-doc-face-p
If documention string inside of def or class get ‘font-lock-doc-face’.
‘font-lock-doc-face’ inherits ‘font-lock-string-face’.
Call M-x ‘customize-face’ in order to have a visible effect.
** py-empty-comment-line-separates-paragraph-p
Consider paragraph start/end lines with nothing inside but comment sign.
Default is non-nil
** py-indent-honors-inline-comment
If non-nil, indents to column of inlined comment start.
Default is nil.
** py-auto-fill-mode
If python-mode should set fill-column
according values in ‘py-comment-fill-column’ and ‘py-docstring-fill-column’.
Default is nil
** py-error-markup-delay
Seconds error’s are highlighted in exception buffer.
** py-fast-completion-delay
Used by py--fast-send-string-intern.
** py-new-shell-delay
If a new comint buffer is connected to Python, commands like completion might need some delay.
** py-autofill-timer-delay
Delay when idle before functions ajusting ‘py-docstring-fill-column’ resp. ‘py-comment-fill-column’ are called.
** py-docstring-fill-column
Value of ‘fill-column’ to use when filling a docstring.
Any non-integer value means do not use a different value of
‘fill-column’ when filling docstrings.
** py-comment-fill-column
Value of ‘fill-column’ to use when filling a comment.
Any non-integer value means do not use a different value of
‘fill-column’ when filling docstrings.
** py-fontify-shell-buffer-p
If code in Python shell should be highlighted as in script buffer.
Default is nil.
If ‘t’, related vars like ‘comment-start’ will be set too.
Seems convenient when playing with stuff in IPython shell
Might not be TRT when a lot of output arrives
** py-modeline-display-full-path-p
If the full PATH/TO/PYTHON should be displayed in shell modeline.
Default is nil. Note: when ‘py-shell-name’ is specified with path, it’s shown as an acronym in buffer-name already.
** py-modeline-acronym-display-home-p
If the modeline acronym should contain chars indicating the home-directory.
Default is nil
** py-timer-close-completions-p
If ‘py-timer-close-completion-buffer’ should run, default is non-nil.
** py-smart-operator-mode-p
If python-mode calls ‘smart-operator-mode-on’
Default is nil.
** py-autopair-mode
If python-mode calls (autopair-mode-on)
Default is nil
Load ‘autopair-mode’ written by Joao Tavora
URL: http://autopair.googlecode.com
** py-indent-no-completion-p
If completion function should insert a TAB when no completion found.
Default is ‘nil’
** py-company-pycomplete-p
Load company-pycomplete stuff. Default is nil
** py-auto-complete-p
Run python-mode’s built-in auto-completion via py-complete-function. Default is nil
** py-tab-shifts-region-p
If ‘t’, TAB will indent/cycle the region, not just the current line.
Default is nil
See also ‘py-tab-indents-region-p’
** py-tab-indents-region-p
When ‘t’ and first TAB doesn’t shift, indent-region is called.
Default is nil
See also ‘py-tab-shifts-region-p’
** py-block-comment-prefix-p
If py-comment inserts py-block-comment-prefix.
Default is t
** py-org-cycle-p
When non-nil, command ‘org-cycle’ is available at shift-TAB,
Default is nil.
** py-set-complete-keymap-p
If ‘py-complete-initialize’, which sets up enviroment for Pymacs based py-complete, should load it’s keys into ‘python-mode-map’
Default is nil.
See also resp. edit ‘py-complete-set-keymap’
** py-outline-minor-mode-p
If outline minor-mode should be on, default is ‘t’.
** py-guess-py-install-directory-p
If in cases, ‘py-install-directory’ isn’t set, ‘py-set-load-path’should guess it from ‘buffer-file-name’.
** py-load-pymacs-p
If Pymacs related stuff should be loaded.
Default is nil.
Pymacs has been written by François Pinard and many others.
See original source: http://pymacs.progiciels-bpi.ca
** py-verbose-p
If functions should report results.
Default is nil.
** py-sexp-function
When set, it’s value is called instead of ‘forward-sexp’, ‘backward-sexp’
Default is nil.
** py-close-provides-newline
If a newline is inserted, when line after block isn’t empty. Default is non-nil.
When non-nil, ‘py-end-of-def’ and related will work faster
** py-dedent-keep-relative-column
If point should follow dedent or kind of electric move to end of line. Default is t - keep relative position.
** py-indent-honors-multiline-listing
If ‘t’, indents to 1+ column of opening delimiter. If ‘nil’, indent adds one level to the beginning of statement. Default is ‘nil’.
** py-indent-paren-spanned-multilines-p
If non-nil, indents elements of list a value of ‘py-indent-offset’ to first element:
def foo():
if (foo &&
baz):
bar()
Default lines up with first element:
def foo():
if (foo &&
baz):
bar()
Default is ‘t’
** py-closing-list-dedents-bos
When non-nil, indent list’s closing delimiter like start-column.
It will be lined up under the first character of
the line that starts the multi-line construct, as in:
my_list = [
1, 2, 3,
4, 5, 6,
]
result = some_function_that_takes_arguments(
’a’, ’b’, ’c’,
’d’, ’e’, ’f’,
)
Default is nil, i.e.
my_list = [
1, 2, 3,
4, 5, 6,
]
result = some_function_that_takes_arguments(
’a’, ’b’, ’c’,
’d’, ’e’, ’f’,
)
Examples from PEP8
** py-imenu-max-items
Python-mode specific ‘imenu-max-items’
** py-closing-list-space
Number of chars, closing parenthesis outdent from opening, default is 1
** py-max-specpdl-size
Heuristic exit. Limiting number of recursive calls by py-forward-statement and related functions. Default is max-specpdl-size.
This threshold is just an approximation. It might set far higher maybe.
See lp:1235375. In case code is not to navigate due to errors, ‘which-function-mode’ and others might make Emacs hang. Rather exit than.
** py-closing-list-keeps-space
If non-nil, closing parenthesis dedents onto column of opening plus ‘py-closing-list-space’, default is nil
** py-electric-kill-backward-p
Affects ‘py-electric-backspace’. Default is nil.
If behind a delimited form of braces, brackets or parentheses,
backspace will kill it’s contents
With when cursor after
my_string[0:1]
--------------^
==>
my_string[]
----------^
In result cursor is insided emptied delimited form.
** py-electric-colon-active-p
‘py-electric-colon’ feature. Default is ‘nil’. See lp:837065 for discussions.
See also ‘py-electric-colon-bobl-only’
** py-electric-colon-bobl-only
When inserting a colon, do not indent lines unless at beginning of block
See lp:1207405 resp. ‘py-electric-colon-active-p’
** py-electric-yank-active-p
When non-nil, ‘yank’ will be followed by an ‘indent-according-to-mode’.
Default is nil
** py-electric-colon-greedy-p
If py-electric-colon should indent to the outmost reasonable level.
If nil, default, it will not move from at any reasonable level.
** py-electric-colon-newline-and-indent-p
If non-nil, ‘py-electric-colon’ will call ‘newline-and-indent’. Default is ‘nil’.
** py-electric-comment-p
If "#" should call ‘py-electric-comment’. Default is ‘nil’.
** py-electric-comment-add-space-p
If py-electric-comment should add a space. Default is ‘nil’.
** py-mark-decorators
If py-mark-def-or-class functions should mark decorators too. Default is ‘nil’.
** py-defun-use-top-level-p
When non-nil, keys C-M-a, C-M-e address top-level form.
Default is nil.
Beginning- end-of-defun forms use
commands ‘py-beginning-of-top-level’, ‘py-end-of-top-level’
mark-defun marks top-level form at point etc.
** py-tab-indent
Non-nil means TAB in Python mode calls ‘py-indent-line’.
** py-return-key
Which command should call.
** py-complete-function
When set, enforces function todo completion, default is ‘py-fast-complete’.
Might not affect IPython, as ‘py-shell-complete’ is the only known working here.
Normally python-mode knows best which function to use.
** py-encoding-string
Default string specifying encoding of a Python file.
** py-shebang-startstring
Detecting the shell in head of file.
** py-flake8-command
Which command to call flake8.
If empty, python-mode will guess some
** py-flake8-command-args
Arguments used by flake8.
Default is the empty string.
** py-message-executing-temporary-file
If execute functions using a temporary file should message it. Default is ‘t’.
Messaging increments the prompt counter of IPython shell.
** py-execute-no-temp-p
Seems Emacs-24.3 provided a way executing stuff without temporary files.
** py-lhs-inbound-indent
When line starts a multiline-assignment: How many colums indent should be more than opening bracket, brace or parenthesis.
** py-continuation-offset
Additional amount of offset to give for some continuation lines.
Continuation lines are those that immediately follow a backslash
terminated line.
** py-indent-tabs-mode
Python-mode starts ‘indent-tabs-mode’ with the value specified here, default is nil.
** py-smart-indentation
Should ‘python-mode’ try to automagically set some indentation variables?
When this variable is non-nil, two things happen when a buffer is set
to ‘python-mode’:
1. ‘py-indent-offset’ is guessed from existing code in the buffer.
Only guessed values between 2 and 8 are considered. If a valid
guess can’t be made (perhaps because you are visiting a new
file), then the value in ‘py-indent-offset’ is used.
2. ‘tab-width’ is setq to ‘py-indent-offset’ if not equal
already. ‘indent-tabs-mode’ inserts one tab one
indentation level, otherwise spaces are used.
Note that both these settings occur *after* ‘python-mode-hook’ is run,
so if you want to defeat the automagic configuration, you must also
set ‘py-smart-indentation’ to nil in your ‘python-mode-hook’.
** py-block-comment-prefix
String used by M-x comment-region to comment out a block of code.
This should follow the convention for non-indenting comment lines so
that the indentation commands won’t get confused (i.e., the string
should be of the form ‘#x...’ where ‘x’ is not a blank or a tab, and
‘...’ is arbitrary). However, this string should not end in whitespace.
** py-indent-offset
Amount of offset per level of indentation.
‘M-x py-guess-indent-offset’ can usually guess a good value when
you’re editing someone else’s Python code.
** py-backslashed-lines-indent-offset
Amount of offset per level of indentation of backslashed.
No semantic indent, which diff to ‘py-indent-offset’ indicates
** py-pdb-path
Where to find pdb.py. Edit this according to your system.
If you ignore the location ‘M-x py-guess-pdb-path’ might display it.
** py-indent-comments
When t, comment lines are indented.
** py-uncomment-indents-p
When non-nil, after uncomment indent lines.
** py-separator-char
Values set by defcustom only will not be seen in batch-mode.
** py-custom-temp-directory
If set, will take precedence over guessed values from ‘py-temp-directory’. Default is the empty string.
** py-beep-if-tab-change
Ring the bell if ‘tab-width’ is changed.
If a comment of the form
# vi:set tabsize=:
is found before the first code line when the file is entered, and the
current value of (the general Emacs variable) ‘tab-width’ does not
equal , ‘tab-width’ is set to , a message saying so is
displayed in the echo area, and if ‘py-beep-if-tab-change’ is non-nil
the Emacs bell is also rung as a warning.
** py-jump-on-exception
Jump to innermost exception frame in Python output buffer.
When this variable is non-nil and an exception occurs when running
Python code synchronously in a subprocess, jump immediately to the
source code of the innermost traceback frame.
** py-ask-about-save
If not nil, ask about which buffers to save before executing some code.
Otherwise, all modified buffers are saved without asking.
** py-delete-function
Function called by ‘py-electric-delete’ when deleting forwards.
** py-pdbtrack-do-tracking-p
Controls whether the pdbtrack feature is enabled or not.
When non-nil, pdbtrack is enabled in all comint-based buffers,
e.g. shell buffers and the *Python* buffer. When using pdb to debug a
Python program, pdbtrack notices the pdb prompt and displays the
source file and line that the program is stopped at, much the same way
as gud-mode does for debugging C programs with gdb.
** py-pdbtrack-filename-mapping
Supports mapping file paths when opening file buffers in pdbtrack.
When non-nil this is an alist mapping paths in the Python interpreter
to paths in Emacs.
** py-pdbtrack-minor-mode-string
String to use in the minor mode list when pdbtrack is enabled.
** py-import-check-point-max
Maximum number of characters to search for a Java-ish import statement.
When ‘python-mode’ tries to calculate the shell to use (either a
CPython or a Jython shell), it looks at the so-called ‘shebang’ line
-- i.e. #! line. If that’s not available, it looks at some of the
file heading imports to see if they look Java-like.
** py-jython-packages
Imported packages that imply ‘jython-mode’.
** py-current-defun-show
If ‘py-current-defun’ should jump to the definition, highlight it while waiting PY-WHICH-FUNC-DELAY seconds, before returning to previous position.
Default is ‘t’.
** py-current-defun-delay
When called interactively, ‘py-current-defun’ should wait PY-WHICH-FUNC-DELAY seconds at the definition name found, before returning to previous position.
** py--delete-temp-file-delay
Used by ‘py--delete-temp-file’
** py-python-send-delay
Seconds to wait for output, used by ‘py--send-...’ functions.
See also py-ipython-send-delay
** py-ipython-send-delay
Seconds to wait for output, used by ‘py--send-...’ functions.
See also py-python-send-delay
** py-master-file
If non-nil, M-x py-execute-buffer executes the named
master file instead of the buffer’s file. If the file name has a
relative path, the value of variable ‘default-directory’ for the
buffer is prepended to come up with a file name.
Beside you may set this variable in the file’s local
variable section, e.g.:
# Local Variables:
# py-master-file: "master.py"
# End:
** py-pychecker-command
Shell command used to run Pychecker.
** py-pychecker-command-args
String arguments to be passed to pychecker.
** py-pyflakes-command
Shell command used to run Pyflakes.
** py-pyflakes-command-args
String arguments to be passed to pyflakes.
Default is ""
** py-pep8-command
Shell command used to run pep8.
** py-pep8-command-args
String arguments to be passed to pylint.
Default is ""
** py-pyflakespep8-command
Shell command used to run ‘pyflakespep8’.
** py-pyflakespep8-command-args
string arguments to be passed to pyflakespep8.
Default is ""
** py-pylint-command
Shell command used to run Pylint.
** py-pylint-command-args
String arguments to be passed to pylint.
Default is "--errors-only"
** py-shell-input-prompt-1-regexp
A regular expression to match the input prompt of the shell.
** py-shell-input-prompt-2-regexp
A regular expression to match the input prompt of the shell after the
first line of input.
** py-shell-prompt-read-only
If non-nil, the python prompt is read only. Setting this
variable will only effect new shells.
** py-honor-IPYTHONDIR-p
When non-nil ipython-history file is constructed by $IPYTHONDIR
followed by "/history". Default is nil.
Otherwise value of py-ipython-history is used.
** py-ipython-history
ipython-history default file. Used when py-honor-IPYTHONDIR-p is nil (default)
** py-honor-PYTHONHISTORY-p
When non-nil python-history file is set by $PYTHONHISTORY
Default is nil.
Otherwise value of py-python-history is used.
** py-python-history
python-history default file. Used when py-honor-PYTHONHISTORY-p is nil (default)
** py-switch-buffers-on-execute-p
When non-nil switch to the Python output buffer.
If ‘py-keep-windows-configuration’ is t, this will take precedence over setting here.
** py-split-window-on-execute
When non-nil split windows.
Default is just-two - when code is send to interpreter, split screen into source-code buffer and current py-shell result.
Other buffer will be hidden that way.
When set to ‘t’, python-mode tries to reuse existing windows and will split only if needed.
With ’always, results will displayed in a new window.
Both ‘t’ and ‘always’ is experimental still.
For the moment: If a multitude of python-shells/buffers should be
visible, open them manually and set ‘py-keep-windows-configuration’ to ‘t’.
See also ‘py-keep-windows-configuration’
** py-split-window-on-execute-threshold
Maximal number of displayed windows.
Honored, when ‘py-split-window-on-execute’ is ‘t’, i.e. "reuse".
Don’t split when max number of displayed windows is reached.
** py-split-windows-on-execute-function
How window should get splitted to display results of py-execute-... functions.
** py-shell-fontify-style
Fontify current input resp. output in Python shell. Default is nil.
INPUT will leave output unfontified.
ALL keeps output fontified.
At any case only current input gets fontified.
** py-hide-show-keywords
Keywords composing visible heads.
** py-hide-show-hide-docstrings
Controls if doc strings can be hidden by hide-show
** py-hide-comments-when-hiding-all
Hide the comments too when you do an ‘hs-hide-all’.
** py-outline-mode-keywords
Keywords composing visible heads.
** python-mode-hook
Hook run after entering python-mode-modeline-display mode.
No problems result if this variable is not bound.
‘add-hook’ automatically binds it. (This is true for all hook variables.)
** py-shell-name
A PATH/TO/EXECUTABLE or default value ‘py-shell’ may look for, if no shell is specified by command.
On Windows default is C:/Python27/python
--there is no garantee it exists, please check your system--
Else python
** py-python-command
Make sure, the directory where python.exe resides in in the PATH-variable.
Windows: If needed, edit in "Advanced System Settings/Environment Variables" Commonly "C:\\Python27\\python.exe"
With Anaconda for example the following works here:
"C:\\Users\\My-User-Name\\Anaconda\\Scripts\\python.exe"
Else /usr/bin/python
** py-python-command-args
String arguments to be used when starting a Python shell.
** py-python2-command
Make sure, the directory where python.exe resides in in the PATH-variable.
Windows: If needed, edit in "Advanced System Settings/Environment Variables" Commonly "C:\\Python27\\python.exe"
With Anaconda for example the following works here:
"C:\\Users\\My-User-Name\\Anaconda\\Scripts\\python.exe"
Else /usr/bin/python
** py-python2-command-args
String arguments to be used when starting a Python shell.
** py-python3-command
A PATH/TO/EXECUTABLE or default value ‘py-shell’ may look for, if
no shell is specified by command.
On Windows see C:/Python3/python.exe
--there is no garantee it exists, please check your system--
At GNU systems see /usr/bin/python3
** py-python3-command-args
String arguments to be used when starting a Python3 shell.
** py-ipython-command
A PATH/TO/EXECUTABLE or default value ‘M-x IPython RET’ may look for, if no IPython-shell is specified by command.
On Windows default is "C:\\Python27\\python.exe"
While with Anaconda for example the following works here:
"C:\\Users\\My-User-Name\\Anaconda\\Scripts\\ipython.exe"
Else /usr/bin/ipython
** py-ipython-command-args
String arguments to be used when starting a Python shell.
At Windows make sure ipython-script.py is PATH. Also setting PATH/TO/SCRIPT here should work, for example;
C:\Python27\Scripts\ipython-script.py
With Anaconda the following is known to work:
"C:\\Users\\My-User-Name\\Anaconda\\Scripts\\ipython-script-py"
** py-jython-command
A PATH/TO/EXECUTABLE or default value ‘M-x Jython RET’ may look for, if no Jython-shell is specified by command.
Not known to work at windows
Default /usr/bin/jython
** py-jython-command-args
String arguments to be used when starting a Python shell.
** py-shell-toggle-1
A PATH/TO/EXECUTABLE or default value used by ‘py-toggle-shell’.
** py-shell-toggle-2
A PATH/TO/EXECUTABLE or default value used by ‘py-toggle-shell’.
** py--imenu-create-index-p
Non-nil means Python mode creates and displays an index menu of functions and global variables.
** py-match-paren-mode
Non-nil means, cursor will jump to beginning or end of a block.
This vice versa, to beginning first.
Sets ‘py-match-paren-key’ in python-mode-map.
Customize ‘py-match-paren-key’ which key to use.
** py-match-paren-key
String used by M-x comment-region to comment out a block of code.
This should follow the convention for non-indenting comment lines so
that the indentation commands won’t get confused (i.e., the string
should be of the form ‘#x...’ where ‘x’ is not a blank or a tab, and
‘...’ is arbitrary). However, this string should not end in whitespace.
** py-kill-empty-line
If t, py-indent-forward-line kills empty lines.
** py-imenu-show-method-args-p
Controls echoing of arguments of functions & methods in the Imenu buffer.
When non-nil, arguments are printed.
** py-use-local-default
If ‘t’, py-shell will use ‘py-shell-local-path’ instead
of default Python.
Making switch between several virtualenv’s easier,
‘python-mode’ should deliver an installer, so named-shells pointing to virtualenv’s will be available.
** py-edit-only-p
When ‘t’ ‘python-mode’ will not take resort nor check for installed Python executables. Default is nil.
See bug report at launchpad, lp:944093.
** py-force-py-shell-name-p
When ‘t’, execution with kind of Python specified in ‘py-shell-name’ is enforced, possibly shebang doesn’t take precedence.
** python-mode-v5-behavior-p
Execute region through ‘shell-command-on-region’ as
v5 did it - lp:990079. This might fail with certain chars - see UnicodeEncodeError lp:550661
** py-trailing-whitespace-smart-delete-p
Default is nil. When t, python-mode calls
(add-hook ’before-save-hook ’delete-trailing-whitespace nil ’local)
Also commands may delete trailing whitespace by the way.
When editing other peoples code, this may produce a larger diff than expected
** py-newline-delete-trailing-whitespace-p
Delete trailing whitespace maybe left by ‘py-newline-and-indent’.
Default is ‘t’. See lp:1100892
** py--warn-tmp-files-left-p
Messages a warning, when ‘py-temp-directory’ contains files susceptible being left by previous Python-mode sessions. See also lp:987534
** py-complete-ac-sources
List of auto-complete sources assigned to ‘ac-sources’ in ‘py-complete-initialize’.
Default is known to work an Ubuntu 14.10 - having python-
mode, pymacs and auto-complete-el, with the following minimal
emacs initialization:
(require ’pymacs)
(require ’auto-complete-config)
(ac-config-default)
** py-remove-cwd-from-path
Whether to allow loading of Python modules from the current directory.
If this is non-nil, Emacs removes ’’ from sys.path when starting
a Python process. This is the default, for security
reasons, as it is easy for the Python process to be started
without the user’s realization (e.g. to perform completion).
** py-shell-local-path
If ‘py-use-local-default’ is non-nil, ‘py-shell’ will use EXECUTABLE indicated here incl. path.
** py-python-edit-version
When not empty, fontify according to Python version specified.
Default is the empty string, a useful value "python3" maybe.
When empty, version is guessed via ‘py-choose-shell’.
** py-ipython-execute-delay
Delay needed by execute functions when no IPython shell is running.
** py--imenu-create-index-function
Switch between ‘py--imenu-create-index-new’, which also lists modules variables, and series 5. index-machine
** py-docstring-style
Implemented styles are DJANGO, ONETWO, PEP-257, PEP-257-NN,
SYMMETRIC, and NIL.
A value of NIL won’t care about quotes
position and will treat docstrings a normal string, any other
value may result in one of the following docstring styles:
DJANGO:
"""
Process foo, return bar.
"""
"""
Process foo, return bar.
If processing fails throw ProcessingError.
"""
ONETWO:
"""Process foo, return bar."""
"""
Process foo, return bar.
If processing fails throw ProcessingError.
"""
PEP-257:
"""Process foo, return bar."""
"""Process foo, return bar.
If processing fails throw ProcessingError.
"""
PEP-257-NN:
"""Process foo, return bar."""
"""Process foo, return bar.
If processing fails throw ProcessingError.
"""
SYMMETRIC:
"""Process foo, return bar."""
"""
Process foo, return bar.
If processing fails throw ProcessingError.
"""
** py-execute-directory
When set, stores the file’s default directory-name py-execute-... functions act upon.
Used by Python-shell for output of ‘py-execute-buffer’ and related commands. See also ‘py-use-current-dir-when-execute-p’
** py-use-current-dir-when-execute-p
When ‘t’, current directory is used by Python-shell for output of ‘py-execute-buffer’ and related commands.
See also ‘py-execute-directory’
** py-keep-shell-dir-when-execute-p
Don’t change Python shell’s current working directory when sending code.
See also ‘py-execute-directory’
** py-fileless-buffer-use-default-directory-p
When ‘py-use-current-dir-when-execute-p’ is non-nil and no buffer-file exists, value of ‘default-directory’ sets current working directory of Python output shell
** py-check-command
Command used to check a Python file.
** py-ffap-p
Select python-modes way to find file at point.
Default is nil
** py-keep-windows-configuration
Takes precedence over ‘py-split-window-on-execute’ and ‘py-switch-buffers-on-execute-p’.
See lp:1239498
To suppres window-changes due to error-signaling also, set ‘py-keep-windows-configuration’ onto ’force
Default is nil
** py-shell-prompt-regexp
Regular Expression matching top-level input prompt of python shell.
It should not contain a caret (^) at the beginning.
** py-shell-prompt-output-regexp
Regular Expression matching output prompt of python shell.
It should not contain a caret (^) at the beginning.
** py-debug-p
When non-nil, keep resp. store information useful for debugging.
Temporary files are not deleted. Other functions might implement
some logging etc.
** py-section-start
Delimit arbitrary chunks of code.
** py-section-end
Delimit arbitrary chunks of code.
** py-paragraph-re
Allow Python specific paragraph-start var
** py-outdent-re-raw
** py-no-outdent-re-raw
** py-block-or-clause-re-raw
Matches the beginning of a compound statement or it’s clause.
** py-block-re-raw
Matches the beginning of a compound statement but not it’s clause.
** py-extended-block-or-clause-re-raw
Matches the beginning of a compound statement or it’s clause.
** py-top-level-re
A form which starts at zero indent level, but is not a comment.
** py-clause-re-raw
Matches the beginning of a clause.
** py-compilation-regexp-alist
Fetch errors from Py-shell.
hooked into ‘compilation-error-regexp-alist’
** py-shell-unfontify-p
Run ‘py--run-unfontify-timer’ unfontifying the shell banner-text.
Default is nil
** py-underscore-word-syntax-p
If underscore chars should be of syntax-class ‘word’, not of ‘symbol’.
Underscores in word-class makes ‘forward-word’ etc. travel the indentifiers. Default is ‘t’.
See bug report at launchpad, lp:940812
python-mode.el-6.2.3/doc/commands-python-mode.rst 0000644 0000000 0000000 00000631672 13037357637 021720 0 ustar root root 0000000 0000000 Commands
====================
py-smart-operator-check
-----------------------
Check, if smart-operator-mode is loaded resp. available.
Give some hints, if not.
py-autopair-check
-----------------
Check, if autopair-mode is available.
Give some hints, if not.
py--unfontify-banner
--------------------
Unfontify the shell banner-text.
Cancels ‘py--timer’
Expects being called by ‘py--run-unfontify-timer’
py-choose-shell-by-shebang
--------------------------
Choose shell by looking at #! on the first line.
If SHEBANG is non-nil, returns the shebang as string,
otherwise the Python resp. Jython shell command name.
py-choose-shell-by-path
-----------------------
Select Python executable according to version desplayed in path, current buffer-file is selected from.
Returns versioned string, nil if nothing appropriate found
py-which-python
---------------
Returns version of Python of current environment, a number.
py-python-current-environment
-----------------------------
Returns path of current Python installation.
py-choose-shell
---------------
Return an appropriate executable as a string.
Returns nil, if no executable found.
This does the following:
- look for an interpreter with ‘py-choose-shell-by-shebang’
- examine imports using ‘py--choose-shell-by-import’
- look if Path/To/File indicates a Python version
- if not successful, return default value of ‘py-shell-name’
When interactivly called, messages the shell name, Emacs would in the given circumstances.
With C-u 4 is called ‘py-switch-shell’ see docu there.
py-install-directory-check
--------------------------
Do some sanity check for ‘py-install-directory’.
Returns ‘t’ if successful.
py-guess-py-install-directory
-----------------------------
Takes value of user directory aka $HOME
if ‘(locate-library "python-mode")’ is not succesful.
Used only, if ‘py-install-directory’ is empty.
py-load-pymacs
--------------
Load Pymacs as delivered.
Pymacs has been written by François Pinard and many others.
See original source: http://pymacs.progiciels-bpi.ca
py-set-load-path
----------------
Include needed subdirs of python-mode directory.
py-count-lines
--------------
Count lines in accessible part until current line.
See http://debbugs.gnu.org/cgi/bugreport.cgi?bug=7115
py-toggle-highlight-indentation
-------------------------------
If ‘highlight-indentation-p’ should be on or off.
py-highlight-indentation-off
----------------------------
If ‘highlight-indentation-p’ should be on or off.
py-highlight-indentation-on
---------------------------
If ‘highlight-indentation-p’ should be on or off.
py-toggle-smart-indentation
---------------------------
If ‘py-smart-indentation’ should be on or off.
Returns value of ‘py-smart-indentation’ switched to.
py-smart-indentation-on
-----------------------
Make sure, ‘py-smart-indentation’ is on.
Returns value of ‘py-smart-indentation’.
py-smart-indentation-off
------------------------
Make sure, ‘py-smart-indentation’ is off.
Returns value of ‘py-smart-indentation’.
py-toggle-sexp-function
-----------------------
Opens customization
py-toggle-autopair-mode
-----------------------
If ‘py-autopair-mode’ should be on or off.
Returns value of ‘py-autopair-mode’ switched to.
py-autopair-mode-on
-------------------
Make sure, py-autopair-mode’ is on.
Returns value of ‘py-autopair-mode’.
py-autopair-mode-off
--------------------
Make sure, py-autopair-mode’ is off.
Returns value of ‘py-autopair-mode’.
toggle-py-smart-operator-mode-p
-------------------------------
If ‘py-smart-operator-mode-p’ should be on or off.
Returns value of ‘py-smart-operator-mode-p’ switched to.
py-smart-operator-mode-p-on
---------------------------
Make sure, py-smart-operator-mode-p’ is on.
Returns value of ‘py-smart-operator-mode-p’.
py-smart-operator-mode-p-off
----------------------------
Make sure, py-smart-operator-mode-p’ is off.
Returns value of ‘py-smart-operator-mode-p’.
toggle-py-switch-buffers-on-execute-p
-------------------------------------
If ‘py-switch-buffers-on-execute-p’ should be on or off.
Returns value of ‘py-switch-buffers-on-execute-p’ switched to.
py-switch-buffers-on-execute-p-on
---------------------------------
Make sure, ‘py-py-switch-buffers-on-execute-p’ is on.
Returns value of ‘py-switch-buffers-on-execute-p’.
py-switch-buffers-on-execute-p-off
----------------------------------
Make sure, ‘py-switch-buffers-on-execute-p’ is off.
Returns value of ‘py-switch-buffers-on-execute-p’.
toggle-py-split-window-on-execute
---------------------------------
If ‘py-split-window-on-execute’ should be on or off.
Returns value of ‘py-split-window-on-execute’ switched to.
py-split-window-on-execute-on
-----------------------------
Make sure, ‘py-py-split-window-on-execute’ is on.
Returns value of ‘py-split-window-on-execute’.
py-split-window-on-execute-off
------------------------------
Make sure, ‘py-split-window-on-execute’ is off.
Returns value of ‘py-split-window-on-execute’.
toggle-py-fontify-shell-buffer-p
--------------------------------
If ‘py-fontify-shell-buffer-p’ should be on or off.
Returns value of ‘py-fontify-shell-buffer-p’ switched to.
py-fontify-shell-buffer-p-on
----------------------------
Make sure, ‘py-py-fontify-shell-buffer-p’ is on.
Returns value of ‘py-fontify-shell-buffer-p’.
py-fontify-shell-buffer-p-off
-----------------------------
Make sure, ‘py-fontify-shell-buffer-p’ is off.
Returns value of ‘py-fontify-shell-buffer-p’.
toggle-python-mode-v5-behavior-p
--------------------------------
If ‘python-mode-v5-behavior-p’ should be on or off.
Returns value of ‘python-mode-v5-behavior-p’ switched to.
python-mode-v5-behavior-p-on
----------------------------
Make sure, ‘python-mode-v5-behavior-p’ is on.
Returns value of ‘python-mode-v5-behavior-p’.
python-mode-v5-behavior-p-off
-----------------------------
Make sure, ‘python-mode-v5-behavior-p’ is off.
Returns value of ‘python-mode-v5-behavior-p’.
toggle-py-jump-on-exception
---------------------------
If ‘py-jump-on-exception’ should be on or off.
Returns value of ‘py-jump-on-exception’ switched to.
py-jump-on-exception-on
-----------------------
Make sure, py-jump-on-exception’ is on.
Returns value of ‘py-jump-on-exception’.
py-jump-on-exception-off
------------------------
Make sure, ‘py-jump-on-exception’ is off.
Returns value of ‘py-jump-on-exception’.
toggle-py-use-current-dir-when-execute-p
----------------------------------------
If ‘py-use-current-dir-when-execute-p’ should be on or off.
Returns value of ‘py-use-current-dir-when-execute-p’ switched to.
py-use-current-dir-when-execute-p-on
------------------------------------
Make sure, py-use-current-dir-when-execute-p’ is on.
Returns value of ‘py-use-current-dir-when-execute-p’.
py-use-current-dir-when-execute-p-off
-------------------------------------
Make sure, ‘py-use-current-dir-when-execute-p’ is off.
Returns value of ‘py-use-current-dir-when-execute-p’.
toggle-py-electric-comment-p
----------------------------
If ‘py-electric-comment-p’ should be on or off.
Returns value of ‘py-electric-comment-p’ switched to.
py-electric-comment-p-on
------------------------
Make sure, py-electric-comment-p’ is on.
Returns value of ‘py-electric-comment-p’.
py-electric-comment-p-off
-------------------------
Make sure, ‘py-electric-comment-p’ is off.
Returns value of ‘py-electric-comment-p’.
toggle-py-underscore-word-syntax-p
----------------------------------
If ‘py-underscore-word-syntax-p’ should be on or off.
Returns value of ‘py-underscore-word-syntax-p’ switched to.
py-underscore-word-syntax-p-on
------------------------------
Make sure, py-underscore-word-syntax-p’ is on.
Returns value of ‘py-underscore-word-syntax-p’.
py-underscore-word-syntax-p-off
-------------------------------
Make sure, ‘py-underscore-word-syntax-p’ is off.
Returns value of ‘py-underscore-word-syntax-p’.
py-insert-default-shebang
-------------------------
Insert in buffer shebang of installed default Python.
py-indent-line-outmost
----------------------
Indent the current line to the outmost reasonable indent.
With optional C-u an indent with length ‘py-indent-offset’ is inserted unconditionally
py-indent-line
--------------
Indent the current line according to Python rules.
When called interactivly with C-u, ignore dedenting rules for block closing statements
(e.g. return, raise, break, continue, pass)
An optional C-u followed by a numeric argument neither 1 nor 4 will switch off ‘py-smart-indentation’ for this execution. This permits to correct allowed but unwanted indents.
Similar to ‘toggle-py-smart-indentation’ resp. ‘py-smart-indentation-off’ followed by TAB.
This function is normally used by ‘indent-line-function’ resp.
TAB.
When bound to TAB, C-q TAB inserts a TAB.
OUTMOST-ONLY stops circling possible indent.
When ‘py-tab-shifts-region-p’ is ‘t’, not just the current line,
but the region is shiftet that way.
If ‘py-tab-indents-region-p’ is ‘t’ and first TAB doesn’t shift
--as indent is at outmost reasonable--, indent-region is called.
C-q TAB inserts a literal TAB-character.
py-newline-and-indent
---------------------
Add a newline and indent to outmost reasonable indent.
When indent is set back manually, this is honoured in following lines.
py-newline-and-dedent
---------------------
Add a newline and indent to one level below current.
Returns column.
py-toggle-indent-tabs-mode
--------------------------
Toggle ‘indent-tabs-mode’.
Returns value of ‘indent-tabs-mode’ switched to.
py-indent-tabs-mode
-------------------
With positive ARG switch ‘indent-tabs-mode’ on.
With negative ARG switch ‘indent-tabs-mode’ off.
Returns value of ‘indent-tabs-mode’ switched to.
py-indent-tabs-mode-on
----------------------
Switch ‘indent-tabs-mode’ on.
py-indent-tabs-mode-off
-----------------------
Switch ‘indent-tabs-mode’ off.
py-guess-indent-offset
----------------------
Guess ‘py-indent-offset’.
Set local value of ‘py-indent-offset’, return it
Might change local value of ‘py-indent-offset’ only when called
downwards from beginning of block followed by a statement. Otherwise default-value is returned.
py-indent-and-forward
---------------------
Indent current line according to mode, move one line forward.
If optional INDENT is given, use it
py-indent-region
----------------
Reindent a region of Python code.
In case first line accepts an indent, keep the remaining
lines relative.
Otherwise lines in region get outmost indent,
same with optional argument
In order to shift a chunk of code, where the first line is okay, start with second line.
py-backward-declarations
------------------------
Got to the beginning of assigments resp. statements in current level which don’t open blocks.
py-forward-declarations
-----------------------
Got to the end of assigments resp. statements in current level which don’t open blocks.
py-declarations
---------------
Copy and mark assigments resp. statements in current level which don’t open blocks or start with a keyword.
See also ‘py-statements’, which is more general, taking also simple statements starting with a keyword.
py-kill-declarations
--------------------
Delete variables declared in current level.
Store deleted variables in kill-ring
py--bounds-of-statements
------------------------
Bounds of consecutive multitude of statements around point.
Indented same level, which don’t open blocks.
py-backward-statements
----------------------
Got to the beginning of statements in current level which don’t open blocks.
py-forward-statements
---------------------
Got to the end of statements in current level which don’t open blocks.
py-statements
-------------
Copy and mark simple statements in current level which don’t open blocks.
More general than py-declarations, which would stop at keywords like a print-statement.
py-kill-statements
------------------
Delete statements declared in current level.
Store deleted statements in kill-ring
py-insert-super
---------------
Insert a function "super()" from current environment.
As example given in Python v3.1 documentation » The Python Standard Library »
class C(B):
def method(self, arg):
super().method(arg) # This does the same thing as:
# super(C, self).method(arg)
Returns the string inserted.
py-delete-comments-in-def-or-class
----------------------------------
Delete all commented lines in def-or-class at point
py-delete-comments-in-class
---------------------------
Delete all commented lines in class at point
py-delete-comments-in-block
---------------------------
Delete all commented lines in block at point
py-delete-comments-in-region
----------------------------
Delete all commented lines in region.
py-edit-docstring
-----------------
Edit docstring or active region in python-mode.
py-backward-region
------------------
Go to the beginning of current region
py-backward-block
-----------------
Go to beginning of ‘block’.
If already at beginning, go one ‘block’ backward.
Returns beginning of ‘block’ if successful, nil otherwise
py-backward-block-or-clause
---------------------------
Go to beginning of ‘block-or-clause’.
If already at beginning, go one ‘block-or-clause’ backward.
Returns beginning of ‘block-or-clause’ if successful, nil otherwise
py-backward-class
-----------------
Go to beginning of ‘class’.
If already at beginning, go one ‘class’ backward.
Returns beginning of ‘class’ if successful, nil otherwise
py-backward-clause
------------------
Go to beginning of ‘clause’.
If already at beginning, go one ‘clause’ backward.
Returns beginning of ‘clause’ if successful, nil otherwise
py-backward-def
---------------
Go to beginning of ‘def’.
If already at beginning, go one ‘def’ backward.
Returns beginning of ‘def’ if successful, nil otherwise
py-backward-def-or-class
------------------------
Go to beginning of ‘def-or-class’.
If already at beginning, go one ‘def-or-class’ backward.
Returns beginning of ‘def-or-class’ if successful, nil otherwise
py-backward-elif-block
----------------------
Go to beginning of ‘elif-block’.
If already at beginning, go one ‘elif-block’ backward.
Returns beginning of ‘elif-block’ if successful, nil otherwise
py-backward-else-block
----------------------
Go to beginning of ‘else-block’.
If already at beginning, go one ‘else-block’ backward.
Returns beginning of ‘else-block’ if successful, nil otherwise
py-backward-except-block
------------------------
Go to beginning of ‘except-block’.
If already at beginning, go one ‘except-block’ backward.
Returns beginning of ‘except-block’ if successful, nil otherwise
py-backward-for-block
---------------------
Go to beginning of ‘for-block’.
If already at beginning, go one ‘for-block’ backward.
Returns beginning of ‘for-block’ if successful, nil otherwise
py-backward-if-block
--------------------
Go to beginning of ‘if-block’.
If already at beginning, go one ‘if-block’ backward.
Returns beginning of ‘if-block’ if successful, nil otherwise
py-backward-minor-block
-----------------------
Go to beginning of ‘minor-block’.
If already at beginning, go one ‘minor-block’ backward.
Returns beginning of ‘minor-block’ if successful, nil otherwise
py-backward-try-block
---------------------
Go to beginning of ‘try-block’.
If already at beginning, go one ‘try-block’ backward.
Returns beginning of ‘try-block’ if successful, nil otherwise
py-backward-block-bol
---------------------
Go to beginning of ‘block’, go to BOL.
If already at beginning, go one ‘block’ backward.
Returns beginning of ‘block’ if successful, nil otherwise
py-backward-block-or-clause-bol
-------------------------------
Go to beginning of ‘block-or-clause’, go to BOL.
If already at beginning, go one ‘block-or-clause’ backward.
Returns beginning of ‘block-or-clause’ if successful, nil otherwise
py-backward-class-bol
---------------------
Go to beginning of ‘class’, go to BOL.
If already at beginning, go one ‘class’ backward.
Returns beginning of ‘class’ if successful, nil otherwise
py-backward-clause-bol
----------------------
Go to beginning of ‘clause’, go to BOL.
If already at beginning, go one ‘clause’ backward.
Returns beginning of ‘clause’ if successful, nil otherwise
py-backward-def-bol
-------------------
Go to beginning of ‘def’, go to BOL.
If already at beginning, go one ‘def’ backward.
Returns beginning of ‘def’ if successful, nil otherwise
py-backward-def-or-class-bol
----------------------------
Go to beginning of ‘def-or-class’, go to BOL.
If already at beginning, go one ‘def-or-class’ backward.
Returns beginning of ‘def-or-class’ if successful, nil otherwise
py-backward-elif-block-bol
--------------------------
Go to beginning of ‘elif-block’, go to BOL.
If already at beginning, go one ‘elif-block’ backward.
Returns beginning of ‘elif-block’ if successful, nil otherwise
py-backward-else-block-bol
--------------------------
Go to beginning of ‘else-block’, go to BOL.
If already at beginning, go one ‘else-block’ backward.
Returns beginning of ‘else-block’ if successful, nil otherwise
py-backward-except-block-bol
----------------------------
Go to beginning of ‘except-block’, go to BOL.
If already at beginning, go one ‘except-block’ backward.
Returns beginning of ‘except-block’ if successful, nil otherwise
py-backward-for-block-bol
-------------------------
Go to beginning of ‘for-block’, go to BOL.
If already at beginning, go one ‘for-block’ backward.
Returns beginning of ‘for-block’ if successful, nil otherwise
py-backward-if-block-bol
------------------------
Go to beginning of ‘if-block’, go to BOL.
If already at beginning, go one ‘if-block’ backward.
Returns beginning of ‘if-block’ if successful, nil otherwise
py-backward-minor-block-bol
---------------------------
Go to beginning of ‘minor-block’, go to BOL.
If already at beginning, go one ‘minor-block’ backward.
Returns beginning of ‘minor-block’ if successful, nil otherwise
py-backward-try-block-bol
-------------------------
Go to beginning of ‘try-block’, go to BOL.
If already at beginning, go one ‘try-block’ backward.
Returns beginning of ‘try-block’ if successful, nil otherwise
py-forward-region
-----------------
Go to the end of current region
py-forward-block
----------------
Go to end of block.
Returns end of block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-block-bol
--------------------
Goto beginning of line following end of block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-block’: down from current definition to next beginning of block below.
py-forward-block-or-clause
--------------------------
Go to end of block-or-clause.
Returns end of block-or-clause if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-block-or-clause-bol
------------------------------
Goto beginning of line following end of block-or-clause.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-block-or-clause’: down from current definition to next beginning of block-or-clause below.
py-forward-class
----------------
Go to end of class.
Returns end of class if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-class-bol
--------------------
Goto beginning of line following end of class.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-class’: down from current definition to next beginning of class below.
py-forward-clause
-----------------
Go to end of clause.
Returns end of clause if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-clause-bol
---------------------
Goto beginning of line following end of clause.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-clause’: down from current definition to next beginning of clause below.
py-forward-def-or-class
-----------------------
Go to end of def-or-class.
Returns end of def-or-class if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-def-or-class-bol
---------------------------
Goto beginning of line following end of def-or-class.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-def-or-class’: down from current definition to next beginning of def-or-class below.
py-forward-def
--------------
Go to end of def.
Returns end of def if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-def-bol
------------------
Goto beginning of line following end of def.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-def’: down from current definition to next beginning of def below.
py-forward-if-block
-------------------
Go to end of if-block.
Returns end of if-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-if-block-bol
-----------------------
Goto beginning of line following end of if-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-if-block’: down from current definition to next beginning of if-block below.
py-forward-elif-block
---------------------
Go to end of elif-block.
Returns end of elif-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-elif-block-bol
-------------------------
Goto beginning of line following end of elif-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-elif-block’: down from current definition to next beginning of elif-block below.
py-forward-else-block
---------------------
Go to end of else-block.
Returns end of else-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-else-block-bol
-------------------------
Goto beginning of line following end of else-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-else-block’: down from current definition to next beginning of else-block below.
py-forward-for-block
--------------------
Go to end of for-block.
Returns end of for-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-for-block-bol
------------------------
Goto beginning of line following end of for-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-for-block’: down from current definition to next beginning of for-block below.
py-forward-except-block
-----------------------
Go to end of except-block.
Returns end of except-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-except-block-bol
---------------------------
Goto beginning of line following end of except-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-except-block’: down from current definition to next beginning of except-block below.
py-forward-try-block
--------------------
Go to end of try-block.
Returns end of try-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-try-block-bol
------------------------
Goto beginning of line following end of try-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-try-block’: down from current definition to next beginning of try-block below.
py-forward-minor-block
----------------------
Go to end of minor-block.
Returns end of minor-block if successful, nil otherwise
Optional arg DECORATOR is used if form supports one
With optional BOL, go to beginning of line following match.
py-forward-minor-block-bol
--------------------------
Goto beginning of line following end of minor-block.
Returns position reached, if successful, nil otherwise.
See also ‘py-down-minor-block’: down from current definition to next beginning of minor-block below.
py-backward-indent
------------------
Go to the beginning of a section of equal indent.
If already at the beginning or before a indent, go to next indent in buffer upwards
Returns final position when called from inside section, nil otherwise
py-backward-indent-bol
----------------------
Go to the beginning of line of a section of equal indent.
If already at the beginning or before an indent, go to next indent in buffer upwards
Returns final position when called from inside section, nil otherwise
py-forward-indent
-----------------
Go to the end of a section of equal indentation.
If already at the end, go down to next indent in buffer
Returns final position when called from inside section, nil otherwise
py-forward-indent-bol
---------------------
Go to beginning of line following of a section of equal indentation.
If already at the end, go down to next indent in buffer
Returns final position when called from inside section, nil otherwise
py-backward-expression
----------------------
Go to the beginning of a python expression.
If already at the beginning or before a expression, go to next expression in buffer upwards
py-forward-expression
---------------------
Go to the end of a compound python expression.
Operators are ignored.
py-backward-line
----------------
Go to beginning-of-line, return position.
If already at beginning-of-line and not at BOB, go to beginning of previous line.
py-forward-line
---------------
Go to end-of-line, return position.
If already at end-of-line and not at EOB, go to end of next line.
py-backward-statement
---------------------
Go to the initial line of a simple statement.
For beginning of compound statement use py-backward-block.
For beginning of clause py-backward-clause.
‘ignore-in-string-p’ allows moves inside a docstring, used when
computing indents
py-backward-statement-bol
-------------------------
Goto beginning of line where statement starts.
Returns position reached, if successful, nil otherwise.
See also ‘py-up-statement’: up from current definition to next beginning of statement above.
py-forward-statement
--------------------
Go to the last char of current statement.
Optional argument REPEAT, the number of loops done already, is checked for py-max-specpdl-size error. Avoid eternal loops due to missing string delimters etc.
py-forward-statement-bol
------------------------
Go to the beginning-of-line following current statement.
py-backward-decorator
---------------------
Go to the beginning of a decorator.
Returns position if succesful
py-forward-decorator
--------------------
Go to the end of a decorator.
Returns position if succesful
py-backward-comment
-------------------
Got to beginning of a commented section.
py-forward-comment
------------------
Go to end of commented section.
Optional args position and comment-start character
Travel empty lines
py-go-to-beginning-of-comment
-----------------------------
Go to the beginning of current line’s comment, if any.
From a programm use macro ‘py-backward-comment’ instead
py-leave-comment-or-string-backward
-----------------------------------
If inside a comment or string, leave it backward.
py-beginning-of-list-pps
------------------------
Go to the beginning of a list.
Optional ARG indicates a start-position for ‘parse-partial-sexp’.
Return beginning position, nil if not inside.
py-forward-into-nomenclature
----------------------------
Move forward to end of a nomenclature symbol.
With C-u (programmatically, optional argument ARG), do it that many times.
A ‘nomenclature’ is a fancy way of saying AWordWithMixedCaseNotUnderscores.
py-backward-into-nomenclature
-----------------------------
Move backward to beginning of a nomenclature symbol.
With optional ARG, move that many times. If ARG is negative, move
forward.
A ‘nomenclature’ is a fancy way of saying AWordWithMixedCaseNotUnderscores.
py-beginning-of-block-current-column
------------------------------------
Reach next beginning of block upwards which starts at current column.
Return position
py-backward-section
-------------------
Go to next section start upward in buffer.
Return position if successful
py-forward-section
------------------
Go to next section end downward in buffer.
Return position if successful
py-kill-comment
---------------
Delete comment at point.
Stores data in kill ring
py-kill-line
------------
Delete line at point.
Stores data in kill ring
py-kill-paragraph
-----------------
Delete paragraph at point.
Stores data in kill ring
py-kill-expression
------------------
Delete expression at point.
Stores data in kill ring
py-kill-partial-expression
--------------------------
Delete partial-expression at point.
Stores data in kill ring
py-kill-section
---------------
Delete section at point.
Stores data in kill ring
py-kill-top-level
-----------------
Delete top-level at point.
Stores data in kill ring
py-kill-block
-------------
Delete block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-block-or-clause
-----------------------
Delete block-or-clause at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-class
-------------
Delete class at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-clause
--------------
Delete clause at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-def
-----------
Delete def at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-def-or-class
--------------------
Delete def-or-class at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-elif-block
------------------
Delete elif-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-else-block
------------------
Delete else-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-except-block
--------------------
Delete except-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-for-block
-----------------
Delete for-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-if-block
----------------
Delete if-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-indent
--------------
Delete indent at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-minor-block
-------------------
Delete minor-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-statement
-----------------
Delete statement at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-kill-try-block
-----------------
Delete try-block at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-close-block
--------------
Close block at point.
Set indent level to that of beginning of function definition.
If final line isn’t empty and ‘py-close-block-provides-newline’ non-nil, insert a newline.
py-close-class
--------------
Close class at point.
Set indent level to that of beginning of function definition.
If final line isn’t empty and ‘py-close-block-provides-newline’ non-nil, insert a newline.
py-close-def
------------
Close def at point.
Set indent level to that of beginning of function definition.
If final line isn’t empty and ‘py-close-block-provides-newline’ non-nil, insert a newline.
py-close-def-or-class
---------------------
Close def-or-class at point.
Set indent level to that of beginning of function definition.
If final line isn’t empty and ‘py-close-block-provides-newline’ non-nil, insert a newline.
py-close-minor-block
--------------------
Close minor-block at point.
Set indent level to that of beginning of function definition.
If final line isn’t empty and ‘py-close-block-provides-newline’ non-nil, insert a newline.
py-close-statement
------------------
Close statement at point.
Set indent level to that of beginning of function definition.
If final line isn’t empty and ‘py-close-block-provides-newline’ non-nil, insert a newline.
py-mark-comment
---------------
Mark comment at point.
Returns beginning and end positions of marked area, a cons.
py-mark-line
------------
Mark line at point.
Returns beginning and end positions of marked area, a cons.
py-mark-paragraph
-----------------
Mark paragraph at point.
Returns beginning and end positions of marked area, a cons.
py-mark-expression
------------------
Mark expression at point.
Returns beginning and end positions of marked area, a cons.
py-mark-partial-expression
--------------------------
Mark partial-expression at point.
Returns beginning and end positions of marked area, a cons.
py-mark-section
---------------
Mark section at point.
Returns beginning and end positions of marked area, a cons.
py-mark-top-level
-----------------
Mark top-level at point.
Returns beginning and end positions of marked area, a cons.
py-mark-block
-------------
Mark block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
py-mark-block-or-clause
-----------------------
Mark block-or-clause, take beginning of line positions.
Returns beginning and end positions of region, a cons.
py-mark-class
-------------
Mark class, take beginning of line positions.
With C-u or ‘py-mark-decorators’ set to ‘t’, decorators are marked too.
Returns beginning and end positions of region, a cons.
py-mark-clause
--------------
Mark clause, take beginning of line positions.
Returns beginning and end positions of region, a cons.
py-mark-def
-----------
Mark def, take beginning of line positions.
With C-u or ‘py-mark-decorators’ set to ‘t’, decorators are marked too.
Returns beginning and end positions of region, a cons.
py-mark-def-or-class
--------------------
Mark def-or-class, take beginning of line positions.
With C-u or ‘py-mark-decorators’ set to ‘t’, decorators are marked too.
Returns beginning and end positions of region, a cons.
py-mark-elif-block
------------------
Mark elif-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
py-mark-else-block
------------------
Mark else-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
py-mark-except-block
--------------------
Mark except-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
py-mark-for-block
-----------------
Mark for-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
py-mark-if-block
----------------
Mark if-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
py-mark-indent
--------------
Mark indent, take beginning of line positions.
Returns beginning and end positions of region, a cons.
py-mark-minor-block
-------------------
Mark minor-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
py-mark-statement
-----------------
Mark statement, take beginning of line positions.
Returns beginning and end positions of region, a cons.
py-mark-try-block
-----------------
Mark try-block, take beginning of line positions.
Returns beginning and end positions of region, a cons.
py-copy-block
-------------
Copy block at point.
Store data in kill ring, so it might yanked back.
py-copy-block-or-clause
-----------------------
Copy block-or-clause at point.
Store data in kill ring, so it might yanked back.
py-copy-buffer
--------------
Copy buffer at point.
Store data in kill ring, so it might yanked back.
py-copy-class
-------------
Copy class at point.
Store data in kill ring, so it might yanked back.
py-copy-clause
--------------
Copy clause at point.
Store data in kill ring, so it might yanked back.
py-copy-def
-----------
Copy def at point.
Store data in kill ring, so it might yanked back.
py-copy-def-or-class
--------------------
Copy def-or-class at point.
Store data in kill ring, so it might yanked back.
py-copy-expression
------------------
Copy expression at point.
Store data in kill ring, so it might yanked back.
py-copy-indent
--------------
Copy indent at point.
Store data in kill ring, so it might yanked back.
py-copy-line
------------
Copy line at point.
Store data in kill ring, so it might yanked back.
py-copy-minor-block
-------------------
Copy minor-block at point.
Store data in kill ring, so it might yanked back.
py-copy-paragraph
-----------------
Copy paragraph at point.
Store data in kill ring, so it might yanked back.
py-copy-partial-expression
--------------------------
Copy partial-expression at point.
Store data in kill ring, so it might yanked back.
py-copy-region
--------------
Copy region at point.
Store data in kill ring, so it might yanked back.
py-copy-statement
-----------------
Copy statement at point.
Store data in kill ring, so it might yanked back.
py-copy-top-level
-----------------
Copy top-level at point.
Store data in kill ring, so it might yanked back.
py-copy-block-bol
-----------------
Delete block bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-block-or-clause-bol
---------------------------
Delete block-or-clause bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-buffer-bol
------------------
Delete buffer bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-class-bol
-----------------
Delete class bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-clause-bol
------------------
Delete clause bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-def-bol
---------------
Delete def bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-def-or-class-bol
------------------------
Delete def-or-class bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-expression-bol
----------------------
Delete expression bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-indent-bol
------------------
Delete indent bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-line-bol
----------------
Delete line bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-minor-block-bol
-----------------------
Delete minor-block bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-paragraph-bol
---------------------
Delete paragraph bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-partial-expression-bol
------------------------------
Delete partial-expression bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-region-bol
------------------
Delete region bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-statement-bol
---------------------
Delete statement bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-copy-top-level-bol
---------------------
Delete top-level bol at point.
Stores data in kill ring. Might be yanked back using ‘C-y’.
py-delete-block
---------------
Delete BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
py-delete-block-or-clause
-------------------------
Delete BLOCK-OR-CLAUSE at point until beginning-of-line.
Don’t store data in kill ring.
py-delete-class
---------------
Delete CLASS at point until beginning-of-line.
Don’t store data in kill ring.
With C-u or ‘py-mark-decorators’ set to ‘t’, ‘decorators’ are included.
py-delete-clause
----------------
Delete CLAUSE at point until beginning-of-line.
Don’t store data in kill ring.
py-delete-def
-------------
Delete DEF at point until beginning-of-line.
Don’t store data in kill ring.
With C-u or ‘py-mark-decorators’ set to ‘t’, ‘decorators’ are included.
py-delete-def-or-class
----------------------
Delete DEF-OR-CLASS at point until beginning-of-line.
Don’t store data in kill ring.
With C-u or ‘py-mark-decorators’ set to ‘t’, ‘decorators’ are included.
py-delete-elif-block
--------------------
Delete ELIF-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
py-delete-else-block
--------------------
Delete ELSE-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
py-delete-except-block
----------------------
Delete EXCEPT-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
py-delete-for-block
-------------------
Delete FOR-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
py-delete-if-block
------------------
Delete IF-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
py-delete-indent
----------------
Delete INDENT at point until beginning-of-line.
Don’t store data in kill ring.
py-delete-minor-block
---------------------
Delete MINOR-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
py-delete-statement
-------------------
Delete STATEMENT at point until beginning-of-line.
Don’t store data in kill ring.
py-delete-try-block
-------------------
Delete TRY-BLOCK at point until beginning-of-line.
Don’t store data in kill ring.
py-delete-comment
-----------------
Delete COMMENT at point.
Don’t store data in kill ring.
py-delete-line
--------------
Delete LINE at point.
Don’t store data in kill ring.
py-delete-paragraph
-------------------
Delete PARAGRAPH at point.
Don’t store data in kill ring.
py-delete-expression
--------------------
Delete EXPRESSION at point.
Don’t store data in kill ring.
py-delete-partial-expression
----------------------------
Delete PARTIAL-EXPRESSION at point.
Don’t store data in kill ring.
py-delete-section
-----------------
Delete SECTION at point.
Don’t store data in kill ring.
py-delete-top-level
-------------------
Delete TOP-LEVEL at point.
Don’t store data in kill ring.
py-switch-to-python
-------------------
Switch to the Python process buffer, maybe starting new process.
With prefix arg, position cursor at end of buffer.
py-send-file
------------
Send FILE-NAME to Python PROCESS.
If TEMP-FILE-NAME is passed then that file is used for processing
instead, while internally the shell will continue to use
FILE-NAME.
toggle-force-local-shell
------------------------
If locally indicated Python shell should be taken and
enforced upon sessions execute commands.
Toggles boolean ‘py-force-local-shell-p’ along with ‘py-force-py-shell-name-p’
Returns value of ‘toggle-force-local-shell’ switched to.
When on, kind of an option ’follow’, local shell sets ‘py-shell-name’, enforces its use afterwards.
See also commands
‘py-force-local-shell-on’
‘py-force-local-shell-off’
py-force-local-shell-on
-----------------------
Make sure, ‘py-force-local-shell-p’ is on.
Returns value of ‘py-force-local-shell-p’.
Kind of an option ’follow’, local shell sets ‘py-shell-name’, enforces its use afterwards
py-force-local-shell-off
------------------------
Restore ‘py-shell-name’ default value and ‘behaviour’.
toggle-force-py-shell-name-p
----------------------------
If customized default ‘py-shell-name’ should be enforced upon execution.
If ‘py-force-py-shell-name-p’ should be on or off.
Returns value of ‘py-force-py-shell-name-p’ switched to.
See also commands
force-py-shell-name-p-on
force-py-shell-name-p-off
Caveat: Completion might not work that way.
force-py-shell-name-p-on
------------------------
Switches ‘py-force-py-shell-name-p’ on.
Customized default ‘py-shell-name’ will be enforced upon execution.
Returns value of ‘py-force-py-shell-name-p’.
Caveat: Completion might not work that way.
force-py-shell-name-p-off
-------------------------
Make sure, ‘py-force-py-shell-name-p’ is off.
Function to use by executes will be guessed from environment.
Returns value of ‘py-force-py-shell-name-p’.
py-toggle-split-windows-on-execute
----------------------------------
If ‘py-split-window-on-execute’ should be on or off.
Returns value of ‘py-split-window-on-execute’ switched to.
py-split-windows-on-execute-on
------------------------------
Make sure, ‘py-split-window-on-execute’ is on.
Returns value of ‘py-split-window-on-execute’.
py-split-windows-on-execute-off
-------------------------------
Make sure, ‘py-split-window-on-execute’ is off.
Returns value of ‘py-split-window-on-execute’.
py-toggle-shell-switch-buffers-on-execute
-----------------------------------------
If ‘py-switch-buffers-on-execute-p’ should be on or off.
Returns value of ‘py-switch-buffers-on-execute-p’ switched to.
py-shell-switch-buffers-on-execute-on
-------------------------------------
Make sure, ‘py-switch-buffers-on-execute-p’ is on.
Returns value of ‘py-switch-buffers-on-execute-p’.
py-shell-switch-buffers-on-execute-off
--------------------------------------
Make sure, ‘py-switch-buffers-on-execute-p’ is off.
Returns value of ‘py-switch-buffers-on-execute-p’.
py-guess-default-python
-----------------------
Defaults to "python", if guessing didn’t succeed.
py-shell-dedicated
------------------
Start an interactive Python interpreter in another window.
With optional C-u user is prompted by
‘py-choose-shell’ for command and options to pass to the Python
interpreter.
py-set-ipython-completion-command-string
----------------------------------------
Set and return ‘py-ipython-completion-command-string’.
py-ipython--module-completion-import
------------------------------------
Import module-completion
py-toggle-split-window-function
-------------------------------
If window is splitted vertically or horizontally.
When code is executed and ‘py-split-window-on-execute’ is ‘t’, the result is displays in an output-buffer, "*Python*" by default.
Customizable variable ‘py-split-windows-on-execute-function’ tells how to split the screen.
py--manage-windows-split
------------------------
If one window, split according to ‘py-split-windows-on-execute-function.
py-kill-shell-unconditional
---------------------------
With optional argument SHELL.
Otherwise kill default (I)Python shell.
Kill buffer and its process.
Receives a buffer-name as argument
py-kill-default-shell-unconditional
-----------------------------------
Kill buffer "*Python*" and its process.
py-shell
--------
Start an interactive Python interpreter in another window.
Interactively, C-u prompts for a new buffer-name.
C-u 2 prompts for ‘py-python-command-args’.
If ‘default-directory’ is a remote file name, it is also prompted
to change if called with a prefix arg.
Optional string SHELL overrides default ‘py-shell-name’.
Returns py-shell’s buffer-name.
BUFFER allows specifying a name, the Python process is connected to
FAST process not in comint-mode buffer
EXCEPTION-BUFFER point to error
SPLIT see var ‘py-split-window-on-execute’
SWITCH see var ‘py-switch-buffers-on-execute-p’
py-shell-get-process
--------------------
Get appropriate Python process for current buffer and return it.
py-switch-to-shell
------------------
Switch to Python process buffer.
py-execute-file
---------------
When called interactively, user is prompted for filename.
py-execute-string
-----------------
Send the argument STRING to Python default interpreter.
See also ‘py-execute-region’.
py-execute-string-dedicated
---------------------------
Send the argument STRING to an unique Python interpreter.
See also ‘py-execute-region’.
py-fetch-py-master-file
-----------------------
Lookup if a ‘py-master-file’ is specified.
See also doku of variable ‘py-master-file’
py-execute-import-or-reload
---------------------------
Import the current buffer’s file in a Python interpreter.
If the file has already been imported, then do reload instead to get
the latest version.
If the file’s name does not end in ".py", then do execfile instead.
If the current buffer is not visiting a file, do ‘py-execute-buffer’
instead.
If the file local variable ‘py-master-file’ is non-nil, import or
reload the named file instead of the buffer’s file. The file may be
saved based on the value of ‘py-execute-import-or-reload-save-p’.
See also ‘M-x py-execute-region’.
This may be preferable to ‘M-x py-execute-buffer’ because:
- Definitions stay in their module rather than appearing at top
level, where they would clutter the global namespace and not affect
uses of qualified names (MODULE.NAME).
- The Python debugger gets line number information about the functions.
py-execute-defun
----------------
Send the current defun (class or method) to the Python process.
py-process-file
---------------
Process "python filename".
Optional OUTPUT-BUFFER and ERROR-BUFFER might be given.
py-remove-overlays-at-point
---------------------------
Remove overlays as set when ‘py-highlight-error-source-p’ is non-nil.
py-mouseto-exception
--------------------
Jump to the code which caused the Python exception at EVENT.
EVENT is usually a mouse click.
py-goto-exception
-----------------
Go to the line indicated by the traceback.
py-down-exception
-----------------
Go to the next line down in the traceback.
With M-x univeral-argument (programmatically, optional argument
BOTTOM), jump to the bottom (innermost) exception in the exception
stack.
py-up-exception
---------------
Go to the previous line up in the traceback.
With C-u (programmatically, optional argument TOP)
jump to the top (outermost) exception in the exception stack.
py-output-buffer-filter
-----------------------
Clear output buffer from py-shell-input prompt etc.
py-output-filter
----------------
Clear output buffer from py-shell-input prompt etc.
py-send-string
--------------
Evaluate STRING in Python process.
py-shell-complete
-----------------
Complete word before point, if any.
py-indent-or-complete
---------------------
Complete or indent depending on the context.
If cursor is at end of a symbol, try to complete
Otherwise call ‘py-indent-line’
If ‘(use-region-p)’ returns ‘t’, indent region.
Use ‘C-q TAB’ to insert a literally TAB-character
In python-mode ‘py-complete-function’ is called,
in (I)Python shell-modes ‘py-shell-complete’
py-pdbtrack-toggle-stack-tracking
---------------------------------
Set variable ‘py-pdbtrack-do-tracking-p’.
py-execute-statement-pdb
------------------------
Execute statement running pdb.
py-pdb-help
-----------
Print generic pdb.help() message
py--pdb-versioned
-----------------
Guess existing pdb version from py-shell-name
Return "pdb[VERSION]" if executable found, just "pdb" otherwise
py-pdb
------
Run pdb on program FILE in buffer ‘*gud-FILE*’.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
At GNU Linux systems required pdb version should be detected by ‘py--pdb-version’, at Windows configure ‘py-python-ms-pdb-command’
lp:963253
py-update-gud-pdb-history
-------------------------
If pdb is called at a Python buffer, put it’s file name at the head of ‘gud-pdb-history’.
py-fetch-docu
-------------
Lookup in current buffer for the doku for the symbol at point.
Useful for newly defined symbol, not known to python yet.
py-info-current-defun
---------------------
Return name of surrounding function with Python compatible dotted expression syntax.
Optional argument INCLUDE-TYPE indicates to include the type of the defun.
This function is compatible to be used as
‘add-log-current-defun-function’ since it returns nil if point is
not inside a defun.
py-help-at-point
----------------
Print help on symbol at point.
If symbol is defined in current buffer, jump to it’s definition
py-describe-mode
----------------
Dump long form of ‘python-mode’ docs.
py-find-definition
------------------
Find source of definition of SYMBOL.
Interactively, prompt for SYMBOL.
py-find-imports
---------------
Find top-level imports.
Returns imports
py-update-imports
-----------------
Returns imports.
Imports done are displayed in message buffer.
py-pep8-run
-----------
*Run pep8, check formatting - default on the file currently visited.
py-pep8-help
------------
Display pep8 command line help messages.
py-pylint-run
-------------
Run pylint (default on the file currently visited).
For help see M-x pylint-help resp. M-x pylint-long-help.
Home-page: http://www.logilab.org/project/pylint
py-pylint-help
--------------
Display Pylint command line help messages.
Let’s have this until more Emacs-like help is prepared
py-pylint-doku
--------------
Display Pylint Documentation.
Calls ‘pylint --full-documentation’
py-pyflakes-run
---------------
*Run pyflakes (default on the file currently visited).
For help see M-x pyflakes-help resp. M-x pyflakes-long-help.
Home-page: http://www.logilab.org/project/pyflakes
py-pyflakes-help
----------------
Display Pyflakes command line help messages.
Let’s have this until more Emacs-like help is prepared
py-pyflakespep8-run
-------------------
*Run pyflakespep8, check formatting (default on the file currently visited).
py-pyflakespep8-help
--------------------
Display pyflakespep8 command line help messages.
py-pychecker-run
----------------
*Run pychecker (default on the file currently visited).
py-check-command
----------------
Check a Python file (default current buffer’s file).
Runs COMMAND, a shell command, as if by ‘compile’.
See ‘py-check-command’ for the default.
py-flake8-run
-------------
Flake8 is a wrapper around these tools:
- PyFlakes
- pep8
- Ned Batchelder’s McCabe script
It also adds features:
- files that contain this line are skipped::
# flake8: noqa
- lines that contain a ‘‘# noqa‘‘ comment at the end will not issue warnings.
- a Git and a Mercurial hook.
- a McCabe complexity checker.
- extendable through ‘‘flake8.extension‘‘ entry points.
py-flake8-help
--------------
Display flake8 command line help messages.
py-nesting-level
----------------
Accepts the output of ‘parse-partial-sexp’.
py-flycheck-mode
----------------
Toggle ‘flycheck-mode’.
With negative argument switch off flycheck-mode
See menu "Tools/Syntax Checking"
pylint-flymake-mode
-------------------
Toggle ‘pylint’ ‘flymake-mode’.
pyflakes-flymake-mode
---------------------
Toggle ‘pyflakes’ ‘flymake-mode’.
pychecker-flymake-mode
----------------------
Toggle ‘pychecker’ ‘flymake-mode’.
pep8-flymake-mode
-----------------
Toggle ‘pep8’ ‘flymake-mode’.
pyflakespep8-flymake-mode
-------------------------
Toggle ‘pyflakespep8’ ‘flymake-mode’.
Joint call to pyflakes and pep8 as proposed by
Keegan Carruthers-Smith
variables-state
---------------
Diplays state of python-mode variables in an org-mode buffer.
Reads variables from python-mode.el as current buffer.
Variables which would produce a large output are left out:
- syntax-tables
- python-mode-map
Maybe call M-x describe-variable RET to query its value.
py-indent-forward-line
----------------------
Indent and move one line forward to next indentation.
Returns column of line reached.
If ‘py-kill-empty-line’ is non-nil, delete an empty line.
When closing a form, use py-close-block et al, which will move and indent likewise.
With M-x universal argument just indent.
py-dedent-forward-line
----------------------
Dedent line and move one line forward.
py-dedent
---------
Dedent line according to ‘py-indent-offset’.
With arg, do it that many times.
If point is between indent levels, dedent to next level.
Return indentation reached, if dedent done, nil otherwise.
Affected by ‘py-dedent-keep-relative-column’.
py-class-at-point
-----------------
Return class definition as string.
With interactive call, send it to the message buffer too.
py-function-at-point
--------------------
Return functions definition as string.
With interactive call, send it to the message buffer too.
py-backward-function
--------------------
Jump to the beginning of defun. Returns point.
py-forward-function
-------------------
Jump to the end of function.
py-line-at-point
----------------
Return line as string.
With interactive call, send it to the message buffer too.
py-match-paren-mode
-------------------
py-match-paren-mode nil oder t
py-match-paren
--------------
If at a beginning, jump to end and vice versa.
When called from within, go to the start.
Matches lists, but also block, statement, string and comment.
py-documentation
----------------
Launch PyDOC on the Word at Point
eva
---
Put "eval(...)" forms around strings at point.
pst-here
--------
Kill previous "pdb.set_trace()" and insert it at point.
py-printform-insert
-------------------
Inserts a print statement out of current ‘(car kill-ring)’ by default, inserts STRING if delivered.
With optional C-u print as string
py-line-to-printform-python2
----------------------------
Transforms the item on current in a print statement.
py-boolswitch
-------------
Edit the assignment of a boolean variable, revert them.
I.e. switch it from "True" to "False" and vice versa
py-switch-imenu-index-function
------------------------------
Switch between series 5. index machine ‘py--imenu-create-index’ and ‘py--imenu-create-index-new’, which also lists modules variables
ipython
-------
Start an IPython interpreter.
Optional C-u prompts for path to the interpreter.
ipython2\.7
-----------
Start an IPython2.7 interpreter.
Optional C-u prompts for path to the interpreter.
ipython3
--------
Start an IPython3 interpreter.
Optional C-u prompts for path to the interpreter.
jython
------
Start an Jython interpreter.
Optional C-u prompts for path to the interpreter.
python
------
Start an Python interpreter.
Optional C-u prompts for path to the interpreter.
python2
-------
Start an Python2 interpreter.
Optional C-u prompts for path to the interpreter.
python3
-------
Start an Python3 interpreter.
Optional C-u prompts for path to the interpreter.
ipython-dedicated
-----------------
Start an unique IPython interpreter in another window.
Optional C-u prompts for path to the interpreter.
ipython2\.7-dedicated
---------------------
Start an unique IPython2.7 interpreter in another window.
Optional C-u prompts for path to the interpreter.
ipython3-dedicated
------------------
Start an unique IPython3 interpreter in another window.
Optional C-u prompts for path to the interpreter.
jython-dedicated
----------------
Start an unique Jython interpreter in another window.
Optional C-u prompts for path to the interpreter.
python-dedicated
----------------
Start an unique Python interpreter in another window.
Optional C-u prompts for path to the interpreter.
python2-dedicated
-----------------
Start an unique Python2 interpreter in another window.
Optional C-u prompts for path to the interpreter.
python3-dedicated
-----------------
Start an unique Python3 interpreter in another window.
Optional C-u prompts for path to the interpreter.
ipython-switch
--------------
Switch to IPython interpreter in another window.
Optional C-u prompts for path to the interpreter.
ipython2\.7-switch
------------------
Switch to IPython2.7 interpreter in another window.
Optional C-u prompts for path to the interpreter.
ipython3-switch
---------------
Switch to IPython3 interpreter in another window.
Optional C-u prompts for path to the interpreter.
jython-switch
-------------
Switch to Jython interpreter in another window.
Optional C-u prompts for path to the interpreter.
python-switch
-------------
Switch to Python interpreter in another window.
Optional C-u prompts for path to the interpreter.
python2-switch
--------------
Switch to Python2 interpreter in another window.
Optional C-u prompts for path to the interpreter.
python3-switch
--------------
Switch to Python3 interpreter in another window.
Optional C-u prompts for path to the interpreter.
ipython-no-switch
-----------------
Open an IPython interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
ipython2\.7-no-switch
---------------------
Open an IPython2.7 interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
ipython3-no-switch
------------------
Open an IPython3 interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
jython-no-switch
----------------
Open an Jython interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
python-no-switch
----------------
Open an Python interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
python2-no-switch
-----------------
Open an Python2 interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
python3-no-switch
-----------------
Open an Python3 interpreter in another window, but do not switch to it.
Optional C-u prompts for path to the interpreter.
ipython-switch-dedicated
------------------------
Switch to an unique IPython interpreter in another window.
Optional C-u prompts for path to the interpreter.
ipython2\.7-switch-dedicated
----------------------------
Switch to an unique IPython2.7 interpreter in another window.
Optional C-u prompts for path to the interpreter.
ipython3-switch-dedicated
-------------------------
Switch to an unique IPython3 interpreter in another window.
Optional C-u prompts for path to the interpreter.
jython-switch-dedicated
-----------------------
Switch to an unique Jython interpreter in another window.
Optional C-u prompts for path to the interpreter.
python-switch-dedicated
-----------------------
Switch to an unique Python interpreter in another window.
Optional C-u prompts for path to the interpreter.
python2-switch-dedicated
------------------------
Switch to an unique Python2 interpreter in another window.
Optional C-u prompts for path to the interpreter.
python3-switch-dedicated
------------------------
Switch to an unique Python3 interpreter in another window.
Optional C-u prompts for path to the interpreter.
py-electric-colon
-----------------
Insert a colon and indent accordingly.
If a numeric argument ARG is provided, that many colons are inserted
non-electrically.
Electric behavior is inhibited inside a string or
comment or by universal prefix C-u.
Switched by ‘py-electric-colon-active-p’, default is nil
See also ‘py-electric-colon-greedy-p’
py-electric-close
-----------------
Close completion buffer when it’s sure, it’s no longer needed, i.e. when inserting a space.
Works around a bug in ‘choose-completion’.
py-electric-comment
-------------------
Insert a comment. If starting a comment, indent accordingly.
If a numeric argument ARG is provided, that many "#" are inserted
non-electrically.
With C-u "#" electric behavior is inhibited inside a string or comment.
py-empty-out-list-backward
--------------------------
Deletes all elements from list before point.
py-electric-backspace
---------------------
Delete preceding character or level of indentation.
When ‘delete-active-region’ and (use-region-p), delete region.
Unless at indentation:
With ‘py-electric-kill-backward-p’ delete whitespace before point.
With ‘py-electric-kill-backward-p’ at end of a list, empty that list.
Returns column reached.
py-electric-delete
------------------
Delete following character or levels of whitespace.
When ‘delete-active-region’ and (use-region-p), delete region
py-electric-yank
----------------
Perform command ‘yank’ followed by an ‘indent-according-to-mode’
virtualenv-current
------------------
Barfs the current activated virtualenv
virtualenv-activate
-------------------
Activate the virtualenv located in DIR
virtualenv-deactivate
---------------------
Deactivate the current virtual enviroment
virtualenv-workon
-----------------
Issue a virtualenvwrapper-like virtualenv-workon command
py-up-statement
---------------
Go to the beginning of next statement upwards in buffer.
Return position if statement found, nil otherwise.
py-down-statement
-----------------
Go to the beginning of next statement downwards in buffer.
Return position if statement found, nil otherwise.
py-up-block
-----------
Go to the beginning of next block upwards in buffer.
Return position if block found, nil otherwise.
py-up-class
-----------
Go to the beginning of next class upwards in buffer.
Return position if class found, nil otherwise.
py-up-def
---------
Go to the beginning of next def upwards in buffer.
Return position if def found, nil otherwise.
py-up-def-or-class
------------------
Go to the beginning of next def-or-class upwards in buffer.
Return position if def-or-class found, nil otherwise.
py-up-minor-block
-----------------
Go to the beginning of next minor-block upwards in buffer.
Return position if minor-block found, nil otherwise.
py-down-block
-------------
Go to the beginning of next block below in buffer.
Return position if block found, nil otherwise.
py-down-class
-------------
Go to the beginning of next class below in buffer.
Return position if class found, nil otherwise.
py-down-def
-----------
Go to the beginning of next def below in buffer.
Return position if def found, nil otherwise.
py-down-def-or-class
--------------------
Go to the beginning of next def-or-class below in buffer.
Return position if def-or-class found, nil otherwise.
py-down-minor-block
-------------------
Go to the beginning of next minor-block below in buffer.
Return position if minor-block found, nil otherwise.
py-up-block-bol
---------------
Go to the beginning of next block upwards in buffer.
Go to beginning of line.
Return position if block found, nil otherwise.
py-up-class-bol
---------------
Go to the beginning of next class upwards in buffer.
Go to beginning of line.
Return position if class found, nil otherwise.
py-up-def-bol
-------------
Go to the beginning of next def upwards in buffer.
Go to beginning of line.
Return position if def found, nil otherwise.
py-up-def-or-class-bol
----------------------
Go to the beginning of next def-or-class upwards in buffer.
Go to beginning of line.
Return position if def-or-class found, nil otherwise.
py-up-minor-block-bol
---------------------
Go to the beginning of next minor-block upwards in buffer.
Go to beginning of line.
Return position if minor-block found, nil otherwise.
py-down-block-bol
-----------------
Go to the beginning of next block below in buffer.
Go to beginning of line
Return position if block found, nil otherwise
py-down-class-bol
-----------------
Go to the beginning of next class below in buffer.
Go to beginning of line
Return position if class found, nil otherwise
py-down-def-bol
---------------
Go to the beginning of next def below in buffer.
Go to beginning of line
Return position if def found, nil otherwise
py-down-def-or-class-bol
------------------------
Go to the beginning of next def-or-class below in buffer.
Go to beginning of line
Return position if def-or-class found, nil otherwise
py-down-minor-block-bol
-----------------------
Go to the beginning of next minor-block below in buffer.
Go to beginning of line
Return position if minor-block found, nil otherwise
py-execute-try-block
--------------------
Send try-block at point to Python default interpreter.
py-execute-if-block
-------------------
Send if-block at point to Python default interpreter.
py-execute-for-block
--------------------
Send for-block at point to Python default interpreter.
py-execute-block
----------------
Send block at point to interpreter.
py-execute-block-switch
-----------------------
Send block at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-no-switch
--------------------------
Send block at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-dedicated
--------------------------
Send block at point to unique interpreter.
py-execute-block-dedicated-switch
---------------------------------
Send block at point to unique interpreter and switch to result.
py-execute-block-ipython
------------------------
Send block at point to IPython interpreter.
py-execute-block-ipython-switch
-------------------------------
Send block at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-ipython-no-switch
----------------------------------
Send block at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-ipython-dedicated
----------------------------------
Send block at point to IPython unique interpreter.
py-execute-block-ipython-dedicated-switch
-----------------------------------------
Send block at point to IPython unique interpreter and switch to result.
py-execute-block-ipython2\.7
----------------------------
Send block at point to IPython interpreter.
py-execute-block-ipython2\.7-switch
-----------------------------------
Send block at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-ipython2\.7-no-switch
--------------------------------------
Send block at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-ipython2\.7-dedicated
--------------------------------------
Send block at point to IPython unique interpreter.
py-execute-block-ipython2\.7-dedicated-switch
---------------------------------------------
Send block at point to IPython unique interpreter and switch to result.
py-execute-block-ipython3
-------------------------
Send block at point to IPython interpreter.
py-execute-block-ipython3-switch
--------------------------------
Send block at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-ipython3-no-switch
-----------------------------------
Send block at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-ipython3-dedicated
-----------------------------------
Send block at point to IPython unique interpreter.
py-execute-block-ipython3-dedicated-switch
------------------------------------------
Send block at point to IPython unique interpreter and switch to result.
py-execute-block-jython
-----------------------
Send block at point to Jython interpreter.
py-execute-block-jython-switch
------------------------------
Send block at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-jython-no-switch
---------------------------------
Send block at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-jython-dedicated
---------------------------------
Send block at point to Jython unique interpreter.
py-execute-block-jython-dedicated-switch
----------------------------------------
Send block at point to Jython unique interpreter and switch to result.
py-execute-block-python
-----------------------
Send block at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-block-python-switch
------------------------------
Send block at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-block-python-no-switch
---------------------------------
Send block at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-block-python-dedicated
---------------------------------
Send block at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-block-python-dedicated-switch
----------------------------------------
Send block at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-block-python2
------------------------
Send block at point to Python2 interpreter.
py-execute-block-python2-switch
-------------------------------
Send block at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-python2-no-switch
----------------------------------
Send block at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-python2-dedicated
----------------------------------
Send block at point to Python2 unique interpreter.
py-execute-block-python2-dedicated-switch
-----------------------------------------
Send block at point to Python2 unique interpreter and switch to result.
py-execute-block-python3
------------------------
Send block at point to Python3 interpreter.
py-execute-block-python3-switch
-------------------------------
Send block at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-python3-no-switch
----------------------------------
Send block at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-python3-dedicated
----------------------------------
Send block at point to Python3 unique interpreter.
py-execute-block-python3-dedicated-switch
-----------------------------------------
Send block at point to Python3 unique interpreter and switch to result.
py-execute-block-or-clause
--------------------------
Send block-or-clause at point to interpreter.
py-execute-block-or-clause-switch
---------------------------------
Send block-or-clause at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-or-clause-no-switch
------------------------------------
Send block-or-clause at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-or-clause-dedicated
------------------------------------
Send block-or-clause at point to unique interpreter.
py-execute-block-or-clause-dedicated-switch
-------------------------------------------
Send block-or-clause at point to unique interpreter and switch to result.
py-execute-block-or-clause-ipython
----------------------------------
Send block-or-clause at point to IPython interpreter.
py-execute-block-or-clause-ipython-switch
-----------------------------------------
Send block-or-clause at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-or-clause-ipython-no-switch
--------------------------------------------
Send block-or-clause at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-or-clause-ipython-dedicated
--------------------------------------------
Send block-or-clause at point to IPython unique interpreter.
py-execute-block-or-clause-ipython-dedicated-switch
---------------------------------------------------
Send block-or-clause at point to IPython unique interpreter and switch to result.
py-execute-block-or-clause-ipython2\.7
--------------------------------------
Send block-or-clause at point to IPython interpreter.
py-execute-block-or-clause-ipython2\.7-switch
---------------------------------------------
Send block-or-clause at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-or-clause-ipython2\.7-no-switch
------------------------------------------------
Send block-or-clause at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-or-clause-ipython2\.7-dedicated
------------------------------------------------
Send block-or-clause at point to IPython unique interpreter.
py-execute-block-or-clause-ipython2\.7-dedicated-switch
-------------------------------------------------------
Send block-or-clause at point to IPython unique interpreter and switch to result.
py-execute-block-or-clause-ipython3
-----------------------------------
Send block-or-clause at point to IPython interpreter.
py-execute-block-or-clause-ipython3-switch
------------------------------------------
Send block-or-clause at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-or-clause-ipython3-no-switch
---------------------------------------------
Send block-or-clause at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-or-clause-ipython3-dedicated
---------------------------------------------
Send block-or-clause at point to IPython unique interpreter.
py-execute-block-or-clause-ipython3-dedicated-switch
----------------------------------------------------
Send block-or-clause at point to IPython unique interpreter and switch to result.
py-execute-block-or-clause-jython
---------------------------------
Send block-or-clause at point to Jython interpreter.
py-execute-block-or-clause-jython-switch
----------------------------------------
Send block-or-clause at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-or-clause-jython-no-switch
-------------------------------------------
Send block-or-clause at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-or-clause-jython-dedicated
-------------------------------------------
Send block-or-clause at point to Jython unique interpreter.
py-execute-block-or-clause-jython-dedicated-switch
--------------------------------------------------
Send block-or-clause at point to Jython unique interpreter and switch to result.
py-execute-block-or-clause-python
---------------------------------
Send block-or-clause at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-block-or-clause-python-switch
----------------------------------------
Send block-or-clause at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-block-or-clause-python-no-switch
-------------------------------------------
Send block-or-clause at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-block-or-clause-python-dedicated
-------------------------------------------
Send block-or-clause at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-block-or-clause-python-dedicated-switch
--------------------------------------------------
Send block-or-clause at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-block-or-clause-python2
----------------------------------
Send block-or-clause at point to Python2 interpreter.
py-execute-block-or-clause-python2-switch
-----------------------------------------
Send block-or-clause at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-or-clause-python2-no-switch
--------------------------------------------
Send block-or-clause at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-or-clause-python2-dedicated
--------------------------------------------
Send block-or-clause at point to Python2 unique interpreter.
py-execute-block-or-clause-python2-dedicated-switch
---------------------------------------------------
Send block-or-clause at point to Python2 unique interpreter and switch to result.
py-execute-block-or-clause-python3
----------------------------------
Send block-or-clause at point to Python3 interpreter.
py-execute-block-or-clause-python3-switch
-----------------------------------------
Send block-or-clause at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-block-or-clause-python3-no-switch
--------------------------------------------
Send block-or-clause at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-block-or-clause-python3-dedicated
--------------------------------------------
Send block-or-clause at point to Python3 unique interpreter.
py-execute-block-or-clause-python3-dedicated-switch
---------------------------------------------------
Send block-or-clause at point to Python3 unique interpreter and switch to result.
py-execute-buffer
-----------------
:around advice: ‘ad-Advice-py-execute-buffer’
Send buffer at point to interpreter.
(fn &optional SHELL DEDICATED FAST SPLIT SWITCH PROC WHOLEBUF)
py-execute-buffer-switch
------------------------
Send buffer at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-buffer-no-switch
---------------------------
Send buffer at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-buffer-dedicated
---------------------------
Send buffer at point to unique interpreter.
py-execute-buffer-dedicated-switch
----------------------------------
Send buffer at point to unique interpreter and switch to result.
py-execute-buffer-ipython
-------------------------
Send buffer at point to IPython interpreter.
py-execute-buffer-ipython-switch
--------------------------------
Send buffer at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-buffer-ipython-no-switch
-----------------------------------
Send buffer at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-buffer-ipython-dedicated
-----------------------------------
Send buffer at point to IPython unique interpreter.
py-execute-buffer-ipython-dedicated-switch
------------------------------------------
Send buffer at point to IPython unique interpreter and switch to result.
py-execute-buffer-ipython2\.7
-----------------------------
Send buffer at point to IPython interpreter.
py-execute-buffer-ipython2\.7-switch
------------------------------------
Send buffer at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-buffer-ipython2\.7-no-switch
---------------------------------------
Send buffer at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-buffer-ipython2\.7-dedicated
---------------------------------------
Send buffer at point to IPython unique interpreter.
py-execute-buffer-ipython2\.7-dedicated-switch
----------------------------------------------
Send buffer at point to IPython unique interpreter and switch to result.
py-execute-buffer-ipython3
--------------------------
Send buffer at point to IPython interpreter.
py-execute-buffer-ipython3-switch
---------------------------------
Send buffer at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-buffer-ipython3-no-switch
------------------------------------
Send buffer at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-buffer-ipython3-dedicated
------------------------------------
Send buffer at point to IPython unique interpreter.
py-execute-buffer-ipython3-dedicated-switch
-------------------------------------------
Send buffer at point to IPython unique interpreter and switch to result.
py-execute-buffer-jython
------------------------
Send buffer at point to Jython interpreter.
py-execute-buffer-jython-switch
-------------------------------
Send buffer at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-buffer-jython-no-switch
----------------------------------
Send buffer at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-buffer-jython-dedicated
----------------------------------
Send buffer at point to Jython unique interpreter.
py-execute-buffer-jython-dedicated-switch
-----------------------------------------
Send buffer at point to Jython unique interpreter and switch to result.
py-execute-buffer-python
------------------------
Send buffer at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-buffer-python-switch
-------------------------------
Send buffer at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-buffer-python-no-switch
----------------------------------
Send buffer at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-buffer-python-dedicated
----------------------------------
Send buffer at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-buffer-python-dedicated-switch
-----------------------------------------
Send buffer at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-buffer-python2
-------------------------
Send buffer at point to Python2 interpreter.
py-execute-buffer-python2-switch
--------------------------------
Send buffer at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-buffer-python2-no-switch
-----------------------------------
Send buffer at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-buffer-python2-dedicated
-----------------------------------
Send buffer at point to Python2 unique interpreter.
py-execute-buffer-python2-dedicated-switch
------------------------------------------
Send buffer at point to Python2 unique interpreter and switch to result.
py-execute-buffer-python3
-------------------------
Send buffer at point to Python3 interpreter.
py-execute-buffer-python3-switch
--------------------------------
Send buffer at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-buffer-python3-no-switch
-----------------------------------
Send buffer at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-buffer-python3-dedicated
-----------------------------------
Send buffer at point to Python3 unique interpreter.
py-execute-buffer-python3-dedicated-switch
------------------------------------------
Send buffer at point to Python3 unique interpreter and switch to result.
py-execute-class
----------------
Send class at point to interpreter.
py-execute-class-switch
-----------------------
Send class at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-class-no-switch
--------------------------
Send class at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-class-dedicated
--------------------------
Send class at point to unique interpreter.
py-execute-class-dedicated-switch
---------------------------------
Send class at point to unique interpreter and switch to result.
py-execute-class-ipython
------------------------
Send class at point to IPython interpreter.
py-execute-class-ipython-switch
-------------------------------
Send class at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-class-ipython-no-switch
----------------------------------
Send class at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-class-ipython-dedicated
----------------------------------
Send class at point to IPython unique interpreter.
py-execute-class-ipython-dedicated-switch
-----------------------------------------
Send class at point to IPython unique interpreter and switch to result.
py-execute-class-ipython2\.7
----------------------------
Send class at point to IPython interpreter.
py-execute-class-ipython2\.7-switch
-----------------------------------
Send class at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-class-ipython2\.7-no-switch
--------------------------------------
Send class at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-class-ipython2\.7-dedicated
--------------------------------------
Send class at point to IPython unique interpreter.
py-execute-class-ipython2\.7-dedicated-switch
---------------------------------------------
Send class at point to IPython unique interpreter and switch to result.
py-execute-class-ipython3
-------------------------
Send class at point to IPython interpreter.
py-execute-class-ipython3-switch
--------------------------------
Send class at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-class-ipython3-no-switch
-----------------------------------
Send class at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-class-ipython3-dedicated
-----------------------------------
Send class at point to IPython unique interpreter.
py-execute-class-ipython3-dedicated-switch
------------------------------------------
Send class at point to IPython unique interpreter and switch to result.
py-execute-class-jython
-----------------------
Send class at point to Jython interpreter.
py-execute-class-jython-switch
------------------------------
Send class at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-class-jython-no-switch
---------------------------------
Send class at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-class-jython-dedicated
---------------------------------
Send class at point to Jython unique interpreter.
py-execute-class-jython-dedicated-switch
----------------------------------------
Send class at point to Jython unique interpreter and switch to result.
py-execute-class-python
-----------------------
Send class at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-class-python-switch
------------------------------
Send class at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-class-python-no-switch
---------------------------------
Send class at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-class-python-dedicated
---------------------------------
Send class at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-class-python-dedicated-switch
----------------------------------------
Send class at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-class-python2
------------------------
Send class at point to Python2 interpreter.
py-execute-class-python2-switch
-------------------------------
Send class at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-class-python2-no-switch
----------------------------------
Send class at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-class-python2-dedicated
----------------------------------
Send class at point to Python2 unique interpreter.
py-execute-class-python2-dedicated-switch
-----------------------------------------
Send class at point to Python2 unique interpreter and switch to result.
py-execute-class-python3
------------------------
Send class at point to Python3 interpreter.
py-execute-class-python3-switch
-------------------------------
Send class at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-class-python3-no-switch
----------------------------------
Send class at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-class-python3-dedicated
----------------------------------
Send class at point to Python3 unique interpreter.
py-execute-class-python3-dedicated-switch
-----------------------------------------
Send class at point to Python3 unique interpreter and switch to result.
py-execute-clause
-----------------
Send clause at point to interpreter.
py-execute-clause-switch
------------------------
Send clause at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-clause-no-switch
---------------------------
Send clause at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-clause-dedicated
---------------------------
Send clause at point to unique interpreter.
py-execute-clause-dedicated-switch
----------------------------------
Send clause at point to unique interpreter and switch to result.
py-execute-clause-ipython
-------------------------
Send clause at point to IPython interpreter.
py-execute-clause-ipython-switch
--------------------------------
Send clause at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-clause-ipython-no-switch
-----------------------------------
Send clause at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-clause-ipython-dedicated
-----------------------------------
Send clause at point to IPython unique interpreter.
py-execute-clause-ipython-dedicated-switch
------------------------------------------
Send clause at point to IPython unique interpreter and switch to result.
py-execute-clause-ipython2\.7
-----------------------------
Send clause at point to IPython interpreter.
py-execute-clause-ipython2\.7-switch
------------------------------------
Send clause at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-clause-ipython2\.7-no-switch
---------------------------------------
Send clause at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-clause-ipython2\.7-dedicated
---------------------------------------
Send clause at point to IPython unique interpreter.
py-execute-clause-ipython2\.7-dedicated-switch
----------------------------------------------
Send clause at point to IPython unique interpreter and switch to result.
py-execute-clause-ipython3
--------------------------
Send clause at point to IPython interpreter.
py-execute-clause-ipython3-switch
---------------------------------
Send clause at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-clause-ipython3-no-switch
------------------------------------
Send clause at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-clause-ipython3-dedicated
------------------------------------
Send clause at point to IPython unique interpreter.
py-execute-clause-ipython3-dedicated-switch
-------------------------------------------
Send clause at point to IPython unique interpreter and switch to result.
py-execute-clause-jython
------------------------
Send clause at point to Jython interpreter.
py-execute-clause-jython-switch
-------------------------------
Send clause at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-clause-jython-no-switch
----------------------------------
Send clause at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-clause-jython-dedicated
----------------------------------
Send clause at point to Jython unique interpreter.
py-execute-clause-jython-dedicated-switch
-----------------------------------------
Send clause at point to Jython unique interpreter and switch to result.
py-execute-clause-python
------------------------
Send clause at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-clause-python-switch
-------------------------------
Send clause at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-clause-python-no-switch
----------------------------------
Send clause at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-clause-python-dedicated
----------------------------------
Send clause at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-clause-python-dedicated-switch
-----------------------------------------
Send clause at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-clause-python2
-------------------------
Send clause at point to Python2 interpreter.
py-execute-clause-python2-switch
--------------------------------
Send clause at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-clause-python2-no-switch
-----------------------------------
Send clause at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-clause-python2-dedicated
-----------------------------------
Send clause at point to Python2 unique interpreter.
py-execute-clause-python2-dedicated-switch
------------------------------------------
Send clause at point to Python2 unique interpreter and switch to result.
py-execute-clause-python3
-------------------------
Send clause at point to Python3 interpreter.
py-execute-clause-python3-switch
--------------------------------
Send clause at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-clause-python3-no-switch
-----------------------------------
Send clause at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-clause-python3-dedicated
-----------------------------------
Send clause at point to Python3 unique interpreter.
py-execute-clause-python3-dedicated-switch
------------------------------------------
Send clause at point to Python3 unique interpreter and switch to result.
py-execute-def
--------------
Send def at point to interpreter.
py-execute-def-switch
---------------------
Send def at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-no-switch
------------------------
Send def at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-dedicated
------------------------
Send def at point to unique interpreter.
py-execute-def-dedicated-switch
-------------------------------
Send def at point to unique interpreter and switch to result.
py-execute-def-ipython
----------------------
Send def at point to IPython interpreter.
py-execute-def-ipython-switch
-----------------------------
Send def at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-ipython-no-switch
--------------------------------
Send def at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-ipython-dedicated
--------------------------------
Send def at point to IPython unique interpreter.
py-execute-def-ipython-dedicated-switch
---------------------------------------
Send def at point to IPython unique interpreter and switch to result.
py-execute-def-ipython2\.7
--------------------------
Send def at point to IPython interpreter.
py-execute-def-ipython2\.7-switch
---------------------------------
Send def at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-ipython2\.7-no-switch
------------------------------------
Send def at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-ipython2\.7-dedicated
------------------------------------
Send def at point to IPython unique interpreter.
py-execute-def-ipython2\.7-dedicated-switch
-------------------------------------------
Send def at point to IPython unique interpreter and switch to result.
py-execute-def-ipython3
-----------------------
Send def at point to IPython interpreter.
py-execute-def-ipython3-switch
------------------------------
Send def at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-ipython3-no-switch
---------------------------------
Send def at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-ipython3-dedicated
---------------------------------
Send def at point to IPython unique interpreter.
py-execute-def-ipython3-dedicated-switch
----------------------------------------
Send def at point to IPython unique interpreter and switch to result.
py-execute-def-jython
---------------------
Send def at point to Jython interpreter.
py-execute-def-jython-switch
----------------------------
Send def at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-jython-no-switch
-------------------------------
Send def at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-jython-dedicated
-------------------------------
Send def at point to Jython unique interpreter.
py-execute-def-jython-dedicated-switch
--------------------------------------
Send def at point to Jython unique interpreter and switch to result.
py-execute-def-python
---------------------
Send def at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-def-python-switch
----------------------------
Send def at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-def-python-no-switch
-------------------------------
Send def at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-def-python-dedicated
-------------------------------
Send def at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-def-python-dedicated-switch
--------------------------------------
Send def at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-def-python2
----------------------
Send def at point to Python2 interpreter.
py-execute-def-python2-switch
-----------------------------
Send def at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-python2-no-switch
--------------------------------
Send def at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-python2-dedicated
--------------------------------
Send def at point to Python2 unique interpreter.
py-execute-def-python2-dedicated-switch
---------------------------------------
Send def at point to Python2 unique interpreter and switch to result.
py-execute-def-python3
----------------------
Send def at point to Python3 interpreter.
py-execute-def-python3-switch
-----------------------------
Send def at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-python3-no-switch
--------------------------------
Send def at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-python3-dedicated
--------------------------------
Send def at point to Python3 unique interpreter.
py-execute-def-python3-dedicated-switch
---------------------------------------
Send def at point to Python3 unique interpreter and switch to result.
py-execute-def-or-class
-----------------------
Send def-or-class at point to interpreter.
py-execute-def-or-class-switch
------------------------------
Send def-or-class at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-or-class-no-switch
---------------------------------
Send def-or-class at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-or-class-dedicated
---------------------------------
Send def-or-class at point to unique interpreter.
py-execute-def-or-class-dedicated-switch
----------------------------------------
Send def-or-class at point to unique interpreter and switch to result.
py-execute-def-or-class-ipython
-------------------------------
Send def-or-class at point to IPython interpreter.
py-execute-def-or-class-ipython-switch
--------------------------------------
Send def-or-class at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-or-class-ipython-no-switch
-----------------------------------------
Send def-or-class at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-or-class-ipython-dedicated
-----------------------------------------
Send def-or-class at point to IPython unique interpreter.
py-execute-def-or-class-ipython-dedicated-switch
------------------------------------------------
Send def-or-class at point to IPython unique interpreter and switch to result.
py-execute-def-or-class-ipython2\.7
-----------------------------------
Send def-or-class at point to IPython interpreter.
py-execute-def-or-class-ipython2\.7-switch
------------------------------------------
Send def-or-class at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-or-class-ipython2\.7-no-switch
---------------------------------------------
Send def-or-class at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-or-class-ipython2\.7-dedicated
---------------------------------------------
Send def-or-class at point to IPython unique interpreter.
py-execute-def-or-class-ipython2\.7-dedicated-switch
----------------------------------------------------
Send def-or-class at point to IPython unique interpreter and switch to result.
py-execute-def-or-class-ipython3
--------------------------------
Send def-or-class at point to IPython interpreter.
py-execute-def-or-class-ipython3-switch
---------------------------------------
Send def-or-class at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-or-class-ipython3-no-switch
------------------------------------------
Send def-or-class at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-or-class-ipython3-dedicated
------------------------------------------
Send def-or-class at point to IPython unique interpreter.
py-execute-def-or-class-ipython3-dedicated-switch
-------------------------------------------------
Send def-or-class at point to IPython unique interpreter and switch to result.
py-execute-def-or-class-jython
------------------------------
Send def-or-class at point to Jython interpreter.
py-execute-def-or-class-jython-switch
-------------------------------------
Send def-or-class at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-or-class-jython-no-switch
----------------------------------------
Send def-or-class at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-or-class-jython-dedicated
----------------------------------------
Send def-or-class at point to Jython unique interpreter.
py-execute-def-or-class-jython-dedicated-switch
-----------------------------------------------
Send def-or-class at point to Jython unique interpreter and switch to result.
py-execute-def-or-class-python
------------------------------
Send def-or-class at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-def-or-class-python-switch
-------------------------------------
Send def-or-class at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-def-or-class-python-no-switch
----------------------------------------
Send def-or-class at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-def-or-class-python-dedicated
----------------------------------------
Send def-or-class at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-def-or-class-python-dedicated-switch
-----------------------------------------------
Send def-or-class at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-def-or-class-python2
-------------------------------
Send def-or-class at point to Python2 interpreter.
py-execute-def-or-class-python2-switch
--------------------------------------
Send def-or-class at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-or-class-python2-no-switch
-----------------------------------------
Send def-or-class at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-or-class-python2-dedicated
-----------------------------------------
Send def-or-class at point to Python2 unique interpreter.
py-execute-def-or-class-python2-dedicated-switch
------------------------------------------------
Send def-or-class at point to Python2 unique interpreter and switch to result.
py-execute-def-or-class-python3
-------------------------------
Send def-or-class at point to Python3 interpreter.
py-execute-def-or-class-python3-switch
--------------------------------------
Send def-or-class at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-def-or-class-python3-no-switch
-----------------------------------------
Send def-or-class at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-def-or-class-python3-dedicated
-----------------------------------------
Send def-or-class at point to Python3 unique interpreter.
py-execute-def-or-class-python3-dedicated-switch
------------------------------------------------
Send def-or-class at point to Python3 unique interpreter and switch to result.
py-execute-expression
---------------------
Send expression at point to interpreter.
py-execute-expression-switch
----------------------------
Send expression at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-expression-no-switch
-------------------------------
Send expression at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-expression-dedicated
-------------------------------
Send expression at point to unique interpreter.
py-execute-expression-dedicated-switch
--------------------------------------
Send expression at point to unique interpreter and switch to result.
py-execute-expression-ipython
-----------------------------
Send expression at point to IPython interpreter.
py-execute-expression-ipython-switch
------------------------------------
Send expression at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-expression-ipython-no-switch
---------------------------------------
Send expression at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-expression-ipython-dedicated
---------------------------------------
Send expression at point to IPython unique interpreter.
py-execute-expression-ipython-dedicated-switch
----------------------------------------------
Send expression at point to IPython unique interpreter and switch to result.
py-execute-expression-ipython2\.7
---------------------------------
Send expression at point to IPython interpreter.
py-execute-expression-ipython2\.7-switch
----------------------------------------
Send expression at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-expression-ipython2\.7-no-switch
-------------------------------------------
Send expression at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-expression-ipython2\.7-dedicated
-------------------------------------------
Send expression at point to IPython unique interpreter.
py-execute-expression-ipython2\.7-dedicated-switch
--------------------------------------------------
Send expression at point to IPython unique interpreter and switch to result.
py-execute-expression-ipython3
------------------------------
Send expression at point to IPython interpreter.
py-execute-expression-ipython3-switch
-------------------------------------
Send expression at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-expression-ipython3-no-switch
----------------------------------------
Send expression at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-expression-ipython3-dedicated
----------------------------------------
Send expression at point to IPython unique interpreter.
py-execute-expression-ipython3-dedicated-switch
-----------------------------------------------
Send expression at point to IPython unique interpreter and switch to result.
py-execute-expression-jython
----------------------------
Send expression at point to Jython interpreter.
py-execute-expression-jython-switch
-----------------------------------
Send expression at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-expression-jython-no-switch
--------------------------------------
Send expression at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-expression-jython-dedicated
--------------------------------------
Send expression at point to Jython unique interpreter.
py-execute-expression-jython-dedicated-switch
---------------------------------------------
Send expression at point to Jython unique interpreter and switch to result.
py-execute-expression-python
----------------------------
Send expression at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-expression-python-switch
-----------------------------------
Send expression at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-expression-python-no-switch
--------------------------------------
Send expression at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-expression-python-dedicated
--------------------------------------
Send expression at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-expression-python-dedicated-switch
---------------------------------------------
Send expression at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-expression-python2
-----------------------------
Send expression at point to Python2 interpreter.
py-execute-expression-python2-switch
------------------------------------
Send expression at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-expression-python2-no-switch
---------------------------------------
Send expression at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-expression-python2-dedicated
---------------------------------------
Send expression at point to Python2 unique interpreter.
py-execute-expression-python2-dedicated-switch
----------------------------------------------
Send expression at point to Python2 unique interpreter and switch to result.
py-execute-expression-python3
-----------------------------
Send expression at point to Python3 interpreter.
py-execute-expression-python3-switch
------------------------------------
Send expression at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-expression-python3-no-switch
---------------------------------------
Send expression at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-expression-python3-dedicated
---------------------------------------
Send expression at point to Python3 unique interpreter.
py-execute-expression-python3-dedicated-switch
----------------------------------------------
Send expression at point to Python3 unique interpreter and switch to result.
py-execute-indent
-----------------
Send indent at point to interpreter.
py-execute-indent-switch
------------------------
Send indent at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-indent-no-switch
---------------------------
Send indent at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-indent-dedicated
---------------------------
Send indent at point to unique interpreter.
py-execute-indent-dedicated-switch
----------------------------------
Send indent at point to unique interpreter and switch to result.
py-execute-indent-ipython
-------------------------
Send indent at point to IPython interpreter.
py-execute-indent-ipython-switch
--------------------------------
Send indent at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-indent-ipython-no-switch
-----------------------------------
Send indent at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-indent-ipython-dedicated
-----------------------------------
Send indent at point to IPython unique interpreter.
py-execute-indent-ipython-dedicated-switch
------------------------------------------
Send indent at point to IPython unique interpreter and switch to result.
py-execute-indent-ipython2\.7
-----------------------------
Send indent at point to IPython interpreter.
py-execute-indent-ipython2\.7-switch
------------------------------------
Send indent at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-indent-ipython2\.7-no-switch
---------------------------------------
Send indent at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-indent-ipython2\.7-dedicated
---------------------------------------
Send indent at point to IPython unique interpreter.
py-execute-indent-ipython2\.7-dedicated-switch
----------------------------------------------
Send indent at point to IPython unique interpreter and switch to result.
py-execute-indent-ipython3
--------------------------
Send indent at point to IPython interpreter.
py-execute-indent-ipython3-switch
---------------------------------
Send indent at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-indent-ipython3-no-switch
------------------------------------
Send indent at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-indent-ipython3-dedicated
------------------------------------
Send indent at point to IPython unique interpreter.
py-execute-indent-ipython3-dedicated-switch
-------------------------------------------
Send indent at point to IPython unique interpreter and switch to result.
py-execute-indent-jython
------------------------
Send indent at point to Jython interpreter.
py-execute-indent-jython-switch
-------------------------------
Send indent at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-indent-jython-no-switch
----------------------------------
Send indent at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-indent-jython-dedicated
----------------------------------
Send indent at point to Jython unique interpreter.
py-execute-indent-jython-dedicated-switch
-----------------------------------------
Send indent at point to Jython unique interpreter and switch to result.
py-execute-indent-python
------------------------
Send indent at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-indent-python-switch
-------------------------------
Send indent at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-indent-python-no-switch
----------------------------------
Send indent at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-indent-python-dedicated
----------------------------------
Send indent at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-indent-python-dedicated-switch
-----------------------------------------
Send indent at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-indent-python2
-------------------------
Send indent at point to Python2 interpreter.
py-execute-indent-python2-switch
--------------------------------
Send indent at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-indent-python2-no-switch
-----------------------------------
Send indent at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-indent-python2-dedicated
-----------------------------------
Send indent at point to Python2 unique interpreter.
py-execute-indent-python2-dedicated-switch
------------------------------------------
Send indent at point to Python2 unique interpreter and switch to result.
py-execute-indent-python3
-------------------------
Send indent at point to Python3 interpreter.
py-execute-indent-python3-switch
--------------------------------
Send indent at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-indent-python3-no-switch
-----------------------------------
Send indent at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-indent-python3-dedicated
-----------------------------------
Send indent at point to Python3 unique interpreter.
py-execute-indent-python3-dedicated-switch
------------------------------------------
Send indent at point to Python3 unique interpreter and switch to result.
py-execute-line
---------------
Send line at point to interpreter.
py-execute-line-switch
----------------------
Send line at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-line-no-switch
-------------------------
Send line at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-line-dedicated
-------------------------
Send line at point to unique interpreter.
py-execute-line-dedicated-switch
--------------------------------
Send line at point to unique interpreter and switch to result.
py-execute-line-ipython
-----------------------
Send line at point to IPython interpreter.
py-execute-line-ipython-switch
------------------------------
Send line at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-line-ipython-no-switch
---------------------------------
Send line at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-line-ipython-dedicated
---------------------------------
Send line at point to IPython unique interpreter.
py-execute-line-ipython-dedicated-switch
----------------------------------------
Send line at point to IPython unique interpreter and switch to result.
py-execute-line-ipython2\.7
---------------------------
Send line at point to IPython interpreter.
py-execute-line-ipython2\.7-switch
----------------------------------
Send line at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-line-ipython2\.7-no-switch
-------------------------------------
Send line at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-line-ipython2\.7-dedicated
-------------------------------------
Send line at point to IPython unique interpreter.
py-execute-line-ipython2\.7-dedicated-switch
--------------------------------------------
Send line at point to IPython unique interpreter and switch to result.
py-execute-line-ipython3
------------------------
Send line at point to IPython interpreter.
py-execute-line-ipython3-switch
-------------------------------
Send line at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-line-ipython3-no-switch
----------------------------------
Send line at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-line-ipython3-dedicated
----------------------------------
Send line at point to IPython unique interpreter.
py-execute-line-ipython3-dedicated-switch
-----------------------------------------
Send line at point to IPython unique interpreter and switch to result.
py-execute-line-jython
----------------------
Send line at point to Jython interpreter.
py-execute-line-jython-switch
-----------------------------
Send line at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-line-jython-no-switch
--------------------------------
Send line at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-line-jython-dedicated
--------------------------------
Send line at point to Jython unique interpreter.
py-execute-line-jython-dedicated-switch
---------------------------------------
Send line at point to Jython unique interpreter and switch to result.
py-execute-line-python
----------------------
Send line at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-line-python-switch
-----------------------------
Send line at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-line-python-no-switch
--------------------------------
Send line at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-line-python-dedicated
--------------------------------
Send line at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-line-python-dedicated-switch
---------------------------------------
Send line at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-line-python2
-----------------------
Send line at point to Python2 interpreter.
py-execute-line-python2-switch
------------------------------
Send line at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-line-python2-no-switch
---------------------------------
Send line at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-line-python2-dedicated
---------------------------------
Send line at point to Python2 unique interpreter.
py-execute-line-python2-dedicated-switch
----------------------------------------
Send line at point to Python2 unique interpreter and switch to result.
py-execute-line-python3
-----------------------
Send line at point to Python3 interpreter.
py-execute-line-python3-switch
------------------------------
Send line at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-line-python3-no-switch
---------------------------------
Send line at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-line-python3-dedicated
---------------------------------
Send line at point to Python3 unique interpreter.
py-execute-line-python3-dedicated-switch
----------------------------------------
Send line at point to Python3 unique interpreter and switch to result.
py-execute-minor-block
----------------------
Send minor-block at point to interpreter.
py-execute-minor-block-switch
-----------------------------
Send minor-block at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-minor-block-no-switch
--------------------------------
Send minor-block at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-minor-block-dedicated
--------------------------------
Send minor-block at point to unique interpreter.
py-execute-minor-block-dedicated-switch
---------------------------------------
Send minor-block at point to unique interpreter and switch to result.
py-execute-minor-block-ipython
------------------------------
Send minor-block at point to IPython interpreter.
py-execute-minor-block-ipython-switch
-------------------------------------
Send minor-block at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-minor-block-ipython-no-switch
----------------------------------------
Send minor-block at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-minor-block-ipython-dedicated
----------------------------------------
Send minor-block at point to IPython unique interpreter.
py-execute-minor-block-ipython-dedicated-switch
-----------------------------------------------
Send minor-block at point to IPython unique interpreter and switch to result.
py-execute-minor-block-ipython2\.7
----------------------------------
Send minor-block at point to IPython interpreter.
py-execute-minor-block-ipython2\.7-switch
-----------------------------------------
Send minor-block at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-minor-block-ipython2\.7-no-switch
--------------------------------------------
Send minor-block at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-minor-block-ipython2\.7-dedicated
--------------------------------------------
Send minor-block at point to IPython unique interpreter.
py-execute-minor-block-ipython2\.7-dedicated-switch
---------------------------------------------------
Send minor-block at point to IPython unique interpreter and switch to result.
py-execute-minor-block-ipython3
-------------------------------
Send minor-block at point to IPython interpreter.
py-execute-minor-block-ipython3-switch
--------------------------------------
Send minor-block at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-minor-block-ipython3-no-switch
-----------------------------------------
Send minor-block at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-minor-block-ipython3-dedicated
-----------------------------------------
Send minor-block at point to IPython unique interpreter.
py-execute-minor-block-ipython3-dedicated-switch
------------------------------------------------
Send minor-block at point to IPython unique interpreter and switch to result.
py-execute-minor-block-jython
-----------------------------
Send minor-block at point to Jython interpreter.
py-execute-minor-block-jython-switch
------------------------------------
Send minor-block at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-minor-block-jython-no-switch
---------------------------------------
Send minor-block at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-minor-block-jython-dedicated
---------------------------------------
Send minor-block at point to Jython unique interpreter.
py-execute-minor-block-jython-dedicated-switch
----------------------------------------------
Send minor-block at point to Jython unique interpreter and switch to result.
py-execute-minor-block-python
-----------------------------
Send minor-block at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-minor-block-python-switch
------------------------------------
Send minor-block at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-minor-block-python-no-switch
---------------------------------------
Send minor-block at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-minor-block-python-dedicated
---------------------------------------
Send minor-block at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-minor-block-python-dedicated-switch
----------------------------------------------
Send minor-block at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-minor-block-python2
------------------------------
Send minor-block at point to Python2 interpreter.
py-execute-minor-block-python2-switch
-------------------------------------
Send minor-block at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-minor-block-python2-no-switch
----------------------------------------
Send minor-block at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-minor-block-python2-dedicated
----------------------------------------
Send minor-block at point to Python2 unique interpreter.
py-execute-minor-block-python2-dedicated-switch
-----------------------------------------------
Send minor-block at point to Python2 unique interpreter and switch to result.
py-execute-minor-block-python3
------------------------------
Send minor-block at point to Python3 interpreter.
py-execute-minor-block-python3-switch
-------------------------------------
Send minor-block at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-minor-block-python3-no-switch
----------------------------------------
Send minor-block at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-minor-block-python3-dedicated
----------------------------------------
Send minor-block at point to Python3 unique interpreter.
py-execute-minor-block-python3-dedicated-switch
-----------------------------------------------
Send minor-block at point to Python3 unique interpreter and switch to result.
py-execute-paragraph
--------------------
Send paragraph at point to interpreter.
py-execute-paragraph-switch
---------------------------
Send paragraph at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-paragraph-no-switch
------------------------------
Send paragraph at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-paragraph-dedicated
------------------------------
Send paragraph at point to unique interpreter.
py-execute-paragraph-dedicated-switch
-------------------------------------
Send paragraph at point to unique interpreter and switch to result.
py-execute-paragraph-ipython
----------------------------
Send paragraph at point to IPython interpreter.
py-execute-paragraph-ipython-switch
-----------------------------------
Send paragraph at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-paragraph-ipython-no-switch
--------------------------------------
Send paragraph at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-paragraph-ipython-dedicated
--------------------------------------
Send paragraph at point to IPython unique interpreter.
py-execute-paragraph-ipython-dedicated-switch
---------------------------------------------
Send paragraph at point to IPython unique interpreter and switch to result.
py-execute-paragraph-ipython2\.7
--------------------------------
Send paragraph at point to IPython interpreter.
py-execute-paragraph-ipython2\.7-switch
---------------------------------------
Send paragraph at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-paragraph-ipython2\.7-no-switch
------------------------------------------
Send paragraph at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-paragraph-ipython2\.7-dedicated
------------------------------------------
Send paragraph at point to IPython unique interpreter.
py-execute-paragraph-ipython2\.7-dedicated-switch
-------------------------------------------------
Send paragraph at point to IPython unique interpreter and switch to result.
py-execute-paragraph-ipython3
-----------------------------
Send paragraph at point to IPython interpreter.
py-execute-paragraph-ipython3-switch
------------------------------------
Send paragraph at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-paragraph-ipython3-no-switch
---------------------------------------
Send paragraph at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-paragraph-ipython3-dedicated
---------------------------------------
Send paragraph at point to IPython unique interpreter.
py-execute-paragraph-ipython3-dedicated-switch
----------------------------------------------
Send paragraph at point to IPython unique interpreter and switch to result.
py-execute-paragraph-jython
---------------------------
Send paragraph at point to Jython interpreter.
py-execute-paragraph-jython-switch
----------------------------------
Send paragraph at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-paragraph-jython-no-switch
-------------------------------------
Send paragraph at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-paragraph-jython-dedicated
-------------------------------------
Send paragraph at point to Jython unique interpreter.
py-execute-paragraph-jython-dedicated-switch
--------------------------------------------
Send paragraph at point to Jython unique interpreter and switch to result.
py-execute-paragraph-python
---------------------------
Send paragraph at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-paragraph-python-switch
----------------------------------
Send paragraph at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-paragraph-python-no-switch
-------------------------------------
Send paragraph at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-paragraph-python-dedicated
-------------------------------------
Send paragraph at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-paragraph-python-dedicated-switch
--------------------------------------------
Send paragraph at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-paragraph-python2
----------------------------
Send paragraph at point to Python2 interpreter.
py-execute-paragraph-python2-switch
-----------------------------------
Send paragraph at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-paragraph-python2-no-switch
--------------------------------------
Send paragraph at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-paragraph-python2-dedicated
--------------------------------------
Send paragraph at point to Python2 unique interpreter.
py-execute-paragraph-python2-dedicated-switch
---------------------------------------------
Send paragraph at point to Python2 unique interpreter and switch to result.
py-execute-paragraph-python3
----------------------------
Send paragraph at point to Python3 interpreter.
py-execute-paragraph-python3-switch
-----------------------------------
Send paragraph at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-paragraph-python3-no-switch
--------------------------------------
Send paragraph at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-paragraph-python3-dedicated
--------------------------------------
Send paragraph at point to Python3 unique interpreter.
py-execute-paragraph-python3-dedicated-switch
---------------------------------------------
Send paragraph at point to Python3 unique interpreter and switch to result.
py-execute-partial-expression
-----------------------------
Send partial-expression at point to interpreter.
py-execute-partial-expression-switch
------------------------------------
Send partial-expression at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-partial-expression-no-switch
---------------------------------------
Send partial-expression at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-partial-expression-dedicated
---------------------------------------
Send partial-expression at point to unique interpreter.
py-execute-partial-expression-dedicated-switch
----------------------------------------------
Send partial-expression at point to unique interpreter and switch to result.
py-execute-partial-expression-ipython
-------------------------------------
Send partial-expression at point to IPython interpreter.
py-execute-partial-expression-ipython-switch
--------------------------------------------
Send partial-expression at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-partial-expression-ipython-no-switch
-----------------------------------------------
Send partial-expression at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-partial-expression-ipython-dedicated
-----------------------------------------------
Send partial-expression at point to IPython unique interpreter.
py-execute-partial-expression-ipython-dedicated-switch
------------------------------------------------------
Send partial-expression at point to IPython unique interpreter and switch to result.
py-execute-partial-expression-ipython2\.7
-----------------------------------------
Send partial-expression at point to IPython interpreter.
py-execute-partial-expression-ipython2\.7-switch
------------------------------------------------
Send partial-expression at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-partial-expression-ipython2\.7-no-switch
---------------------------------------------------
Send partial-expression at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-partial-expression-ipython2\.7-dedicated
---------------------------------------------------
Send partial-expression at point to IPython unique interpreter.
py-execute-partial-expression-ipython2\.7-dedicated-switch
----------------------------------------------------------
Send partial-expression at point to IPython unique interpreter and switch to result.
py-execute-partial-expression-ipython3
--------------------------------------
Send partial-expression at point to IPython interpreter.
py-execute-partial-expression-ipython3-switch
---------------------------------------------
Send partial-expression at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-partial-expression-ipython3-no-switch
------------------------------------------------
Send partial-expression at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-partial-expression-ipython3-dedicated
------------------------------------------------
Send partial-expression at point to IPython unique interpreter.
py-execute-partial-expression-ipython3-dedicated-switch
-------------------------------------------------------
Send partial-expression at point to IPython unique interpreter and switch to result.
py-execute-partial-expression-jython
------------------------------------
Send partial-expression at point to Jython interpreter.
py-execute-partial-expression-jython-switch
-------------------------------------------
Send partial-expression at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-partial-expression-jython-no-switch
----------------------------------------------
Send partial-expression at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-partial-expression-jython-dedicated
----------------------------------------------
Send partial-expression at point to Jython unique interpreter.
py-execute-partial-expression-jython-dedicated-switch
-----------------------------------------------------
Send partial-expression at point to Jython unique interpreter and switch to result.
py-execute-partial-expression-python
------------------------------------
Send partial-expression at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-partial-expression-python-switch
-------------------------------------------
Send partial-expression at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-partial-expression-python-no-switch
----------------------------------------------
Send partial-expression at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-partial-expression-python-dedicated
----------------------------------------------
Send partial-expression at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-partial-expression-python-dedicated-switch
-----------------------------------------------------
Send partial-expression at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-partial-expression-python2
-------------------------------------
Send partial-expression at point to Python2 interpreter.
py-execute-partial-expression-python2-switch
--------------------------------------------
Send partial-expression at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-partial-expression-python2-no-switch
-----------------------------------------------
Send partial-expression at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-partial-expression-python2-dedicated
-----------------------------------------------
Send partial-expression at point to Python2 unique interpreter.
py-execute-partial-expression-python2-dedicated-switch
------------------------------------------------------
Send partial-expression at point to Python2 unique interpreter and switch to result.
py-execute-partial-expression-python3
-------------------------------------
Send partial-expression at point to Python3 interpreter.
py-execute-partial-expression-python3-switch
--------------------------------------------
Send partial-expression at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-partial-expression-python3-no-switch
-----------------------------------------------
Send partial-expression at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-partial-expression-python3-dedicated
-----------------------------------------------
Send partial-expression at point to Python3 unique interpreter.
py-execute-partial-expression-python3-dedicated-switch
------------------------------------------------------
Send partial-expression at point to Python3 unique interpreter and switch to result.
py-execute-region
-----------------
Send region at point to interpreter.
py-execute-region-switch
------------------------
Send region at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-region-no-switch
---------------------------
Send region at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-region-dedicated
---------------------------
Send region at point to unique interpreter.
py-execute-region-dedicated-switch
----------------------------------
Send region at point to unique interpreter and switch to result.
py-execute-region-ipython
-------------------------
Send region at point to IPython interpreter.
py-execute-region-ipython-switch
--------------------------------
Send region at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-region-ipython-no-switch
-----------------------------------
Send region at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-region-ipython-dedicated
-----------------------------------
Send region at point to IPython unique interpreter.
py-execute-region-ipython-dedicated-switch
------------------------------------------
Send region at point to IPython unique interpreter and switch to result.
py-execute-region-ipython2\.7
-----------------------------
Send region at point to IPython interpreter.
py-execute-region-ipython2\.7-switch
------------------------------------
Send region at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-region-ipython2\.7-no-switch
---------------------------------------
Send region at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-region-ipython2\.7-dedicated
---------------------------------------
Send region at point to IPython unique interpreter.
py-execute-region-ipython2\.7-dedicated-switch
----------------------------------------------
Send region at point to IPython unique interpreter and switch to result.
py-execute-region-ipython3
--------------------------
Send region at point to IPython interpreter.
py-execute-region-ipython3-switch
---------------------------------
Send region at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-region-ipython3-no-switch
------------------------------------
Send region at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-region-ipython3-dedicated
------------------------------------
Send region at point to IPython unique interpreter.
py-execute-region-ipython3-dedicated-switch
-------------------------------------------
Send region at point to IPython unique interpreter and switch to result.
py-execute-region-jython
------------------------
Send region at point to Jython interpreter.
py-execute-region-jython-switch
-------------------------------
Send region at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-region-jython-no-switch
----------------------------------
Send region at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-region-jython-dedicated
----------------------------------
Send region at point to Jython unique interpreter.
py-execute-region-jython-dedicated-switch
-----------------------------------------
Send region at point to Jython unique interpreter and switch to result.
py-execute-region-python
------------------------
Send region at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-region-python-switch
-------------------------------
Send region at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-region-python-no-switch
----------------------------------
Send region at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-region-python-dedicated
----------------------------------
Send region at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-region-python-dedicated-switch
-----------------------------------------
Send region at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-region-python2
-------------------------
Send region at point to Python2 interpreter.
py-execute-region-python2-switch
--------------------------------
Send region at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-region-python2-no-switch
-----------------------------------
Send region at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-region-python2-dedicated
-----------------------------------
Send region at point to Python2 unique interpreter.
py-execute-region-python2-dedicated-switch
------------------------------------------
Send region at point to Python2 unique interpreter and switch to result.
py-execute-region-python3
-------------------------
Send region at point to Python3 interpreter.
py-execute-region-python3-switch
--------------------------------
Send region at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-region-python3-no-switch
-----------------------------------
Send region at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-region-python3-dedicated
-----------------------------------
Send region at point to Python3 unique interpreter.
py-execute-region-python3-dedicated-switch
------------------------------------------
Send region at point to Python3 unique interpreter and switch to result.
py-execute-statement
--------------------
Send statement at point to interpreter.
py-execute-statement-switch
---------------------------
Send statement at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-statement-no-switch
------------------------------
Send statement at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-statement-dedicated
------------------------------
Send statement at point to unique interpreter.
py-execute-statement-dedicated-switch
-------------------------------------
Send statement at point to unique interpreter and switch to result.
py-execute-statement-ipython
----------------------------
Send statement at point to IPython interpreter.
py-execute-statement-ipython-switch
-----------------------------------
Send statement at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-statement-ipython-no-switch
--------------------------------------
Send statement at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-statement-ipython-dedicated
--------------------------------------
Send statement at point to IPython unique interpreter.
py-execute-statement-ipython-dedicated-switch
---------------------------------------------
Send statement at point to IPython unique interpreter and switch to result.
py-execute-statement-ipython2\.7
--------------------------------
Send statement at point to IPython interpreter.
py-execute-statement-ipython2\.7-switch
---------------------------------------
Send statement at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-statement-ipython2\.7-no-switch
------------------------------------------
Send statement at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-statement-ipython2\.7-dedicated
------------------------------------------
Send statement at point to IPython unique interpreter.
py-execute-statement-ipython2\.7-dedicated-switch
-------------------------------------------------
Send statement at point to IPython unique interpreter and switch to result.
py-execute-statement-ipython3
-----------------------------
Send statement at point to IPython interpreter.
py-execute-statement-ipython3-switch
------------------------------------
Send statement at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-statement-ipython3-no-switch
---------------------------------------
Send statement at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-statement-ipython3-dedicated
---------------------------------------
Send statement at point to IPython unique interpreter.
py-execute-statement-ipython3-dedicated-switch
----------------------------------------------
Send statement at point to IPython unique interpreter and switch to result.
py-execute-statement-jython
---------------------------
Send statement at point to Jython interpreter.
py-execute-statement-jython-switch
----------------------------------
Send statement at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-statement-jython-no-switch
-------------------------------------
Send statement at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-statement-jython-dedicated
-------------------------------------
Send statement at point to Jython unique interpreter.
py-execute-statement-jython-dedicated-switch
--------------------------------------------
Send statement at point to Jython unique interpreter and switch to result.
py-execute-statement-python
---------------------------
Send statement at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-statement-python-switch
----------------------------------
Send statement at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-statement-python-no-switch
-------------------------------------
Send statement at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-statement-python-dedicated
-------------------------------------
Send statement at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-statement-python-dedicated-switch
--------------------------------------------
Send statement at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-statement-python2
----------------------------
Send statement at point to Python2 interpreter.
py-execute-statement-python2-switch
-----------------------------------
Send statement at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-statement-python2-no-switch
--------------------------------------
Send statement at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-statement-python2-dedicated
--------------------------------------
Send statement at point to Python2 unique interpreter.
py-execute-statement-python2-dedicated-switch
---------------------------------------------
Send statement at point to Python2 unique interpreter and switch to result.
py-execute-statement-python3
----------------------------
Send statement at point to Python3 interpreter.
py-execute-statement-python3-switch
-----------------------------------
Send statement at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-statement-python3-no-switch
--------------------------------------
Send statement at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-statement-python3-dedicated
--------------------------------------
Send statement at point to Python3 unique interpreter.
py-execute-statement-python3-dedicated-switch
---------------------------------------------
Send statement at point to Python3 unique interpreter and switch to result.
py-execute-top-level
--------------------
Send top-level at point to interpreter.
py-execute-top-level-switch
---------------------------
Send top-level at point to interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-top-level-no-switch
------------------------------
Send top-level at point to interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-top-level-dedicated
------------------------------
Send top-level at point to unique interpreter.
py-execute-top-level-dedicated-switch
-------------------------------------
Send top-level at point to unique interpreter and switch to result.
py-execute-top-level-ipython
----------------------------
Send top-level at point to IPython interpreter.
py-execute-top-level-ipython-switch
-----------------------------------
Send top-level at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-top-level-ipython-no-switch
--------------------------------------
Send top-level at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-top-level-ipython-dedicated
--------------------------------------
Send top-level at point to IPython unique interpreter.
py-execute-top-level-ipython-dedicated-switch
---------------------------------------------
Send top-level at point to IPython unique interpreter and switch to result.
py-execute-top-level-ipython2\.7
--------------------------------
Send top-level at point to IPython interpreter.
py-execute-top-level-ipython2\.7-switch
---------------------------------------
Send top-level at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-top-level-ipython2\.7-no-switch
------------------------------------------
Send top-level at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-top-level-ipython2\.7-dedicated
------------------------------------------
Send top-level at point to IPython unique interpreter.
py-execute-top-level-ipython2\.7-dedicated-switch
-------------------------------------------------
Send top-level at point to IPython unique interpreter and switch to result.
py-execute-top-level-ipython3
-----------------------------
Send top-level at point to IPython interpreter.
py-execute-top-level-ipython3-switch
------------------------------------
Send top-level at point to IPython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-top-level-ipython3-no-switch
---------------------------------------
Send top-level at point to IPython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-top-level-ipython3-dedicated
---------------------------------------
Send top-level at point to IPython unique interpreter.
py-execute-top-level-ipython3-dedicated-switch
----------------------------------------------
Send top-level at point to IPython unique interpreter and switch to result.
py-execute-top-level-jython
---------------------------
Send top-level at point to Jython interpreter.
py-execute-top-level-jython-switch
----------------------------------
Send top-level at point to Jython interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-top-level-jython-no-switch
-------------------------------------
Send top-level at point to Jython interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-top-level-jython-dedicated
-------------------------------------
Send top-level at point to Jython unique interpreter.
py-execute-top-level-jython-dedicated-switch
--------------------------------------------
Send top-level at point to Jython unique interpreter and switch to result.
py-execute-top-level-python
---------------------------
Send top-level at point to default interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-top-level-python-switch
----------------------------------
Send top-level at point to default interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
For ‘default’ see value of ‘py-shell-name’
py-execute-top-level-python-no-switch
-------------------------------------
Send top-level at point to default interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
For ‘default’ see value of ‘py-shell-name’
py-execute-top-level-python-dedicated
-------------------------------------
Send top-level at point to default unique interpreter.
For ‘default’ see value of ‘py-shell-name’
py-execute-top-level-python-dedicated-switch
--------------------------------------------
Send top-level at point to default unique interpreter and switch to result.
For ‘default’ see value of ‘py-shell-name’
py-execute-top-level-python2
----------------------------
Send top-level at point to Python2 interpreter.
py-execute-top-level-python2-switch
-----------------------------------
Send top-level at point to Python2 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-top-level-python2-no-switch
--------------------------------------
Send top-level at point to Python2 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-top-level-python2-dedicated
--------------------------------------
Send top-level at point to Python2 unique interpreter.
py-execute-top-level-python2-dedicated-switch
---------------------------------------------
Send top-level at point to Python2 unique interpreter and switch to result.
py-execute-top-level-python3
----------------------------
Send top-level at point to Python3 interpreter.
py-execute-top-level-python3-switch
-----------------------------------
Send top-level at point to Python3 interpreter.
Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’.
py-execute-top-level-python3-no-switch
--------------------------------------
Send top-level at point to Python3 interpreter.
Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’
py-execute-top-level-python3-dedicated
--------------------------------------
Send top-level at point to Python3 unique interpreter.
py-execute-top-level-python3-dedicated-switch
---------------------------------------------
Send top-level at point to Python3 unique interpreter and switch to result.
py-edit-abbrevs
---------------
Jumps to ‘python-mode-abbrev-table’ in a buffer containing lists of abbrev definitions.
You can edit them and type C-c C-c to redefine abbrevs
according to your editing.
Buffer contains a header line for each abbrev table,
which is the abbrev table name in parentheses.
This is followed by one line per abbrev in that table:
NAME USECOUNT EXPANSION HOOK
where NAME and EXPANSION are strings with quotes,
USECOUNT is an integer, and HOOK is any valid function
or may be omitted (it is usually omitted).
py-add-abbrev
-------------
Defines python-mode specific abbrev for last expressions before point.
Argument is how many ‘py-partial-expression’s form the expansion; or zero means the region is the expansion.
Reads the abbreviation in the minibuffer; with numeric arg it displays a proposal for an abbrev.
Proposal is composed from the initial character(s) of the
expansion.
Don’t use this function in a Lisp program; use ‘define-abbrev’ instead.
py-fill-paren
-------------
Paren fill function for ‘py-fill-paragraph’.
JUSTIFY should be used (if applicable) as in ‘fill-paragraph’.
py-fill-string-django
---------------------
Fill docstring according to Django’s coding standards style.
"""
Process foo, return bar.
"""
"""
Process foo, return bar.
If processing fails throw ProcessingError.
"""
See available styles at ‘py-fill-paragraph’ or var ‘py-docstring-style’
py-fill-string-onetwo
---------------------
One newline and start and Two at end style.
"""Process foo, return bar."""
"""
Process foo, return bar.
If processing fails throw ProcessingError.
"""
See available styles at ‘py-fill-paragraph’ or var ‘py-docstring-style’
py-fill-string-pep-257
----------------------
PEP-257 with 2 newlines at end of string.
"""Process foo, return bar."""
"""Process foo, return bar.
If processing fails throw ProcessingError.
"""
See available styles at ‘py-fill-paragraph’ or var ‘py-docstring-style’
py-fill-string-pep-257-nn
-------------------------
PEP-257 with 1 newline at end of string.
"""Process foo, return bar."""
"""Process foo, return bar.
If processing fails throw ProcessingError.
"""
See available styles at ‘py-fill-paragraph’ or var ‘py-docstring-style’
py-fill-string-symmetric
------------------------
Symmetric style.
"""Process foo, return bar."""
"""
Process foo, return bar.
If processing fails throw ProcessingError.
"""
See available styles at ‘py-fill-paragraph’ or var ‘py-docstring-style’
py-set-nil-docstring-style
--------------------------
Set py-docstring-style to ’nil
py-set-pep-257-nn-docstring-style
---------------------------------
Set py-docstring-style to ’pep-257-nn
py-set-pep-257-docstring-style
------------------------------
Set py-docstring-style to ’pep-257
py-set-django-docstring-style
-----------------------------
Set py-docstring-style to ’django
py-set-symmetric-docstring-style
--------------------------------
Set py-docstring-style to ’symmetric
py-set-onetwo-docstring-style
-----------------------------
Set py-docstring-style to ’onetwo
py-fill-comment
---------------
Fill the comment paragraph at point
py-fill-labelled-string
-----------------------
Fill string or paragraph containing lines starting with label
See lp:1066489
py--string-fence-delete-spaces
------------------------------
Delete spaces following or preceding delimiters of string at point.
py-fill-string
--------------
String fill function for ‘py-fill-paragraph’.
JUSTIFY should be used (if applicable) as in ‘fill-paragraph’.
Fill according to ‘py-docstring-style’
py-shift-left
-------------
Dedent region according to ‘py-indent-offset’ by COUNT times.
If no region is active, current line is dedented.
Returns indentation reached.
py-shift-right
--------------
Indent region according to ‘py-indent-offset’ by COUNT times.
If no region is active, current line is indented.
Returns indentation reached.
py-shift-block-right
--------------------
Indent block by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-block-left
-------------------
Dedent block by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-block-or-clause-right
------------------------------
Indent block-or-clause by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-block-or-clause-left
-----------------------------
Dedent block-or-clause by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-class-right
--------------------
Indent class by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-class-left
-------------------
Dedent class by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-clause-right
---------------------
Indent clause by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-clause-left
--------------------
Dedent clause by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-comment-right
----------------------
Indent comment by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-comment-left
---------------------
Dedent comment by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-def-right
------------------
Indent def by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-def-left
-----------------
Dedent def by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-def-or-class-right
---------------------------
Indent def-or-class by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-def-or-class-left
--------------------------
Dedent def-or-class by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-indent-right
---------------------
Indent indent by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-indent-left
--------------------
Dedent indent by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-minor-block-right
--------------------------
Indent minor-block by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-minor-block-left
-------------------------
Dedent minor-block by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-paragraph-right
------------------------
Indent paragraph by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-paragraph-left
-----------------------
Dedent paragraph by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-region-right
---------------------
Indent region by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-region-left
--------------------
Dedent region by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-statement-right
------------------------
Indent statement by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-statement-left
-----------------------
Dedent statement by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-top-level-right
------------------------
Indent top-level by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-shift-top-level-left
-----------------------
Dedent top-level by COUNT spaces.
COUNT defaults to ‘py-indent-offset’,
use [universal-argument] to specify a different value.
Returns outmost indentation reached.
py-execute-file-python
----------------------
Send file to Python default interpreter.
py-execute-file-python-switch
-----------------------------
Send file to Python default interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-python-no-switch
--------------------------------
Send file to Python default interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
py-execute-file-python-dedicated
--------------------------------
Send file to Python default interpreter.
Uses a dedicated shell.
py-execute-file-python-dedicated-switch
---------------------------------------
Send file to Python default interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-ipython
-----------------------
Send file to a Ipython interpreter.
py-execute-file-ipython-switch
------------------------------
Send file to a Ipython interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-ipython-no-switch
---------------------------------
Send file to a Ipython interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
py-execute-file-ipython-dedicated
---------------------------------
Send file to a Ipython interpreter.
Uses a dedicated shell.
py-execute-file-ipython-dedicated-switch
----------------------------------------
Send file to a Ipython interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-python3
-----------------------
Send file to a Python3 interpreter.
py-execute-file-python3-switch
------------------------------
Send file to a Python3 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-python3-no-switch
---------------------------------
Send file to a Python3 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
py-execute-file-python3-dedicated
---------------------------------
Send file to a Python3 interpreter.
Uses a dedicated shell.
py-execute-file-python3-dedicated-switch
----------------------------------------
Send file to a Python3 interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-python2
-----------------------
Send file to a Python2 interpreter.
py-execute-file-python2-switch
------------------------------
Send file to a Python2 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-python2-no-switch
---------------------------------
Send file to a Python2 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
py-execute-file-python2-dedicated
---------------------------------
Send file to a Python2 interpreter.
Uses a dedicated shell.
py-execute-file-python2-dedicated-switch
----------------------------------------
Send file to a Python2 interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-python2\.7
--------------------------
Send file to a Python2.7 interpreter.
py-execute-file-python2\.7-switch
---------------------------------
Send file to a Python2.7 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-python2\.7-no-switch
------------------------------------
Send file to a Python2.7 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
py-execute-file-python2\.7-dedicated
------------------------------------
Send file to a Python2.7 interpreter.
Uses a dedicated shell.
py-execute-file-python2\.7-dedicated-switch
-------------------------------------------
Send file to a Python2.7 interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-jython
----------------------
Send file to a Jython interpreter.
py-execute-file-jython-switch
-----------------------------
Send file to a Jython interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-jython-no-switch
--------------------------------
Send file to a Jython interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
py-execute-file-jython-dedicated
--------------------------------
Send file to a Jython interpreter.
Uses a dedicated shell.
py-execute-file-jython-dedicated-switch
---------------------------------------
Send file to a Jython interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-python3\.2
--------------------------
Send file to a Python3.2 interpreter.
py-execute-file-python3\.2-switch
---------------------------------
Send file to a Python3.2 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-python3\.2-no-switch
------------------------------------
Send file to a Python3.2 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
py-execute-file-python3\.2-dedicated
------------------------------------
Send file to a Python3.2 interpreter.
Uses a dedicated shell.
py-execute-file-python3\.2-dedicated-switch
-------------------------------------------
Send file to a Python3.2 interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-python3\.3
--------------------------
Send file to a Python3.3 interpreter.
py-execute-file-python3\.3-switch
---------------------------------
Send file to a Python3.3 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-file-python3\.3-no-switch
------------------------------------
Send file to a Python3.3 interpreter.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "nil"
py-execute-file-python3\.3-dedicated
------------------------------------
Send file to a Python3.3 interpreter.
Uses a dedicated shell.
py-execute-file-python3\.3-dedicated-switch
-------------------------------------------
Send file to a Python3.3 interpreter.
Uses a dedicated shell.
Ignores default of ‘py-switch-buffers-on-execute-p’, uses it with value "non-nil"
py-execute-section
------------------
Execute section at point.
py-execute-section-python
-------------------------
Execute section at point using python interpreter.
py-execute-section-python2
--------------------------
Execute section at point using python2 interpreter.
py-execute-section-python3
--------------------------
Execute section at point using python3 interpreter.
py-execute-section-ipython
--------------------------
Execute section at point using ipython interpreter.
py-execute-section-ipython2\.7
------------------------------
Execute section at point using ipython2.7 interpreter.
py-execute-section-ipython3
---------------------------
Execute section at point using ipython3 interpreter.
py-execute-section-jython
-------------------------
Execute section at point using jython interpreter.
py-comment-region
-----------------
Like ‘comment-region’ but uses double hash (‘#’) comment starter.
py-comment-block
----------------
Comments block at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
py-comment-block-or-clause
--------------------------
Comments block-or-clause at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
py-comment-class
----------------
Comments class at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
py-comment-clause
-----------------
Comments clause at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
py-comment-def
--------------
Comments def at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
py-comment-def-or-class
-----------------------
Comments def-or-class at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
py-comment-indent
-----------------
Comments indent at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
py-comment-minor-block
----------------------
Comments minor-block at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
py-comment-section
------------------
Comments section at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
py-comment-statement
--------------------
Comments statement at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
py-comment-top-level
--------------------
Comments top-level at point.
Uses double hash (‘#’) comment starter when ‘py-block-comment-prefix-p’ is ‘t’,
the default
py-block
--------
Block at point.
Return code of ‘py-block’ at point, a string.
py-block-or-clause
------------------
Block-Or-Clause at point.
Return code of ‘py-block-or-clause’ at point, a string.
py-buffer
---------
Buffer at point.
Return code of ‘py-buffer’ at point, a string.
py-class
--------
Class at point.
Return code of ‘py-class’ at point, a string.
py-clause
---------
Clause at point.
Return code of ‘py-clause’ at point, a string.
py-def
------
Def at point.
Return code of ‘py-def’ at point, a string.
py-def-or-class
---------------
Def-Or-Class at point.
Return code of ‘py-def-or-class’ at point, a string.
py-expression
-------------
Expression at point.
Return code of ‘py-expression’ at point, a string.
py-indent
---------
Indent at point.
Return code of ‘py-indent’ at point, a string.
py-line
-------
Line at point.
Return code of ‘py-line’ at point, a string.
py-minor-block
--------------
Minor-Block at point.
Return code of ‘py-minor-block’ at point, a string.
py-paragraph
------------
Paragraph at point.
Return code of ‘py-paragraph’ at point, a string.
py-partial-expression
---------------------
Partial-Expression at point.
Return code of ‘py-partial-expression’ at point, a string.
py-region
---------
Region at point.
Return code of ‘py-region’ at point, a string.
py-statement
------------
Statement at point.
Return code of ‘py-statement’ at point, a string.
py-top-level
------------
Top-Level at point.
Return code of ‘py-top-level’ at point, a string.
py-fast-process
---------------
Connect am (I)Python process suitable for large output.
Output buffer displays "Fast" by default
It is not in interactive, i.e. comint-mode, as its bookkeepings seem linked to the freeze reported by lp:1253907
py-execute-block-fast
---------------------
Process block at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
py-execute-block-or-clause-fast
-------------------------------
Process block-or-clause at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
py-execute-class-fast
---------------------
Process class at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
py-execute-clause-fast
----------------------
Process clause at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
py-execute-def-fast
-------------------
Process def at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
py-execute-def-or-class-fast
----------------------------
Process def-or-class at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
py-execute-expression-fast
--------------------------
Process expression at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
py-execute-partial-expression-fast
----------------------------------
Process partial-expression at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
py-execute-section-fast
-----------------------
Process section at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
py-execute-statement-fast
-------------------------
Process statement at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
py-execute-top-level-fast
-------------------------
Process top-level at point by a Python interpreter.
Suitable for large output, doesn’t mess up interactive shell.
Output buffer not in comint-mode, displays "Fast" by default
py-narrow-to-block
------------------
Narrow to block at point.
py-narrow-to-block-or-clause
----------------------------
Narrow to block-or-clause at point.
py-narrow-to-class
------------------
Narrow to class at point.
py-narrow-to-clause
-------------------
Narrow to clause at point.
py-narrow-to-def
----------------
Narrow to def at point.
py-narrow-to-def-or-class
-------------------------
Narrow to def-or-class at point.
py-narrow-to-statement
----------------------
Narrow to statement at point.
py-comment-auto-fill
--------------------
Toggles comment-auto-fill mode
py-hide-show
------------
Toggle visibility of existing forms at point.
py-hide-region
--------------
Hide active region.
py-show-region
--------------
Un-hide active region.
py-hide-block
-------------
Hide block at point.
py-show-block
-------------
Show block at point.
py-hide-block-or-clause
-----------------------
Hide block-or-clause at point.
py-show-block-or-clause
-----------------------
Show block-or-clause at point.
py-hide-class
-------------
Hide class at point.
py-show-class
-------------
Show class at point.
py-hide-clause
--------------
Hide clause at point.
py-show-clause
--------------
Show clause at point.
py-hide-comment
---------------
Hide comment at point.
py-show-comment
---------------
Show comment at point.
py-hide-def
-----------
Hide def at point.
py-show-def
-----------
Show def at point.
py-hide-def-or-class
--------------------
Hide def-or-class at point.
py-show-def-or-class
--------------------
Show def-or-class at point.
py-hide-elif-block
------------------
Hide elif-block at point.
py-show-elif-block
------------------
Show elif-block at point.
py-hide-else-block
------------------
Hide else-block at point.
py-show-else-block
------------------
Show else-block at point.
py-hide-except-block
--------------------
Hide except-block at point.
py-show-except-block
--------------------
Show except-block at point.
py-hide-expression
------------------
Hide expression at point.
py-show-expression
------------------
Show expression at point.
py-hide-for-block
-----------------
Hide for-block at point.
py-show-for-block
-----------------
Show for-block at point.
py-hide-if-block
----------------
Hide if-block at point.
py-show-if-block
----------------
Show if-block at point.
py-hide-indent
--------------
Hide indent at point.
py-show-indent
--------------
Show indent at point.
py-hide-line
------------
Hide line at point.
py-show-line
------------
Show line at point.
py-hide-minor-block
-------------------
Hide minor-block at point.
py-show-minor-block
-------------------
Show minor-block at point.
py-hide-paragraph
-----------------
Hide paragraph at point.
py-show-paragraph
-----------------
Show paragraph at point.
py-hide-partial-expression
--------------------------
Hide partial-expression at point.
py-show-partial-expression
--------------------------
Show partial-expression at point.
py-hide-section
---------------
Hide section at point.
py-show-section
---------------
Show section at point.
py-hide-statement
-----------------
Hide statement at point.
py-show-statement
-----------------
Show statement at point.
py-hide-top-level
-----------------
Hide top-level at point.
py-show-top-level
-----------------
Show top-level at point.
py-fast-complete
----------------
Complete word before point, if any.
Use ‘py-fast-process’
ar--beginning-of-form-intern
----------------------------
Go to beginning of FORM.
With INDENT, go to beginning one level above.
Whit IACT, print result in message buffer.
Returns beginning of FORM if successful, nil otherwise
py-in-comment-p
---------------
Return the beginning of current line’s comment, if inside.
py-forward-buffer
-----------------
A complementary form used by auto-generated commands.
Returns position reached if successful
py-backward-buffer
------------------
A complementary form used by auto-generated commands.
Returns position reached if successful
py-load-skeletons
-----------------
Load skeletons from extensions.
py-python-version
-----------------
Returns versions number of a Python EXECUTABLE, string.
If no EXECUTABLE given, ‘py-shell-name’ is used.
Interactively output of ‘--version’ is displayed.
py-version
----------
Echo the current version of ‘python-mode’ in the minibuffer.
py-load-file
------------
Load a Python file FILE-NAME into the Python process.
If the file has extension ‘.py’ import or reload it as a module.
Treating it as a module keeps the global namespace clean, provides
function location information for debugging, and supports users of
module-qualified names.
py-proc
-------
Return the current Python process.
Start a new process if necessary.
py-guess-pdb-path
-----------------
If py-pdb-path isn’t set, find location of pdb.py.
py-switch-shell
---------------
Toggles between the interpreter customized in ‘py-shell-toggle-1’ resp. ‘py-shell-toggle-2’. Was hard-coded CPython and Jython in earlier versions, now starts with Python2 and Python3 by default.
ARG might be a python-version string to set to.
C-u ‘py-toggle-shell’ prompts to specify a reachable Python command.
C-u followed by numerical arg 2 or 3, ‘py-toggle-shell’ opens a respective Python shell.
C-u followed by numerical arg 5 opens a Jython shell.
Should you need more shells to select, extend this command by adding inside the first cond:
((eq NUMBER (prefix-numeric-value arg))
"MY-PATH-TO-SHELL")
py-uncomment
------------
Uncomment commented lines at point.
If region is active, restrict uncommenting at region
py-set-command-args
-------------------
Set Python arguments on the fly, override defaults in this session.
Use ‘defcustom’ to keep value across sessions
py-symbol-at-point
------------------
Return the current Python symbol.
py-kill-buffer-unconditional
----------------------------
Kill buffer unconditional, kill buffer-process if existing.
py-compute-indentation
----------------------
Compute Python indentation.
When HONOR-BLOCK-CLOSE-P is non-nil, statements such as ‘return’,
‘raise’, ‘break’, ‘continue’, and ‘pass’ force one level of dedenting.
Optional arguments are flags resp. values set and used by ‘py-compute-indentation’ internally:
ORIG keeps original position
ORIGLINE keeps line where compute started
CLOSING is t when started at a char delimiting a list as "]})"
LINE indicates being not at origline now
NESTING is currently ignored, if executing from inside a list
REPEAT counter enables checks against ‘py-max-specpdl-size’
INDENT-OFFSET allows calculation of block-local values
LIEP stores line-end-position at point-of-interest
py-continuation-offset
----------------------
With numeric ARG different from 1 py-continuation-offset is set to that value; returns py-continuation-offset.
py-indentation-of-statement
---------------------------
Returns the indenation of the statement at point.
py-end-of-list-position
-----------------------
Return end position, nil if not inside.
Optional ARG indicates a start-position for ‘parse-partial-sexp’.
py-in-triplequoted-string-p
---------------------------
Returns character address of start tqs-string, nil if not inside.
py-in-string-p
--------------
if inside a double- triple- or singlequoted string,
If non-nil, return a list composed of
- beginning position
- the character used as string-delimiter (in decimal)
- and length of delimiter, commonly 1 or 3
py-in-statement-p
-----------------
Returns list of beginning and end-position if inside.
Result is useful for booleans too: (when (py-in-statement-p)...)
will work.
py-backward-top-level-p
-----------------------
Returns position, if cursor is at the beginning of a top-level, nil otherwise.
py-look-downward-for-clause
---------------------------
If beginning of other clause exists downward in current block.
If succesful return position.
py-current-defun
----------------
Go to the outermost method or class definition in current scope.
Python value for ‘add-log-current-defun-function’.
This tells add-log.el how to find the current function/method/variable.
Returns name of class or methods definition, if found, nil otherwise.
See customizable variables ‘py-current-defun-show’ and ‘py-current-defun-delay’.
py-sort-imports
---------------
Sort multiline imports.
Put point inside the parentheses of a multiline import and hit
M-x py-sort-imports to sort the imports lexicographically
py-install-local-shells
-----------------------
Builds Python-shell commands from executable found in LOCAL.
If LOCAL is empty, shell-command ‘find’ searches beneath current directory.
Eval resulting buffer to install it, see customizable ‘py-extensions’.
py-end-of-string
----------------
Go to end of string at point if any, if successful return position.
py-which-def-or-class
---------------------
Returns concatenated ‘def’ and ‘class’ names in hierarchical order, if cursor is inside.
Returns "???" otherwise
Used by variable ‘which-func-functions’
py--beginning-of-form-intern
----------------------------
Go to beginning of FORM.
With INDENT, go to beginning one level above.
Whit IACT, print result in message buffer.
Returns beginning of FORM if successful, nil otherwise
py-unload-python-el
-------------------
Unloads python-mode delivered by shipped python.el
Removes python-skeleton forms from abbrevs.
These would interfere when inserting forms heading a block
py-backward-top-level
---------------------
Go up to beginning of statments until level of indentation is null.
Returns position if successful, nil otherwise
py-forward-top-level
--------------------
Go to end of top-level form at point.
Returns position if successful, nil otherwise
py-down-top-level
-----------------
Go to beginning of next top-level form downward.
Returns position if successful, nil otherwise
py-forward-top-level-bol
------------------------
Go to end of top-level form at point, stop at next beginning-of-line.
Returns position successful, nil otherwise
py-down
-------
Go to beginning one level below of compound statement or definition at point.
If no statement or block below, but a delimited form --string or list-- go to its beginning. Repeated call from there will behave like down-list.
Returns position if successful, nil otherwise
py-beginning
------------
Go to beginning of compound statement or definition at point.
With C-u, go to beginning one level above.
Returns position if successful, nil otherwise
py-end
------
Go to end of of compound statement or definition at point.
Returns position block if successful, nil otherwise
py-backward-same-level
----------------------
Go form backward keeping indent level if possible.
If inside a delimited form --string or list-- go to its beginning.
If not at beginning of a statement or block, go to its beginning.
If at beginning of a statement or block, go to previous beginning of compound statement or definition at point.
If no further element at same level, go one level up.
py-sectionize-region
--------------------
Markup code in region as section.
Use current region unless optional args BEG END are delivered.
py-rotate-shell-fontify-style
-----------------------------
Rotates between possible values ’all, ’input and nil.
python-mode.el-6.2.3/byte-compile-directory.sh 0000644 0000000 0000000 00000002657 13011652224 021257 0 ustar root root 0000000 0000000 #!/bin/bash
# -- byte-compile Emacs Lisp files delivered with python-mode.el
# Author: Andreas Röhler
# This program 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.
# This program 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 this program. If not, see .
# Commentary: Edit the vars pointing to the directories/files
# holding your python-mode for test
# assumes python-mode files in or below current directory
# Code:
# the path
PDIR=`pwd`
# python-mode file to load
if [ -s "python-components-mode.el" ];
then
PYTHONMODE='python-components-mode.el'
else
PYTHONMODE='python-mode.el'
fi
EMACS=emacs
PYMACSDIR=Pymacs
$EMACS -Q --batch --eval "(message (emacs-version))" --eval "(when (featurep 'python-mode)(unload-feature 'python-mode t))" --eval "(add-to-list 'load-path \"$PDIR/\")" --eval "(add-to-list 'load-path \"$PYMACSDIR/\")" -load "$PDIR/$PYTHONMODE" --eval '(byte-recompile-directory default-directory 1 t)'