From b757ca00e1a4b5966f658e96d4221f14b762f87c Mon Sep 17 00:00:00 2001 From: Lars Wirzenius Date: Sat, 15 Aug 2020 09:04:41 +0300 Subject: update: emacs.d --- emacs.d/elpa/archives/gnu/archive-contents | 2413 ++ .../blacken-20191123.1547/blacken-autoloads.el | 34 + emacs.d/elpa/blacken-20191123.1547/blacken-pkg.el | 2 + emacs.d/elpa/blacken-20191123.1547/blacken.el | 176 + .../flymake-easy-autoloads.el | 22 + .../flymake-easy-20140818.755/flymake-easy-pkg.el | 2 + .../elpa/flymake-easy-20140818.755/flymake-easy.el | 152 + .../flymake-rust-autoloads.el | 22 + .../flymake-rust-20170729.2139/flymake-rust-pkg.el | 2 + .../flymake-rust-20170729.2139/flymake-rust.el | 70 + .../completion/pycomplete.el | 436 + .../completion/pycomplete.py | 798 + .../python-mode-autoloads.el | 137 + .../python-mode-20200508.1756/python-mode-pkg.el | 4 + .../elpa/python-mode-20200508.1756/python-mode.el | 28002 +++++++++++++++++++ ...01d47009963c31ba1159569722019955500000022650061 | 0 ...01d47009963c31ba1159574583376392600000022650075 | 0 ...1025c13d2547b60a4159077433053076200000021570061 | 0 ...1025c13d2547b60a4159092200566268200000021570110 | 0 ...0b4081bb65a59085d159478824683153500000022890061 | 0 ...0b4081bb65a59085d159479301240276200000022890072 | 0 ...0f083cc2387800c9d158834765989283100000022650307 | 0 ...0f083cc2387800c9d158844134055669800000022650348 | 0 ...0f6902c8946b7fce3158895969791533300000019210061 | 0 ...0f6902c8946b7fce3158909298996168000000019210117 | 0 ...0f6902c8946b7fce3158912618062280700000019210154 | 0 emacs.d/tramp | 82 + 27 files changed, 32354 insertions(+) create mode 100644 emacs.d/elpa/archives/gnu/archive-contents create mode 100644 emacs.d/elpa/blacken-20191123.1547/blacken-autoloads.el create mode 100644 emacs.d/elpa/blacken-20191123.1547/blacken-pkg.el create mode 100644 emacs.d/elpa/blacken-20191123.1547/blacken.el create mode 100644 emacs.d/elpa/flymake-easy-20140818.755/flymake-easy-autoloads.el create mode 100644 emacs.d/elpa/flymake-easy-20140818.755/flymake-easy-pkg.el create mode 100644 emacs.d/elpa/flymake-easy-20140818.755/flymake-easy.el create mode 100644 emacs.d/elpa/flymake-rust-20170729.2139/flymake-rust-autoloads.el create mode 100644 emacs.d/elpa/flymake-rust-20170729.2139/flymake-rust-pkg.el create mode 100644 emacs.d/elpa/flymake-rust-20170729.2139/flymake-rust.el create mode 100644 emacs.d/elpa/python-mode-20200508.1756/completion/pycomplete.el create mode 100644 emacs.d/elpa/python-mode-20200508.1756/completion/pycomplete.py create mode 100644 emacs.d/elpa/python-mode-20200508.1756/python-mode-autoloads.el create mode 100644 emacs.d/elpa/python-mode-20200508.1756/python-mode-pkg.el create mode 100644 emacs.d/elpa/python-mode-20200508.1756/python-mode.el create mode 100644 emacs.d/session.101d47009963c31ba1159569722019955500000022650061 create mode 100644 emacs.d/session.101d47009963c31ba1159574583376392600000022650075 create mode 100644 emacs.d/session.1025c13d2547b60a4159077433053076200000021570061 create mode 100644 emacs.d/session.1025c13d2547b60a4159092200566268200000021570110 create mode 100644 emacs.d/session.10b4081bb65a59085d159478824683153500000022890061 create mode 100644 emacs.d/session.10b4081bb65a59085d159479301240276200000022890072 create mode 100644 emacs.d/session.10f083cc2387800c9d158834765989283100000022650307 create mode 100644 emacs.d/session.10f083cc2387800c9d158844134055669800000022650348 create mode 100644 emacs.d/session.10f6902c8946b7fce3158895969791533300000019210061 create mode 100644 emacs.d/session.10f6902c8946b7fce3158909298996168000000019210117 create mode 100644 emacs.d/session.10f6902c8946b7fce3158912618062280700000019210154 create mode 100644 emacs.d/tramp diff --git a/emacs.d/elpa/archives/gnu/archive-contents b/emacs.d/elpa/archives/gnu/archive-contents new file mode 100644 index 0000000..ade2478 --- /dev/null +++ b/emacs.d/elpa/archives/gnu/archive-contents @@ -0,0 +1,2413 @@ +(1 + (ace-window . + [(0 9 0) + ((avy + (0 2 0))) + "Quickly switch windows." single + ((:keywords "window" "location") + (:authors + ("Oleh Krehel" . "ohwoeowho@gmail.com")) + (:maintainer "Oleh Krehel" . "ohwoeowho@gmail.com") + (:url . "https://github.com/abo-abo/ace-window"))]) + (ack . + [(1 8) + nil "interface to ack-like tools" tar + ((:url . "https://github.com/leoliu/ack-el") + (:maintainer "João Távora" . "joaotavora@gmail.com") + (:authors + ("Leo Liu" . "sdl.web@gmail.com")) + (:keywords "tools" "processes" "convenience"))]) + (ada-mode . + [(7 0 1) + ((uniquify-files + (1 0 1)) + (wisi + (3 0 1)) + (emacs + (25 0))) + "major-mode for editing Ada sources" tar + ((:url . "http://www.nongnu.org/ada-mode/") + (:maintainer "Stephen Leake" . "stephen_leake@stephe-leake.org") + (:authors + ("Stephen Leake" . "stephen_leake@stephe-leake.org")) + (:keywords "languages" "ada"))]) + (ada-ref-man . + [(2012 5) + nil "Ada Reference Manual 2012" tar + ((:url . "http://stephe-leake.org/ada/arm.html") + (:maintainer "Stephen Leake" . "stephen_leake@member.fsf.org") + (:authors + ("Stephen Leake" . "stephen_leake@member.fsf.org")) + (:keywords "languages" "ada"))]) + (adaptive-wrap . + [(0 7) + nil "Smart line-wrapping with wrap-prefix" single + ((:url . "http://elpa.gnu.org/packages/adaptive-wrap.html") + (:authors + ("Stephen Berman" . "stephen.berman@gmx.net") + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stephen Berman" . "stephen.berman@gmx.net"))]) + (adjust-parens . + [(3 1) + nil "Indent and dedent Lisp code, automatically adjust close parens" tar + ((:maintainer "Barry O'Reilly" . "gundaetiapo@gmail.com") + (:authors + ("Barry O'Reilly" . "gundaetiapo@gmail.com")) + (:url . "http://elpa.gnu.org/packages/adjust-parens.html"))]) + (advice-patch . + [(0 1) + ((emacs + (24 4))) + "Use patches to advise the inside of functions" single + ((:url . "http://elpa.gnu.org/packages/advice-patch.html") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (aggressive-indent . + [(1 8 3) + ((emacs + (24 1)) + (cl-lib + (0 5))) + "Minor mode to aggressively keep your code always indented" single + ((:keywords "indent" "lisp" "maint" "tools") + (:authors + ("Artur Malabarba" . "emacs@endlessparentheses.com")) + (:maintainer "Artur Malabarba" . "emacs@endlessparentheses.com") + (:url . "https://github.com/Malabarba/aggressive-indent-mode"))]) + (ahungry-theme . + [(1 10 0) + ((emacs + (24))) + "Ahungry color theme for Emacs. Make sure to (load-theme 'ahungry)." tar + ((:url . "https://github.com/ahungry/color-theme-ahungry") + (:maintainer "Matthew Carter" . "m@ahungry.com") + (:authors + ("Matthew Carter" . "m@ahungry.com")) + (:keywords "ahungry" "palette" "color" "theme" "emacs" "color-theme" "deftheme"))]) + (all . + [(1 0) + nil "Edit all lines matching a given regexp" single + ((:url . "http://elpa.gnu.org/packages/all.html") + (:keywords "matching") + (:authors + ("Per Abrahamsen" . "abraham@dina.kvl.dk")) + (:maintainer "Per Abrahamsen" . "abraham@dina.kvl.dk"))]) + (ampc . + [(0 2) + nil "Asynchronous Music Player Controller" single + ((:url . "http://elpa.gnu.org/packages/ampc.html") + (:keywords "ampc" "mpc" "mpd") + (:authors + ("Christopher Schmidt" . "christopher@ch.ristopher.com")) + (:maintainer nil . "emacs-devel@gnu.org"))]) + (arbitools . + [(0 977) + ((cl-lib + (0 5))) + "Package for chess tournaments administration" single + ((:url . "http://elpa.gnu.org/packages/arbitools.html") + (:authors + ("David Gonzalez Gandara" . "dggandara@member.fsf.org")) + (:maintainer "David Gonzalez Gandara" . "dggandara@member.fsf.org"))]) + (ascii-art-to-unicode . + [(1 12) + nil "a small artist adjunct" single + ((:keywords "ascii" "unicode" "box-drawing") + (:authors + ("Thien-Thi Nguyen" . "ttn@gnu.org")) + (:maintainer "Thien-Thi Nguyen" . "ttn@gnu.org") + (:url . "http://www.gnuvola.org/software/aa2u/"))]) + (async . + [(1 9 3) + ((cl-lib + (0 5)) + (nadvice + (0 3))) + "Asynchronous processing in Emacs" tar + ((:url . "https://github.com/jwiegley/emacs-async") + (:maintainer "John Wiegley" . "jwiegley@gmail.com") + (:authors + ("John Wiegley" . "jwiegley@gmail.com")) + (:keywords "async"))]) + (auctex . + [(12 2 1) + ((emacs + (24 1)) + (cl-lib + (0 5))) + "Integrated environment for *TeX*" tar + ((:url . "http://www.gnu.org/software/auctex/") + (:maintainer nil . "auctex-devel@gnu.org") + (:keywords "tex" "latex" "texinfo" "context" "doctex" "preview-latex"))]) + (aumix-mode . + [(7) + nil "run the aumix program in a buffer" single + ((:keywords "multimedia" "mixer" "aumix") + (:authors + ("Kevin Ryde" . "user42_kevin@yahoo.com.au")) + (:maintainer "Kevin Ryde" . "user42_kevin@yahoo.com.au") + (:url . "http://user42.tuxfamily.org/aumix-mode/index.html"))]) + (auto-correct . + [(1 1 4) + nil "Remembers and automatically fixes past corrections" single + ((:url . "http://elpa.gnu.org/packages/auto-correct.html") + (:keywords "editing") + (:authors + ("Ian Dunn" . "dunni@gnu.org")) + (:maintainer "Ian Dunn" . "dunni@gnu.org"))]) + (auto-overlays . + [(0 10 9) + nil "Automatic regexp-delimited overlays" tar + ((:url . "http://www.dr-qubit.org/emacs.php") + (:maintainer "Toby Cubitt" . "toby-predictive@dr-qubit.org") + (:authors + ("Toby Cubitt" . "toby-predictive@dr-qubit.org")) + (:keywords "extensions"))]) + (avy . + [(0 5 0) + ((emacs + (24 1)) + (cl-lib + (0 5))) + "Jump to arbitrary positions in visible text and select text quickly." tar + ((:url . "https://github.com/abo-abo/avy") + (:maintainer "Oleh Krehel" . "ohwoeowho@gmail.com") + (:authors + ("Oleh Krehel" . "ohwoeowho@gmail.com")) + (:keywords "point" "location"))]) + (bbdb . + [(3 2) + ((emacs + (24))) + "core of BBDB" tar + ((:maintainer "Roland Winkler" . "winkler@gnu.org") + (:url . "http://elpa.gnu.org/packages/bbdb.html"))]) + (beacon . + [(1 3 3) + ((seq + (2 14))) + "Highlight the cursor whenever the window scrolls" single + ((:keywords "convenience") + (:authors + ("Artur Malabarba" . "emacs@endlessparentheses.com")) + (:maintainer "Artur Malabarba" . "emacs@endlessparentheses.com") + (:url . "https://github.com/Malabarba/beacon"))]) + (bluetooth . + [(0 1 2) + ((emacs + (25 1)) + (dash + (2 12 0))) + "A Major mode for Bluetooth devices" single + ((:keywords "hardware") + (:authors + ("Raffael Stocker" . "r.stocker@mnet-mail.de")) + (:maintainer "Raffael Stocker" . "r.stocker@mnet-mail.de") + (:url . "https://gitlab.com/rstocker/emacs-bluetooth"))]) + (bnf-mode . + [(0 4 4) + ((cl-lib + (0 5)) + (emacs + (24 3))) + "Major mode for editing BNF grammars." tar + ((:url . "https://github.com/sergeyklay/bnf-mode") + (:maintainer "Serghei Iakovlev" . "egrep@protonmail.ch") + (:authors + ("Serghei Iakovlev" . "egrep@protonmail.ch")) + (:keywords "languages"))]) + (brief . + [(5 87) + nil "Brief Editor Emulator (Brief Mode)" tar + ((:maintainer "Luke Lee" . "luke.yx.lee@gmail.com") + (:authors + ("Luke Lee" . "luke.yx.lee@gmail.com")) + (:keywords "brief" "emulations" "crisp") + (:url . "http://elpa.gnu.org/packages/brief.html"))]) + (buffer-expose . + [(0 4 3) + ((emacs + (25)) + (cl-lib + (0 5))) + "Visual buffer switching using a window grid" single + ((:keywords "convenience") + (:authors + ("Clemens Radermacher" . "clemera@posteo.net")) + (:maintainer "Clemens Radermacher" . "clemera@posteo.net") + (:url . "https://github.com/clemera/buffer-expose"))]) + (bug-hunter . + [(1 3 1) + ((seq + (1 3)) + (cl-lib + (0 5))) + "Hunt down errors by bisecting elisp files" single + ((:keywords "lisp") + (:authors + ("Artur Malabarba" . "emacs@endlessparentheses.com")) + (:maintainer "Artur Malabarba" . "emacs@endlessparentheses.com") + (:url . "https://github.com/Malabarba/elisp-bug-hunter"))]) + (caps-lock . + [(1 0) + nil "Caps-lock as a minor mode" single + ((:url . "http://elpa.gnu.org/packages/caps-lock.html") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (captain . + [(1 0 3) + nil "CAPiTalization is Automatic IN emacs" single + ((:url . "http://elpa.gnu.org/packages/captain.html") + (:keywords "editing") + (:authors + ("Ian Dunn" . "dunni@gnu.org")) + (:maintainer "Ian Dunn" . "dunni@gnu.org"))]) + (chess . + [(2 0 4) + ((cl-lib + (0 5))) + "Play chess in GNU Emacs" tar + ((:maintainer "Mario Lang" . "mlang@delysid.org") + (:authors + ("John Wiegley" . "johnw@gnu.org")) + (:keywords "games") + (:url . "http://elpa.gnu.org/packages/chess.html"))]) + (cl-generic . + [(0 3) + nil "Forward cl-generic compatibility for Emacs<25" single + ((:url . "http://elpa.gnu.org/packages/cl-generic.html") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (cl-lib . + [(0 6 1) + nil "Forward cl-lib compatibility library for Emacs<24.3" single + ((:url . "http://elpa.gnu.org/packages/cl-lib.html") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (cl-print . + [(1 0) + ((emacs + (25))) + "CL-style generic printing" single + ((:url . "http://elpa.gnu.org/packages/cl-print.html") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (clipboard-collector . + [(0 2) + ((emacs + (25))) + "Collect clipboard entries according to regex rules" single + ((:keywords "convenience") + (:authors + ("Clemens Radermacher" . "clemera@posteo.net")) + (:maintainer "Clemens Radermacher" . "clemera@posteo.net") + (:url . "https://github.com/clemera/clipboard-collector"))]) + (cobol-mode . + [(1 0 0) + ((cl-lib + (0 5))) + "Mode for editing COBOL code" single + ((:url . "http://elpa.gnu.org/packages/cobol-mode.html") + (:keywords "languages") + (:authors + ("Edward Hart" . "edward.dan.hart@gmail.com")) + (:maintainer "Edward Hart" . "edward.dan.hart@gmail.com"))]) + (coffee-mode . + [(0 4 1 1) + nil "Major mode for CoffeeScript files" single + ((:keywords "coffeescript" "major" "mode") + (:authors + ("Chris Wanstrath" . "chris@ozmm.org")) + (:maintainer "Chris Wanstrath" . "chris@ozmm.org") + (:url . "http://github.com/defunkt/coffee-mode"))]) + (compact-docstrings . + [(0 1) + nil "Shrink blank lines in docstrings and doc comments" single + ((:keywords "convenience" "faces" "lisp" "maint" "c") + (:authors + ("Clément Pit-Claudel" . "clement.pitclaudel@live.com")) + (:maintainer "Clément Pit-Claudel" . "clement.pitclaudel@live.com") + (:url . "https://github.com/cpitclaudel/compact-docstrings"))]) + (company . + [(0 9 12) + ((emacs + (24 3))) + "Modular text completion framework" tar + ((:url . "http://company-mode.github.io/") + (:maintainer "Dmitry Gutov" . "dgutov@yandex.ru") + (:authors + ("Nikolaj Schumacher")) + (:keywords "abbrev" "convenience" "matching"))]) + (company-ebdb . + [(1 1) + ((company + (0 9 4)) + (ebdb + (0 2))) + "company-mode completion backend for EBDB in message-mode" single + ((:url . "http://elpa.gnu.org/packages/company-ebdb.html") + (:authors + ("Jan Tatarik" . "jan.tatarik@gmail.com")) + (:maintainer "Eric Abrahamsen" . "eric@ericabrahamsen.net"))]) + (company-math . + [(1 3) + ((company + (0 8 0)) + (math-symbol-lists + (1 2))) + "Completion backends for unicode math symbols and latex tags" tar + ((:url . "https://github.com/vspinu/company-math") + (:maintainer "Vitalie Spinu" . "spinuvit@gmail.com") + (:authors + ("Vitalie Spinu" . "spinuvit@gmail.com")) + (:keywords "unicode" "symbols" "completion"))]) + (company-statistics . + [(0 2 3) + ((emacs + (24 3)) + (company + (0 8 5))) + "Sort candidates using completion history" tar + ((:url . "https://github.com/company-mode/company-statistics") + (:maintainer "Ingo Lohmar" . "i.lohmar@gmail.com") + (:authors + ("Ingo Lohmar" . "i.lohmar@gmail.com")) + (:keywords "abbrev" "convenience" "matching"))]) + (context-coloring . + [(8 1 0) + ((emacs + (24 3))) + "Highlight by scope" tar + ((:url . "https://github.com/jacksonrayhamilton/context-coloring") + (:maintainer "Jackson Ray Hamilton" . "jackson@jacksonrayhamilton.com") + (:authors + ("Jackson Ray Hamilton" . "jackson@jacksonrayhamilton.com")) + (:keywords "convenience" "faces" "tools"))]) + (crisp . + [(1 3 6) + nil "CRiSP/Brief Emacs emulator" single + ((:url . "http://elpa.gnu.org/packages/crisp.html") + (:keywords "emulations" "brief" "crisp") + (:authors + ("Gary D. Foster" . "Gary.Foster@Corp.Sun.COM")) + (:maintainer "Luke Lee" . "luke.yx.lee@gmail.com"))]) + (csv-mode . + [(1 12) + ((emacs + (24 1)) + (cl-lib + (0 5))) + "Major mode for editing comma/char separated values" tar + ((:maintainer nil . "emacs-devel@gnu.org") + (:authors + ("\"Francis J. Wright\"" . "F.J.Wright@qmul.ac.uk")) + (:keywords "convenience") + (:url . "http://elpa.gnu.org/packages/csv-mode.html"))]) + (cycle-quotes . + [(0 1) + nil "Cycle between quote styles" tar + ((:maintainer "Simen Heggestøyl" . "simenheg@gmail.com") + (:authors + ("Simen Heggestøyl" . "simenheg@gmail.com")) + (:keywords "convenience") + (:url . "http://elpa.gnu.org/packages/cycle-quotes.html"))]) + (darkroom . + [(0 3) + ((cl-lib + (0 5))) + "Remove visual distractions and focus on writing" single + ((:url . "http://elpa.gnu.org/packages/darkroom.html") + (:keywords "convenience" "emulations") + (:authors + ("João Távora" . "joaotavora@gmail.com")) + (:maintainer "João Távora" . "joaotavora@gmail.com"))]) + (dash . + [(2 12 0) + nil "A modern list library for Emacs" tar + ((:maintainer "Magnar Sveen" . "magnars@gmail.com") + (:authors + ("Magnar Sveen" . "magnars@gmail.com")) + (:keywords "lists") + (:url . "http://elpa.gnu.org/packages/dash.html"))]) + (dbus-codegen . + [(0 1) + ((cl-lib + (0 5))) + "Lisp code generation for D-Bus." single + ((:url . "http://elpa.gnu.org/packages/dbus-codegen.html") + (:keywords "comm" "dbus" "convenience") + (:authors + ("Daiki Ueno" . "ueno@gnu.org")) + (:maintainer nil . "emacs-devel@gnu.org"))]) + (debbugs . + [(0 22) + ((emacs + (25 1)) + (soap-client + (3 1 5))) + "SOAP library to access debbugs servers" tar + ((:maintainer "Michael Albinus" . "michael.albinus@gmx.de") + (:authors + ("Michael Albinus" . "michael.albinus@gmx.de")) + (:keywords "comm" "hypermedia") + (:url . "http://elpa.gnu.org/packages/debbugs.html"))]) + (delight . + [(1 5) + ((cl-lib + (0 5)) + (nadvice + (0 3))) + "A dimmer switch for your lighter text" single + ((:keywords "convenience") + (:authors + ("Phil Sainty" . "psainty@orcon.net.nz")) + (:maintainer "Phil Sainty" . "psainty@orcon.net.nz") + (:url . "https://savannah.nongnu.org/projects/delight"))]) + (dict-tree . + [(0 14) + ((trie + (0 3)) + (tNFA + (0 1 1)) + (heap + (0 3))) + "Dictionary data structure" single + ((:keywords "extensions" "matching" "data structures trie" "tree" "dictionary" "completion" "regexp") + (:authors + ("Toby Cubitt" . "toby-predictive@dr-qubit.org")) + (:maintainer "Toby Cubitt" . "toby-predictive@dr-qubit.org") + (:url . "http://www.dr-qubit.org/emacs.php"))]) + (diff-hl . + [(1 8 7) + ((cl-lib + (0 2)) + (emacs + (24 3))) + "Highlight uncommitted changes using VC" tar + ((:url . "https://github.com/dgutov/diff-hl") + (:maintainer "Dmitry Gutov" . "dgutov@yandex.ru") + (:authors + ("Dmitry Gutov" . "dgutov@yandex.ru")) + (:keywords "vc" "diff"))]) + (diffview . + [(1 0) + nil "View diffs in side-by-side format" single + ((:keywords "convenience" "diff") + (:authors + ("Mitchel Humpherys" . "mitch.special@gmail.com")) + (:maintainer "Mitchel Humpherys" . "mitch.special@gmail.com") + (:url . "https://github.com/mgalgs/diffview-mode"))]) + (dired-du . + [(0 5 2) + ((emacs + (24 4)) + (cl-lib + (0 5))) + "Dired with recursive directory sizes" tar + ((:maintainer "Tino Calancha" . "tino.calancha@gmail.com") + (:authors + ("Tino Calancha" . "tino.calancha@gmail.com")) + (:keywords "files" "unix" "convenience") + (:url . "http://elpa.gnu.org/packages/dired-du.html"))]) + (dired-git-info . + [(0 3 1) + ((emacs + (25))) + "Show git info in dired" single + ((:keywords "dired" "files") + (:authors + ("Clemens Radermacher" . "clemera@posteo.net")) + (:maintainer "Clemens Radermacher" . "clemera@posteo.net") + (:url . "https://github.com/clemera/dired-git-info"))]) + (disk-usage . + [(1 3 3) + ((emacs + (26 1))) + "Sort and browse disk usage listings" single + ((:keywords "files" "convenience" "tools") + (:authors + ("Pierre Neidhardt" . "mail@ambrevar.xyz")) + (:maintainer "Pierre Neidhardt" . "mail@ambrevar.xyz") + (:url . "https://gitlab.com/Ambrevar/emacs-disk-usage"))]) + (dismal . + [(1 5) + ((cl-lib + (0))) + "Dis Mode Ain't Lotus: Spreadsheet program Emacs" tar + ((:maintainer "UnMaintainer" . "emacs-devel@gnu.org") + (:authors + (nil . "David Fox, fox@cs.nyu.edu") + (nil . "Frank E. Ritter, ritter@cs.cmu.edu")) + (:url . "http://elpa.gnu.org/packages/dismal.html"))]) + (djvu . + [(1 1) + nil "Edit and view Djvu files via djvused" single + ((:url . "http://elpa.gnu.org/packages/djvu.html") + (:keywords "files" "wp") + (:authors + ("Roland Winkler" . "winkler@gnu.org")) + (:maintainer "Roland Winkler" . "winkler@gnu.org"))]) + (docbook . + [(0 1) + nil "Info-like viewer for DocBook" single + ((:url . "http://elpa.gnu.org/packages/docbook.html") + (:keywords "docs" "help") + (:authors + ("Chong Yidong" . "cyd@gnu.org")) + (:maintainer "Chong Yidong" . "cyd@gnu.org"))]) + (dts-mode . + [(0 1 0) + nil "Major mode for Device Tree source files" single + ((:url . "http://elpa.gnu.org/packages/dts-mode.html") + (:keywords "languages") + (:authors + ("Ben Gamari" . "ben@smart-cactus.org")) + (:maintainer "Ben Gamari" . "ben@smart-cactus.org"))]) + (easy-kill . + [(0 9 3) + ((emacs + (24)) + (cl-lib + (0 5))) + "kill & mark things easily" tar + ((:url . "https://github.com/leoliu/easy-kill") + (:maintainer "Leo Liu" . "sdl.web@gmail.com") + (:authors + ("Leo Liu" . "sdl.web@gmail.com")) + (:keywords "killing" "convenience"))]) + (ebdb . + [(0 6 17) + ((emacs + (25 1)) + (cl-lib + (0 5)) + (seq + (2 15))) + "Contact management package" tar + ((:url . "https://github.com/girzel/ebdb") + (:maintainer "Eric Abrahamsen" . "eric@ericabrahamsen.net") + (:authors + ("Eric Abrahamsen" . "eric@ericabrahamsen.net")) + (:keywords "convenience" "mail"))]) + (ebdb-gnorb . + [(1 0 2) + ((gnorb + (1 1 0)) + (ebdb + (0 2))) + "Utilities for connecting EBDB to Gnorb" single + ((:url . "http://elpa.gnu.org/packages/ebdb-gnorb.html") + (:authors + ("Eric Abrahamsen" . "eric@ericabrahamsen.net")) + (:maintainer "Eric Abrahamsen" . "eric@ericabrahamsen.net"))]) + (ebdb-i18n-chn . + [(1 3) + ((pyim + (1 6 0)) + (ebdb + (0 6 17))) + "China-specific internationalization support for EBDB" single + ((:url . "http://elpa.gnu.org/packages/ebdb-i18n-chn.html") + (:authors + ("Eric Abrahamsen" . "eric@ericabrahamsen.net")) + (:maintainer "Eric Abrahamsen" . "eric@ericabrahamsen.net"))]) + (ediprolog . + [(1 2) + nil "Emacs Does Interactive Prolog" single + ((:keywords "languages" "processes") + (:authors + ("Markus Triska" . "triska@metalevel.at")) + (:maintainer "Markus Triska" . "triska@metalevel.at") + (:url . "https://www.metalevel.at/ediprolog/"))]) + (eev . + [(20200224) + ((emacs + (24 1))) + "Support for e-scripts (eepitch blocks, elisp hyperlinks, etc)" tar + ((:url . "http://angg.twu.net/#eev") + (:maintainer "Eduardo Ochs" . "eduardoochs@gmail.com") + (:authors + ("Eduardo Ochs" . "eduardoochs@gmail.com")) + (:keywords "lisp" "e-scripts"))]) + (eglot . + [(1 6) + ((emacs + (26 1)) + (jsonrpc + (1 0 7)) + (flymake + (1 0 5))) + "Client for Language Server Protocol (LSP) servers" tar + ((:url . "https://github.com/joaotavora/eglot") + (:maintainer "João Távora" . "joaotavora@gmail.com") + (:authors + ("João Távora" . "joaotavora@gmail.com")) + (:keywords "convenience" "languages"))]) + (el-search . + [(1 12 6 1) + ((emacs + (25)) + (stream + (2 2 4)) + (cl-print + (1 0))) + "Expression based interactive search for Emacs Lisp" tar + ((:maintainer "Michael Heerdegen" . "michael_heerdegen@web.de") + (:authors + ("Michael Heerdegen" . "michael_heerdegen@web.de")) + (:keywords "lisp") + (:url . "http://elpa.gnu.org/packages/el-search.html"))]) + (eldoc-eval . + [(0 1) + nil "Enable eldoc support when minibuffer is in use." single + ((:url . "http://elpa.gnu.org/packages/eldoc-eval.html") + (:authors + ("Thierry Volpiatto" . "thierry.volpiatto@gmail.com")) + (:maintainer "Thierry Volpiatto" . "thierry.volpiatto@gmail.com"))]) + (electric-spacing . + [(5 0) + nil "Insert operators with surrounding spaces smartly" single + ((:url . "http://elpa.gnu.org/packages/electric-spacing.html") + (:authors + ("William Xu" . "william.xwl@gmail.com")) + (:maintainer "William Xu" . "william.xwl@gmail.com"))]) + (elisp-benchmarks . + [(1 4) + nil "elisp benchmarks collection" tar + ((:maintainer "Andrea Corallo" . "akrl@sdf.org") + (:authors + ("Andrea Corallo" . "akrl@sdf.org")) + (:keywords "languages" "lisp") + (:url . "http://elpa.gnu.org/packages/elisp-benchmarks.html"))]) + (enwc . + [(2 0) + ((emacs + (25 1))) + "The Emacs Network Client" tar + ((:url . "https://savannah.nongnu.org/p/enwc") + (:maintainer "Ian Dunn" . "dunni@gnu.org") + (:authors + ("Ian Dunn" . "dunni@gnu.org")) + (:keywords "external" "network" "wicd" "manager" "nm"))]) + (epoch-view . + [(0 0 1) + nil "Minor mode to visualize epoch timestamps" single + ((:url . "http://elpa.gnu.org/packages/epoch-view.html") + (:keywords "data" "timestamp" "epoch" "unix") + (:authors + ("Ted Zlatanov" . "tzz@lifelogs.com")) + (:maintainer "Ted Zlatanov" . "tzz@lifelogs.com"))]) + (ergoemacs-mode . + [(5 16 10 12) + ((emacs + (24 1)) + (undo-tree + (0 6 5)) + (cl-lib + (0 5))) + "Emacs mode based on common modern interface and ergonomics." tar + ((:url . "https://github.com/ergoemacs/ergoemacs-mode") + (:maintainer "Matthew L. Fidler" . "matthew.fidler@gmail.com") + (:authors + ("Xah Lee" . "xah@xahlee.org") + ("David Capello" . "davidcapello@gmail.com") + ("Matthew L. Fidler" . "matthew.fidler@gmail.com")) + (:keywords "convenience"))]) + (excorporate . + [(0 8 3) + ((emacs + (24 1)) + (fsm + (0 2 1)) + (soap-client + (3 1 5)) + (url-http-ntlm + (2 0 4)) + (nadvice + (0 3))) + "Exchange Web Services (EWS) integration" tar + ((:url . "https://www.fitzsim.org/blog/") + (:maintainer "Thomas Fitzsimmons" . "fitzsim@fitzsim.org") + (:authors + ("Thomas Fitzsimmons" . "fitzsim@fitzsim.org")) + (:keywords "calendar"))]) + (expand-region . + [(0 11 0) + nil "Increase selected region by semantic units." tar + ((:url . "https://github.com/magnars/expand-region.el") + (:maintainer "Magnar Sveen" . "magnars@gmail.com") + (:authors + ("Magnar Sveen" . "magnars@gmail.com")) + (:keywords "marking" "region"))]) + (exwm . + [(0 23) + ((xelb + (0 18))) + "Emacs X Window Manager" tar + ((:url . "https://github.com/ch11ng/exwm") + (:maintainer "Chris Feng" . "chris.w.feng@gmail.com") + (:authors + ("Chris Feng" . "chris.w.feng@gmail.com")) + (:keywords "unix"))]) + (f90-interface-browser . + [(1 1) + nil "Parse and browse f90 interfaces" single + ((:authors + ("Lawrence Mitchell" . "wence@gmx.li")) + (:maintainer "Lawrence Mitchell" . "wence@gmx.li") + (:url . "http://github.com/wence-/f90-iface/"))]) + (filladapt . + [(2 12 2) + ((emacs + (24 4))) + "Adaptive fill" single + ((:url . "http://elpa.gnu.org/packages/filladapt.html") + (:authors + ("Kyle E. Jones" . "kyle_jones@wonderworks.com")) + (:maintainer nil . "emacs-devel@gnu.org"))]) + (flylisp . + [(0 2) + ((emacs + (24 1)) + (cl-lib + (0 4))) + "Color unbalanced parentheses and parentheses inconsistent with indentation" single + ((:url . "http://elpa.gnu.org/packages/flylisp.html") + (:authors + ("Barry O'Reilly" . "gundaetiapo@gmail.com")) + (:maintainer "Barry O'Reilly" . "gundaetiapo@gmail.com"))]) + (flymake . + [(1 0 8) + ((emacs + (26 1))) + "A universal on-the-fly syntax checker" single + ((:url . "http://elpa.gnu.org/packages/flymake.html") + (:keywords "c" "languages" "tools") + (:authors + ("Pavel Kobyakov" . "pk_at_work@yahoo.com")) + (:maintainer "João Távora" . "joaotavora@gmail.com"))]) + (fountain-mode . + [(2 7 3) + ((emacs + (24 5))) + "Major mode for screenwriting in Fountain markup" single + ((:keywords "wp" "text") + (:authors + ("Paul W. Rankin" . "pwr@sdf.org")) + (:maintainer "Paul W. Rankin" . "pwr@sdf.org") + (:url . "https://fountain-mode.org"))]) + (frame-tabs . + [(1 1) + nil "show buffer tabs in side window" single + ((:url . "http://elpa.gnu.org/packages/frame-tabs.html") + (:keywords "frames" "tabs") + (:authors + ("Martin Rudalics" . "rudalics@gmx.at")) + (:maintainer "Martin Rudalics" . "rudalics@gmx.at"))]) + (frog-menu . + [(0 2 10) + ((emacs + (26)) + (avy + (0 4)) + (posframe + (0 4))) + "Quickly pick items from ad hoc menus" single + ((:keywords "convenience") + (:authors + ("Clemens Radermacher" . "clemera@posteo.net")) + (:maintainer "Clemens Radermacher" . "clemera@posteo.net") + (:url . "https://github.com/clemera/frog-menu"))]) + (fsm . + [(0 2 1) + ((emacs + (24 1)) + (cl-lib + (0 5))) + "state machine library" single + ((:url . "http://elpa.gnu.org/packages/fsm.html") + (:keywords "extensions") + (:authors + ("Magnus Henoch" . "magnus.henoch@gmail.com")) + (:maintainer "Thomas Fitzsimmons" . "fitzsim@fitzsim.org"))]) + (ggtags . + [(0 8 13) + ((emacs + (24)) + (cl-lib + (0 5))) + "emacs frontend to GNU Global source code tagging system" single + ((:keywords "tools" "convenience") + (:authors + ("Leo Liu" . "sdl.web@gmail.com")) + (:maintainer "Leo Liu" . "sdl.web@gmail.com") + (:url . "https://github.com/leoliu/ggtags"))]) + (gited . + [(0 6 0) + ((emacs + (24 4)) + (cl-lib + (0 5))) + "Operate on Git branches like dired" tar + ((:maintainer "Tino Calancha" . "tino.calancha@gmail.com") + (:authors + ("Tino Calancha" . "tino.calancha@gmail.com")) + (:keywords "git" "vc" "convenience") + (:url . "http://elpa.gnu.org/packages/gited.html"))]) + (gle-mode . + [(1 1) + ((cl-lib + (0 5))) + "Major mode to edit Graphics Layout Engine files" single + ((:url . "http://elpa.gnu.org/packages/gle-mode.html") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (gnome-c-style . + [(0 1) + nil "minor mode for editing GNOME-style C source code" tar + ((:maintainer "Daiki Ueno" . "ueno@gnu.org") + (:authors + ("Daiki Ueno" . "ueno@gnu.org")) + (:keywords "gnome" "c" "coding style") + (:url . "http://elpa.gnu.org/packages/gnome-c-style.html"))]) + (gnorb . + [(1 6 7) + ((cl-lib + (0 5))) + "Glue code between Gnus, Org, and BBDB" tar + ((:maintainer "Eric Abrahamsen" . "eric@ericabrahamsen.net") + (:authors + ("Eric Abrahamsen" . "eric@ericabrahamsen.net")) + (:keywords "mail" "org" "gnus" "bbdb" "todo" "task") + (:url . "http://elpa.gnu.org/packages/gnorb.html"))]) + (gnu-elpa . + [(1 0) + nil "Advertize GNU ELPA packages" tar + ((:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:url . "http://elpa.gnu.org/packages/gnu-elpa.html"))]) + (gnu-elpa-keyring-update . + [(2019 3) + nil "Update Emacs's GPG keyring for GNU ELPA" tar + ((:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:keywords "maint" "tools") + (:url . "http://elpa.gnu.org/packages/gnu-elpa-keyring-update.html"))]) + (gnugo . + [(3 1 0) + ((ascii-art-to-unicode + (1 5)) + (xpm + (1 0 1)) + (cl-lib + (0 5))) + "play GNU Go in a buffer" tar + ((:url . "http://www.gnuvola.org/software/gnugo/") + (:maintainer "Thien-Thi Nguyen" . "ttn@gnu.org") + (:authors + ("Thien-Thi Nguyen" . "ttn@gnu.org")) + (:keywords "games" "processes"))]) + (gnus-mock . + [(0 4 5) + nil "Mock Gnus installation for testing" tar + ((:maintainer "Eric Abrahamsen" . "eric@ericabrahamsen.net") + (:authors + ("Eric Abrahamsen" . "eric@ericabrahamsen.net")) + (:url . "http://elpa.gnu.org/packages/gnus-mock.html"))]) + (gpastel . + [(0 5 0) + ((emacs + (25 1))) + "Integrates GPaste with the kill-ring" single + ((:keywords "tools") + (:authors + ("Damien Cassou" . "damien@cassou.me")) + (:maintainer "Damien Cassou" . "damien@cassou.me") + (:url . "https://gitlab.petton.fr/DamienCassou/desktop-environment"))]) + (greader . + [(0 1) + ((emacs + (25))) + "gnamù reader, a reader with espeak tts" tar + ((:maintainer "Michelangelo Rodriguez" . "michelangelo.rodriguez@gmail.com") + (:authors + ("Michelangelo Rodriguez" . "michelangelo.rodriguez@gmail.com")) + (:keywords "tools" "accessibility") + (:url . "http://elpa.gnu.org/packages/greader.html"))]) + (guess-language . + [(0 0 1) + ((cl-lib + (0 5)) + (emacs + (24)) + (nadvice + (0 1))) + "Robust automatic language detection" single + ((:authors + ("Titus von der Malsburg" . "malsburg@posteo.de")) + (:maintainer "Titus von der Malsburg" . "malsburg@posteo.de") + (:url . "https://github.com/tmalsburg/guess-language.el"))]) + (heap . + [(0 5) + nil "Heap (a.k.a. priority queue) data structure" single + ((:keywords "extensions" "data structures" "heap" "priority queue") + (:authors + ("Toby Cubitt" . "toby-predictive@dr-qubit.org")) + (:maintainer "Toby Cubitt" . "toby-predictive@dr-qubit.org") + (:url . "http://www.dr-qubit.org/emacs.php"))]) + (highlight-escape-sequences . + [(0 4) + nil "Highlight escape sequences" single + ((:keywords "convenience") + (:authors + ("Dmitry Gutov" . "dgutov@yandex.ru") + ("Pavel Matcula" . "dev.plvlml@gmail.com")) + (:maintainer "Dmitry Gutov" . "dgutov@yandex.ru") + (:url . "https://github.com/dgutov/highlight-escape-sequences"))]) + (hook-helpers . + [(1 1 1) + ((emacs + (25 1))) + "Anonymous, modifiable hook functions" tar + ((:url . "https://savannah.nongnu.org/projects/hook-helpers-el/") + (:maintainer "Ian Dunn" . "dunni@gnu.org") + (:authors + ("Ian Dunn" . "dunni@gnu.org")) + (:keywords "development" "hooks"))]) + (html5-schema . + [(0 1) + nil "Add HTML5 schemas for use by nXML" tar + ((:url . "https://github.com/validator/validator") + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:keywords "html" "xml"))]) + (hydra . + [(0 14 0) + ((cl-lib + (0 5))) + "Make bindings that stick around." tar + ((:url . "https://github.com/abo-abo/hydra") + (:maintainer "Oleh Krehel" . "ohwoeowho@gmail.com") + (:authors + ("Oleh Krehel" . "ohwoeowho@gmail.com")) + (:keywords "bindings"))]) + (hyperbole . + [(7 0 6) + ((emacs + (24 4))) + "GNU Hyperbole: The Everyday Hypertextual Information Manager" tar + ((:url . "http://www.gnu.org/software/hyperbole") + (:maintainer "Bob Weiner , Mats Lidell" . "matsl@gnu.org") + (:authors + ("Bob Weiner")) + (:keywords "comm" "convenience" "files" "frames" "hypermedia" "languages" "mail" "matching" "mouse" "multimedia" "outlines" "tools" "wp"))]) + (ioccur . + [(2 4) + ((emacs + (24)) + (cl-lib + (0 5))) + "Incremental occur" single + ((:authors + ("Thierry Volpiatto" . "thierry.volpiatto@gmail.com")) + (:maintainer "Thierry Volpiatto" . "thierry.volpiatto@gmail.com") + (:url . "https://github.com/thierryvolpiatto/ioccur"))]) + (iterators . + [(0 1 1) + ((emacs + (25))) + "Functions for working with iterators" single + ((:url . "http://elpa.gnu.org/packages/iterators.html") + (:keywords "extensions" "elisp") + (:authors + ("Michael Heerdegen" . "michael_heerdegen@web.de")) + (:maintainer "Michael Heerdegen" . "michael_heerdegen@web.de"))]) + (ivy . + [(0 13 0) + ((emacs + (24 5))) + "Incremental Vertical completYon" tar + ((:url . "https://github.com/abo-abo/swiper") + (:maintainer "Oleh Krehel" . "ohwoeowho@gmail.com") + (:authors + ("Oleh Krehel" . "ohwoeowho@gmail.com")) + (:keywords "matching"))]) + (ivy-explorer . + [(0 3 2) + ((emacs + (25)) + (ivy + (0 10 0))) + "Dynamic file browsing grid using ivy" single + ((:keywords "convenience" "files" "matching") + (:authors + ("Clemens Radermacher" . "clemera@posteo.net")) + (:maintainer "Clemens Radermacher" . "clemera@posteo.net") + (:url . "https://github.com/clemera/ivy-explorer"))]) + (javaimp . + [(0 7 1) + nil "Add and reorder Java import statements in Maven/Gradle projects" tar + ((:maintainer "Filipp Gunbin" . "fgunbin@fastmail.fm") + (:authors + ("Filipp Gunbin" . "fgunbin@fastmail.fm")) + (:keywords "java" "maven" "gradle" "programming") + (:url . "http://elpa.gnu.org/packages/javaimp.html"))]) + (jgraph-mode . + [(1 1) + ((cl-lib + (0 5))) + "Major mode for Jgraph files" single + ((:url . "http://elpa.gnu.org/packages/jgraph-mode.html") + (:keywords "tex" "wp") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (js2-mode . + [(20190219) + ((emacs + (24 1)) + (cl-lib + (0 5))) + "Improved JavaScript editing mode" tar + ((:url . "https://github.com/mooz/js2-mode/") + (:maintainer "Steve Yegge" . "steve.yegge@gmail.com") + (:authors + ("Steve Yegge" . "steve.yegge@gmail.com") + ("mooz" . "stillpedant@gmail.com") + ("Dmitry Gutov" . "dgutov@yandex.ru")) + (:keywords "languages" "javascript"))]) + (json-mode . + [(0 1) + ((emacs + (25 1))) + "Major mode for editing JSON files" single + ((:url . "http://elpa.gnu.org/packages/json-mode.html") + (:keywords "data") + (:authors + ("Simen Heggestøyl" . "simenheg@gmail.com")) + (:maintainer "Simen Heggestøyl" . "simenheg@gmail.com"))]) + (jsonrpc . + [(1 0 11) + ((emacs + (25 2))) + "JSON-RPC library" single + ((:url . "http://elpa.gnu.org/packages/jsonrpc.html") + (:keywords "processes" "languages" "extensions") + (:authors + ("João Távora" . "joaotavora@gmail.com")) + (:maintainer "João Távora" . "joaotavora@gmail.com"))]) + (jumpc . + [(3 0) + nil "jump to previous insertion points" single + ((:url . "http://elpa.gnu.org/packages/jumpc.html") + (:authors + ("Ivan Kanis" . "ivan@kanis.fr")) + (:maintainer "Ivan Kanis" . "ivan@kanis.fr"))]) + (kmb . + [(0 1) + ((emacs + (24 1))) + "Kill buffers matching a regexp w/o confirmation" single + ((:url . "http://elpa.gnu.org/packages/kmb.html") + (:keywords "lisp" "convenience") + (:authors + ("Tino Calancha" . "tino.calancha@gmail.com")) + (:maintainer "Tino Calancha"))]) + (landmark . + [(1 0) + nil "Neural-network robot that learns landmarks" single + ((:url . "http://elpa.gnu.org/packages/landmark.html") + (:keywords "games" "neural network" "adaptive search" "chemotaxis") + (:authors + ("Terrence Brannon" . "metaperl@gmail.com")) + (:maintainer nil . "emacs-devel@gnu.org"))]) + (let-alist . + [(1 0 6) + ((emacs + (24 1))) + "Easily let-bind values of an assoc-list by their names" single + ((:url . "http://elpa.gnu.org/packages/let-alist.html") + (:keywords "extensions" "lisp") + (:authors + ("Artur Malabarba" . "emacs@endlessparentheses.com")) + (:maintainer "Artur Malabarba" . "emacs@endlessparentheses.com"))]) + (lex . + [(1 1) + nil "Lexical analyser construction" tar + ((:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:url . "http://elpa.gnu.org/packages/lex.html"))]) + (lmc . + [(1 4) + ((emacs + (24)) + (cl-lib + (0 5))) + "Little Man Computer in Elisp" single + ((:url . "http://elpa.gnu.org/packages/lmc.html") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (load-dir . + [(0 0 5) + ((cl-lib + (0 5))) + "Load all Emacs Lisp files in a given directory" single + ((:url . "http://elpa.gnu.org/packages/load-dir.html") + (:keywords "lisp" "files" "convenience") + (:maintainer "Teodor Zlatanov" . "tzz@lifelogs.com"))]) + (load-relative . + [(1 3 1) + nil "Relative file load (within a multi-file Emacs package)" single + ((:keywords "internal") + (:authors + ("Rocky Bernstein" . "rocky@gnu.org")) + (:maintainer "Rocky Bernstein" . "rocky@gnu.org") + (:url . "http://github.com/rocky/emacs-load-relative"))]) + (loc-changes . + [(1 2) + nil "keep track of positions even after buffer changes" single + ((:authors + ("Rocky Bernstein" . "rocky@gnu.org")) + (:maintainer "Rocky Bernstein" . "rocky@gnu.org") + (:url . "http://github.com/rocky/emacs-loc-changes"))]) + (loccur . + [(1 2 4) + ((emacs + (24 3))) + "Perform an occur-like folding in current buffer" single + ((:keywords "matching") + (:authors + ("Alexey Veretennikov" . "alexey.veretennikov@gmail.com")) + (:maintainer "Alexey Veretennikov" . "alexey.veretennikov@gmail.com") + (:url . "https://github.com/fourier/loccur"))]) + (map . + [(2 1) + ((emacs + (25))) + "Map manipulation functions" single + ((:url . "http://elpa.gnu.org/packages/map.html") + (:keywords "convenience" "map" "hash-table" "alist" "array") + (:authors + ("Nicolas Petton" . "nicolas@petton.fr")) + (:maintainer nil . "emacs-devel@gnu.org"))]) + (markchars . + [(0 2 1) + nil "Mark chars fitting certain characteristics" single + ((:url . "http://elpa.gnu.org/packages/markchars.html") + (:authors + ("Lennart Borgman" . "lennart.borgman@gmail.com")) + (:maintainer "Lennart Borgman" . "lennart.borgman@gmail.com"))]) + (math-symbol-lists . + [(1 2 1) + nil "Lists of Unicode math symbols and latex commands" single + ((:keywords "unicode" "symbols" "mathematics") + (:authors + ("Vitalie Spinu" . "spinuvit@gmail.com")) + (:maintainer "Vitalie Spinu" . "spinuvit@gmail.com") + (:url . "https://github.com/vspinu/math-symbol-lists"))]) + (memory-usage . + [(0 2) + nil "Analyze the memory usage of Emacs in various ways" single + ((:url . "http://elpa.gnu.org/packages/memory-usage.html") + (:keywords "maint") + (:authors + ("Stefan Monnier" . "monnier@cs.yale.edu")) + (:maintainer "Stefan Monnier" . "monnier@cs.yale.edu"))]) + (metar . + [(0 3) + ((cl-lib + (0 5))) + "Retrieve and decode METAR weather information" single + ((:url . "http://elpa.gnu.org/packages/metar.html") + (:keywords "comm") + (:authors + ("Mario Lang" . "mlang@delysid.org")) + (:maintainer "Mario Lang" . "mlang@delysid.org"))]) + (midi-kbd . + [(0 2) + ((emacs + (25))) + "Create keyboard events from Midi input" single + ((:url . "http://elpa.gnu.org/packages/midi-kbd.html") + (:keywords "convenience" "hardware" "multimedia") + (:authors + ("David Kastrup" . "dak@gnu.org")) + (:maintainer "David Kastrup" . "dak@gnu.org"))]) + (mines . + [(1 6) + ((emacs + (24 4)) + (cl-lib + (0 5))) + "Minesweeper game" tar + ((:url . "https://github.com/calancha/Minesweeper") + (:maintainer "Tino Calancha" . "tino.calancha@gmail.com") + (:authors + ("Tino Calancha" . "tino.calancha@gmail.com")) + (:keywords "games"))]) + (minibuffer-line . + [(0 1) + nil "Display status info in the minibuffer window" single + ((:url . "http://elpa.gnu.org/packages/minibuffer-line.html") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (minimap . + [(1 3) + nil "Sidebar showing a \"mini-map\" of a buffer" single + ((:url . "http://elpa.gnu.org/packages/minimap.html") + (:authors + ("David Engster" . "deng@randomsample.de")) + (:maintainer "David Engster" . "deng@randomsample.de"))]) + (mmm-mode . + [(0 5 7) + ((cl-lib + (0 2))) + "Allow Multiple Major Modes in a buffer" tar + ((:url . "https://github.com/purcell/mmm-mode") + (:maintainer "Dmitry Gutov" . "dgutov@yandex.ru") + (:authors + ("Michael Abraham Shulman" . "viritrilbia@gmail.com")) + (:keywords "convenience" "faces" "languages" "tools"))]) + (modus-operandi-theme . + [(0 8 1) + ((emacs + (26 1))) + "Accessible light theme (WCAG AAA)" single + ((:keywords "faces" "theme" "accessibility") + (:authors + ("Protesilaos Stavrou" . "info@protesilaos.com")) + (:maintainer "Protesilaos Stavrou" . "info@protesilaos.com") + (:url . "https://gitlab.com/protesilaos/modus-themes"))]) + (modus-vivendi-theme . + [(0 8 1) + ((emacs + (26 1))) + "Accessible dark theme (WCAG AAA)" single + ((:keywords "faces" "theme" "accessibility") + (:authors + ("Protesilaos Stavrou" . "info@protesilaos.com")) + (:maintainer "Protesilaos Stavrou" . "info@protesilaos.com") + (:url . "https://gitlab.com/protesilaos/modus-themes"))]) + (multishell . + [(1 1 5) + ((cl-lib + (0 5))) + "Easily use multiple shell buffers, local and remote" tar + ((:url . "https://github.com/kenmanheimer/EmacsMultishell") + (:maintainer "Ken Manheimer" . "ken.manheimer@gmail.com") + (:authors + ("Ken Manheimer" . "ken.manheimer@gmail.com")) + (:keywords "processes"))]) + (muse . + [(3 20 2) + nil "Authoring and publishing tool for Emacs" tar + ((:url . "http://mwolson.org/projects/EmacsMuse.html") + (:maintainer "Michael Olson" . "mwolson@gnu.org") + (:authors + ("John Wiegley" . "johnw@gnu.org")) + (:keywords "hypermedia"))]) + (myers . + [(0 1) + ((emacs + (25))) + "Random-access singly-linked lists" single + ((:url . "http://elpa.gnu.org/packages/myers.html") + (:keywords "list" "containers") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (nadvice . + [(0 3) + nil "Forward compatibility for Emacs-24.4's nadvice" single + ((:url . "http://elpa.gnu.org/packages/nadvice.html") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (nameless . + [(1 0 2) + ((emacs + (24 4))) + "Hide package namespace in your emacs-lisp code" single + ((:keywords "convenience" "lisp") + (:authors + ("Artur Malabarba" . "emacs@endlessparentheses.com")) + (:maintainer "Artur Malabarba" . "emacs@endlessparentheses.com") + (:url . "https://github.com/Malabarba/nameless"))]) + (names . + [(20151201 0) + ((emacs + (24 1)) + (cl-lib + (0 5)) + (nadvice + (0 3))) + "Namespaces for emacs-lisp. Avoid name clobbering without hiding symbols." tar + ((:url . "https://github.com/Malabarba/names") + (:maintainer "Artur Malabarba" . "emacs@endlessparentheses.com") + (:authors + ("Artur Malabarba" . "emacs@endlessparentheses.com")) + (:keywords "extensions" "lisp"))]) + (nhexl-mode . + [(1 5) + ((emacs + (24 4)) + (cl-lib + (0 5))) + "Minor mode to edit files via hex-dump format" single + ((:url . "http://elpa.gnu.org/packages/nhexl-mode.html") + (:keywords "data") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (nlinum . + [(1 9) + nil "Show line numbers in the margin" single + ((:url . "http://elpa.gnu.org/packages/nlinum.html") + (:keywords "convenience") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (notes-mode . + [(1 30) + nil "Indexing system for on-line note-taking" tar + ((:maintainer nil . ".") + (:authors + (nil . ".")) + (:url . "http://elpa.gnu.org/packages/notes-mode.html"))]) + (ntlm . + [(2 1 0) + nil "NTLM (NT LanManager) authentication support" single + ((:url . "http://elpa.gnu.org/packages/ntlm.html") + (:keywords "ntlm" "sasl" "comm") + (:authors + ("Taro Kawagishi" . "tarok@transpulse.org")) + (:maintainer "Thomas Fitzsimmons" . "fitzsim@fitzsim.org"))]) + (num3-mode . + [(1 3) + nil "highlight groups of digits in long numbers" single + ((:url . "http://elpa.gnu.org/packages/num3-mode.html") + (:keywords "faces" "minor-mode") + (:authors + ("Felix Lee , Michal Nazarewicz" . "mina86@mina86.com")) + (:maintainer "Michal Nazarewicz" . "mina86@mina86.com"))]) + (oauth2 . + [(0 13) + nil "OAuth 2.0 Authorization Protocol" single + ((:url . "http://elpa.gnu.org/packages/oauth2.html") + (:keywords "comm") + (:authors + ("Julien Danjou" . "julien@danjou.info")) + (:maintainer "Julien Danjou" . "julien@danjou.info"))]) + (objed . + [(0 8 3) + ((emacs + (25)) + (cl-lib + (0 5))) + "Navigate and edit text objects." tar + ((:url . "https://github.com/clemera/objed") + (:maintainer "Clemens Radermacher" . "clemera@posteo.net") + (:authors + ("Clemens Radermacher" . "clemera@posteo.net")) + (:keywords "convenience"))]) + (olivetti . + [(1 7 1) + ((emacs + (24 5))) + "Minor mode for a nice writing environment" single + ((:url . "http://elpa.gnu.org/packages/olivetti.html") + (:keywords "wp" "text") + (:authors + ("Paul W. Rankin" . "pwr@sdf.org")) + (:maintainer "Paul W. Rankin" . "pwr@sdf.org"))]) + (omn-mode . + [(1 2) + nil "Support for OWL Manchester Notation" single + ((:url . "http://elpa.gnu.org/packages/omn-mode.html") + (:authors + ("Phillip Lord" . "phillip.lord@newcastle.ac.uk")) + (:maintainer "Phillip Lord" . "phillip.lord@newcastle.ac.uk"))]) + (on-screen . + [(1 3 3) + ((cl-lib + (0))) + "guide your eyes while scrolling" single + ((:keywords "convenience") + (:authors + ("Michael Heerdegen" . "michael_heerdegen@web.de")) + (:maintainer "Michael Heerdegen" . "michael_heerdegen@web.de") + (:url . "https://github.com/michael-heerdegen/on-screen.el"))]) + (org . + [(9 3 6) + nil "Outline-based notes management and organizer" tar + ((:url . "https://orgmode.org") + (:maintainer "Bastien Guerry" . "bzg@gnu.org") + (:authors + ("Carsten Dominik ")) + (:keywords "outlines" "hypermedia" "calendar" "wp"))]) + (org-edna . + [(1 1 1) + ((emacs + (25 1)) + (seq + (2 19)) + (org + (9 0 5))) + "Extensible Dependencies 'N' Actions" tar + ((:url . "https://savannah.nongnu.org/projects/org-edna-el/") + (:maintainer "Ian Dunn" . "dunni@gnu.org") + (:authors + ("Ian Dunn" . "dunni@gnu.org")) + (:keywords "convenience" "text" "org"))]) + (orgalist . + [(1 12) + ((emacs + (24 4))) + "Manage Org-like lists in non-Org buffers" single + ((:url . "http://elpa.gnu.org/packages/orgalist.html") + (:keywords "convenience") + (:authors + ("Nicolas Goaziou" . "mail@nicolasgoaziou.fr")) + (:maintainer "Nicolas Goaziou" . "mail@nicolasgoaziou.fr"))]) + (osc . + [(0 2) + nil "Open Sound Control protocol library" single + ((:url . "http://elpa.gnu.org/packages/osc.html") + (:keywords "comm" "processes" "multimedia") + (:authors + ("Mario Lang" . "mlang@blind.guru")) + (:maintainer "Mario Lang" . "mlang@blind.guru"))]) + (other-frame-window . + [(1 0 6) + ((emacs + (24 4))) + "Minor mode to enable global prefix keys for other frame/window buffer placement" single + ((:url . "http://elpa.gnu.org/packages/other-frame-window.html") + (:keywords "frame" "window") + (:authors + ("Stephen Leake" . "stephen_leake@member.fsf.org")) + (:maintainer "Stephen Leake" . "stephen_leake@member.fsf.org"))]) + (pabbrev . + [(4 2 1) + nil "Predictive abbreviation expansion" single + ((:url . "http://elpa.gnu.org/packages/pabbrev.html") + (:authors + ("Phillip Lord" . "phillip.lord@newcastle.ac.uk")) + (:maintainer "Phillip Lord" . "phillip.lord@newcastle.ac.uk"))]) + (paced . + [(1 1 3) + ((emacs + (25 1)) + (async + (1 9 1))) + "Predictive Abbreviation Completion and Expansion using Dictionaries" tar + ((:url . "https://savannah.nongnu.org/projects/paced-el/") + (:maintainer "Ian Dunn" . "dunni@gnu.org") + (:authors + ("Ian Dunn" . "dunni@gnu.org")) + (:keywords "convenience" "completion"))]) + (parsec . + [(0 1 3) + ((emacs + (24)) + (cl-lib + (0 5))) + "Parser combinator library" tar + ((:url . "https://github.com/cute-jumper/parsec.el") + (:maintainer "Junpeng Qiu" . "qjpchmail@gmail.com") + (:authors + ("Junpeng Qiu" . "qjpchmail@gmail.com")) + (:keywords "extensions"))]) + (path-iterator . + [(1 0) + ((emacs + (25 0))) + "An iterator for traversing a directory path." tar + ((:maintainer "Stephen Leake" . "stephen_leake@stephe-leake.org") + (:authors + ("Stephen Leake" . "stephen_leake@stephe-leake.org")) + (:url . "http://elpa.gnu.org/packages/path-iterator.html"))]) + (peg . + [(1 0) + ((emacs + (25))) + "Parsing Expression Grammars in Emacs Lisp" tar + ((:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca") + (:authors + ("Helmut Eller" . "eller.helmut@gmail.com")) + (:url . "http://elpa.gnu.org/packages/peg.html"))]) + (persist . + [(0 4) + nil "Persist Variables between Emacs Sessions" tar + ((:maintainer "Phillip Lord" . "phillip.lord@russet.org.uk") + (:authors + ("Phillip Lord" . "phillip.lord@russet.org.uk")) + (:url . "http://elpa.gnu.org/packages/persist.html"))]) + (phps-mode . + [(0 3 46) + ((emacs + (26))) + "Major mode for PHP with Semantic integration" tar + ((:url . "https://github.com/cjohansson/emacs-phps-mode") + (:maintainer "Christian Johansson" . "christian@cvj.se") + (:authors + ("Christian Johansson" . "christian@cvj.se")) + (:keywords "tools" "convenience"))]) + (pinentry . + [(0 1) + nil "GnuPG Pinentry server implementation" single + ((:url . "http://elpa.gnu.org/packages/pinentry.html") + (:keywords "gnupg") + (:authors + ("Daiki Ueno" . "ueno@gnu.org")) + (:maintainer "Daiki Ueno" . "ueno@gnu.org"))]) + (poker . + [(0 2) + nil "Texas hold 'em poker" single + ((:url . "http://elpa.gnu.org/packages/poker.html") + (:keywords "games") + (:authors + ("Mario Lang" . "mlang@delysid.org")) + (:maintainer "Mario Lang" . "mlang@delysid.org"))]) + (posframe . + [(0 7 0) + ((emacs + (26))) + "Pop a posframe (just a frame) at point" single + ((:keywords "convenience" "tooltip") + (:authors + ("Feng Shu" . "tumashu@163.com")) + (:maintainer "Feng Shu" . "tumashu@163.com") + (:url . "https://github.com/tumashu/posframe"))]) + (psgml . + [(1 3 4) + nil "SGML-editing mode with parsing support" tar + ((:maintainer "Lennart Staflin" . "lstaflin@gmail.com") + (:authors + ("Lennart Staflin" . "lenst@lysator.liu.se") + ("James Clark" . "jjc@clark.com")) + (:keywords "languages") + (:url . "http://elpa.gnu.org/packages/psgml.html"))]) + (python . + [(0 26 1) + ((emacs + (24 1)) + (cl-lib + (1 0))) + "Python's flying circus support for Emacs" single + ((:keywords "languages") + (:authors + ("Fabián E. Gallina" . "fgallina@gnu.org")) + (:maintainer nil . "emacs-devel@gnu.org") + (:url . "https://github.com/fgallina/python.el"))]) + (quarter-plane . + [(0 1) + nil "Minor mode for quarter-plane style editing" single + ((:url . "http://elpa.gnu.org/packages/quarter-plane.html") + (:keywords "convenience" "wp") + (:authors + ("Peter J. Weisberg")) + (:maintainer "Peter J. Weisberg"))]) + (queue . + [(0 2) + nil "Queue data structure" single + ((:keywords "extensions" "data structures" "queue") + (:authors + ("Inge Wallin" . "inge@lysator.liu.se") + ("Toby Cubitt" . "toby-predictive@dr-qubit.org")) + (:maintainer "Toby Cubitt" . "toby-predictive@dr-qubit.org") + (:url . "http://www.dr-qubit.org/emacs.php"))]) + (rainbow-mode . + [(1 0 4) + nil "Colorize color names in buffers" single + ((:url . "http://elpa.gnu.org/packages/rainbow-mode.html") + (:keywords "faces") + (:authors + ("Julien Danjou" . "julien@danjou.info")) + (:maintainer "Julien Danjou" . "julien@danjou.info"))]) + (rbit . + [(0 1) + nil "Red-black persistent interval trees" single + ((:url . "http://elpa.gnu.org/packages/rbit.html") + (:keywords "data structures" "binary tree" "intervals") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (rcirc-color . + [(0 4 1) + ((emacs + (24 4))) + "color nicks" single + ((:url . "http://elpa.gnu.org/packages/rcirc-color.html") + (:keywords "comm") + (:authors + ("Alex Schroeder" . "alex@gnu.org")) + (:maintainer "Alex Schroeder" . "alex@gnu.org"))]) + (rcirc-menu . + [(1 1) + nil "A menu of all your rcirc connections" single + ((:url . "http://elpa.gnu.org/packages/rcirc-menu.html") + (:keywords "comm") + (:authors + ("Alex Schroeder" . "alex@gnu.org")) + (:maintainer "Alex Schroeder" . "alex@gnu.org"))]) + (realgud . + [(1 5 1) + ((load-relative + (1 3 1)) + (loc-changes + (1 2)) + (test-simple + (1 3 0)) + (emacs + (25))) + "A modular front-end for interacting with external debuggers" tar + ((:url . "http://github.com/realgud/realgud/") + (:maintainer "Rocky Bernstein" . "rocky@gnu.org") + (:authors + ("Rocky Bernstein" . "rocky@gnu.org")) + (:keywords "debugger" "gdb" "python" "perl" "go" "bash" "zsh" "bashdb" "zshdb" "remake" "trepan" "perldb" "pdb"))]) + (realgud-ipdb . + [(1 0 0) + ((realgud + (1 5 0)) + (load-relative + (1 3 1)) + (emacs + (25))) + "Realgud front-end to ipdb" tar + ((:url . "http://github.com/rocky/realgud-ipdb") + (:maintainer "Rocky Bernstein" . "rocky@gnu.org") + (:authors + ("Rocky Bernstein" . "rocky@gnu.org")))]) + (realgud-jdb . + [(1 0 0) + ((realgud + (1 4 5)) + (load-relative + (1 2)) + (cl-lib + (0 5)) + (emacs + (25))) + "Realgud front-end to Java's jdb debugger\"" tar + ((:url . "http://github.com/realgud/realgud-jdb") + (:maintainer "Rocky Bernstein" . "rocky@gnu.org") + (:authors + ("Rocky Bernstein" . "rocky@gnu.org")))]) + (realgud-lldb . + [(1 0 2) + ((load-relative + (1 3 1)) + (realgud + (1 5 0)) + (emacs + (25))) + "Realgud front-end to lldb" tar + ((:url . "http://github.com/realgud/realgud-lldb") + (:maintainer "Rocky Bernstein" . "rocky@gnu.org") + (:authors + ("Rocky Bernstein" . "rocky@gnu.org")))]) + (realgud-node-debug . + [(1 0 0) + ((realgud + (1 4 5)) + (load-relative + (1 2)) + (cl-lib + (0 5)) + (emacs + (25))) + "Realgud front-end to older \"node debug\"" tar + ((:url . "http://github.com/realgud/realgud-node-debug") + (:maintainer "Rocky Bernstein" . "rocky@gnu.org") + (:authors + ("Rocky Bernstein" . "rocky@gnu.org")))]) + (realgud-node-inspect . + [(1 0 0) + ((realgud + (1 4 5)) + (load-relative + (1 2)) + (cl-lib + (0 5)) + (emacs + (24))) + "Realgud front-end to newer \"node inspect\"" tar + ((:url . "http://github.com/realgud/realgud-node-inspect") + (:maintainer "Rocky Bernstein" . "rocky@gnu.org") + (:authors + ("Rocky Bernstein" . "rocky@gnu.org")))]) + (realgud-trepan-ni . + [(1 0 1) + ((load-relative + (1 2)) + (realgud + (1 5 0)) + (cl-lib + (0 5)) + (emacs + (25))) + "Realgud front-end to trepan-ni" tar + ((:url . "http://github.com/realgud/realgud-trepan-ni") + (:maintainer "Rocky Bernstein" . "rocky@gnu.org") + (:authors + ("Rocky Bernstein" . "rocky@gnu.org")))]) + (register-list . + [(0 1) + nil "Interactively list/edit registers" single + ((:url . "http://elpa.gnu.org/packages/register-list.html") + (:keywords "register") + (:authors + ("Bastien Guerry" . "bzg@gnu.org")) + (:maintainer "Bastien Guerry" . "bzg@gnu.org"))]) + (relint . + [(1 16) + ((xr + (1 19)) + (emacs + (26 1))) + "Elisp regexp mistake finder" tar + ((:url . "https://github.com/mattiase/relint") + (:maintainer "Mattias Engdegård" . "mattiase@acm.org") + (:authors + ("Mattias Engdegård" . "mattiase@acm.org")) + (:keywords "lisp" "regexps"))]) + (rich-minority . + [(1 0 1) + ((cl-lib + (0 5))) + "Clean-up and Beautify the list of minor-modes." single + ((:keywords "mode-line" "faces") + (:authors + ("Artur Malabarba" . "emacs@endlessparentheses.com")) + (:maintainer "Artur Malabarba" . "emacs@endlessparentheses.com") + (:url . "https://github.com/Malabarba/rich-minority"))]) + (rnc-mode . + [(0 2) + nil "Emacs mode to edit Relax-NG Compact files" single + ((:url . "http://elpa.gnu.org/packages/rnc-mode.html") + (:keywords "xml" "relaxng") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (rudel . + [(0 3 1) + ((emacs + (24)) + (cl-lib + (0 5)) + (cl-generic + (0 3)) + (cl-print + (1 0))) + "A collaborative editing framework for Emacs" tar + ((:url . "http://rudel.sourceforge.net/") + (:maintainer "Jan Moringen" . "scymtym@users.sourceforge.net") + (:authors + ("Jan Moringen" . "scymtym@users.sourceforge.net")) + (:keywords "rudel" "collaboration"))]) + (scanner . + [(0 1) + ((emacs + (25 1)) + (dash + (2 12 0))) + "Scan documents and images" tar + ((:url . "https://gitlab.com/rstocker/scanner.git") + (:maintainer "Raffael Stocker" . "r.stocker@mnet-mail.de") + (:authors + ("Raffael Stocker" . "r.stocker@mnet-mail.de")) + (:keywords "hardware" "multimedia"))]) + (scroll-restore . + [(1 0) + nil "restore original position after scrolling" single + ((:url . "http://elpa.gnu.org/packages/scroll-restore.html") + (:keywords "scrolling") + (:authors + ("Martin Rudalics" . "rudalics@gmx.at")) + (:maintainer "Martin Rudalics" . "rudalics@gmx.at"))]) + (sed-mode . + [(1 0) + nil "Major mode to edit sed scripts" single + ((:url . "http://elpa.gnu.org/packages/sed-mode.html") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (seq . + [(2 20) + nil "Sequence manipulation functions" tar + ((:maintainer nil . "emacs-devel@gnu.org") + (:authors + ("Nicolas Petton" . "nicolas@petton.fr")) + (:keywords "sequences") + (:url . "http://elpa.gnu.org/packages/seq.html"))]) + (shelisp . + [(0 9 1) + nil "execute elisp in shell" single + ((:url . "http://elpa.gnu.org/packages/shelisp.html") + (:keywords "terminals" "lisp" "processes") + (:authors + ("Michael R. Mauger" . "michael@mauger.com")) + (:maintainer "Michael R. Mauger" . "michael@mauger.com"))]) + (shen-mode . + [(0 1) + nil "A major mode for editing shen source code" tar + ((:maintainer "Eric Schulte" . "schulte.eric@gmail.com") + (:authors + ("Eric Schulte" . "schulte.eric@gmail.com")) + (:keywords "languages" "shen") + (:url . "http://elpa.gnu.org/packages/shen-mode.html"))]) + (sisu-mode . + [(7 1 8) + nil "Major mode for SiSU markup text" single + ((:keywords "text" "syntax" "processes" "tools") + (:authors + ("Ralph Amissah & Ambrose Kofi Laing")) + (:maintainer "Ralph Amissah" . "ralph.amissah@gmail.com") + (:url . "http://www.sisudoc.org/"))]) + (sm-c-mode . + [(1 0) + nil "C major mode based on SMIE" single + ((:url . "http://elpa.gnu.org/packages/sm-c-mode.html") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (smalltalk-mode . + [(3 2 92) + nil "Major mode for the GNU Smalltalk programming language" tar + ((:maintainer "Derek Zhou" . "derek@3qin.us") + (:authors + ("Steve Byrne")) + (:url . "http://elpa.gnu.org/packages/smalltalk-mode.html"))]) + (smart-yank . + [(0 1 1) + ((emacs + (24))) + "A different approach of yank pointer handling" single + ((:url . "http://elpa.gnu.org/packages/smart-yank.html") + (:keywords "convenience") + (:authors + ("Michael Heerdegen" . "michael_heerdegen@web.de")) + (:maintainer "Michael Heerdegen" . "michael_heerdegen@web.de"))]) + (sml-mode . + [(6 10) + ((emacs + (24 3)) + (cl-lib + (0 5))) + "Major mode for editing (Standard) ML" single + ((:url . "http://elpa.gnu.org/packages/sml-mode.html") + (:keywords "sml") + (:authors + ("Lars Bo Nielsen") + (" Olin Shivers") + (" Fritz Knabe (?)") + (" Steven Gilmore (?)") + (" Matthew Morley" . "mjm@scs.leeds.ac.uk") + (" Matthias Blume" . "blume@cs.princeton.edu") + (" (Stefan Monnier)" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (soap-client . + [(3 1 5) + ((cl-lib + (0 6 1))) + "Access SOAP web services" tar + ((:url . "https://github.com/alex-hhh/emacs-soap-client") + (:maintainer "Alexandru Harsanyi" . "AlexHarsanyi@gmail.com") + (:authors + ("Alexandru Harsanyi" . "AlexHarsanyi@gmail.com")) + (:keywords "soap" "web-services" "comm" "hypermedia"))]) + (sokoban . + [(1 4 8) + ((emacs + (23 1)) + (cl-lib + (0 5))) + "Implementation of Sokoban for Emacs." tar + ((:maintainer "Dieter Deyke" . "dieter.deyke@gmail.com") + (:authors + ("Glynn Clements" . "glynn.clements@xemacs.org")) + (:keywords "games") + (:url . "http://elpa.gnu.org/packages/sokoban.html"))]) + (sotlisp . + [(1 6 2) + ((emacs + (24 1))) + "Write lisp at the speed of thought." single + ((:keywords "convenience" "lisp") + (:authors + ("Artur Malabarba" . "emacs@endlessparentheses.com")) + (:maintainer "Artur Malabarba" . "emacs@endlessparentheses.com") + (:url . "https://github.com/Malabarba/speed-of-thought-lisp"))]) + (spinner . + [(1 7 3) + nil "Add spinners and progress-bars to the mode-line for ongoing operations" single + ((:keywords "processes" "mode-line") + (:authors + ("Artur Malabarba" . "emacs@endlessparentheses.com")) + (:maintainer "Artur Malabarba" . "emacs@endlessparentheses.com") + (:url . "https://github.com/Malabarba/spinner.el"))]) + (sql-indent . + [(1 5) + ((cl-lib + (0 5))) + "Support for indenting code in SQL files." tar + ((:url . "https://github.com/alex-hhh/emacs-sql-indent") + (:maintainer "Alex Harsanyi" . "AlexHarsanyi@gmail.com") + (:authors + ("Alex Harsanyi" . "AlexHarsanyi@gmail.com")) + (:keywords "languages" "sql"))]) + (ssh-deploy . + [(3 1 11) + ((emacs + (25))) + "Deployment via Tramp, global or per directory." tar + ((:url . "https://github.com/cjohansson/emacs-ssh-deploy") + (:maintainer "Christian Johansson" . "christian@cvj.se") + (:authors + ("Christian Johansson" . "christian@cvj.se")) + (:keywords "tools" "convenience"))]) + (stream . + [(2 2 5) + ((emacs + (25))) + "Implementation of streams" tar + ((:maintainer nil . "nicolas@petton.fr") + (:authors + ("Nicolas Petton" . "nicolas@petton.fr")) + (:keywords "stream" "laziness" "sequences") + (:url . "http://elpa.gnu.org/packages/stream.html"))]) + (svg . + [(1 0) + ((emacs + (25))) + "SVG image creation functions" single + ((:url . "http://elpa.gnu.org/packages/svg.html") + (:keywords "image") + (:authors + ("Lars Magne Ingebrigtsen" . "larsi@gnus.org") + ("Felix E. Klee" . "felix.klee@inka.de")) + (:maintainer "Lars Magne Ingebrigtsen" . "larsi@gnus.org"))]) + (svg-clock . + [(1 1) + ((svg + (1 0)) + (emacs + (27 0))) + "Analog clock using Scalable Vector Graphics" single + ((:url . "http://elpa.gnu.org/packages/svg-clock.html") + (:keywords "demo" "svg" "clock") + (:authors + ("Ulf Jasper" . "ulf.jasper@web.de")) + (:maintainer "Ulf Jasper" . "ulf.jasper@web.de"))]) + (system-packages . + [(1 0 11) + ((emacs + (24 3))) + "functions to manage system packages" tar + ((:url . "https://gitlab.com/jabranham/system-packages") + (:maintainer "J. Alexander Branham" . "alex.branham@gmail.com") + (:authors + ("J. Alexander Branham" . "alex.branham@gmail.com")))]) + (tNFA . + [(0 1 1) + ((queue + (0 1))) + "Tagged non-deterministic finite-state automata" single + ((:keywords "extensions" "matching" "data structures tnfa" "nfa" "dfa" "finite state automata" "automata" "regexp") + (:authors + ("Toby Cubitt" . "toby-predictive@dr-qubit.org")) + (:maintainer "Toby Cubitt" . "toby-predictive@dr-qubit.org") + (:url . "http://www.dr-qubit.org/emacs.php"))]) + (temp-buffer-browse . + [(1 5) + ((emacs + (24))) + "temp buffer browse mode" single + ((:url . "http://elpa.gnu.org/packages/temp-buffer-browse.html") + (:keywords "convenience") + (:authors + ("Leo Liu" . "sdl.web@gmail.com")) + (:maintainer "Leo Liu" . "sdl.web@gmail.com"))]) + (test-simple . + [(1 3 0) + ((cl-lib + (0))) + "Simple Unit Test Framework for Emacs Lisp" single + ((:keywords "unit-test") + (:authors + ("Rocky Bernstein" . "rocky@gnu.org")) + (:maintainer "Rocky Bernstein" . "rocky@gnu.org") + (:url . "http://github.com/rocky/emacs-test-simple"))]) + (timerfunctions . + [(1 4 2) + ((cl-lib + (0 5)) + (emacs + (24))) + "Enhanced versions of some timer.el functions" single + ((:url . "http://elpa.gnu.org/packages/timerfunctions.html") + (:authors + ("Dave Goel" . "deego3@gmail.com")) + (:maintainer "Dave Goel" . "deego3@gmail.com"))]) + (tiny . + [(0 2 1) + nil "Quickly generate linear ranges in Emacs" tar + ((:url . "https://github.com/abo-abo/tiny") + (:maintainer "Oleh Krehel" . "ohwoeowho@gmail.com") + (:authors + ("Oleh Krehel" . "ohwoeowho@gmail.com")) + (:keywords "convenience"))]) + (tramp . + [(2 4 3 4) + ((emacs + (24 4))) + "Transparent Remote Access, Multiple Protocol" tar + ((:url . "https://savannah.gnu.org/projects/tramp") + (:maintainer "Michael Albinus" . "michael.albinus@gmx.de") + (:authors + ("Kai Großjohann" . "kai.grossjohann@gmx.net") + ("Michael Albinus" . "michael.albinus@gmx.de")) + (:keywords "comm" "processes"))]) + (tramp-theme . + [(0 2) + ((emacs + (24 1))) + "Custom theme for remote buffers" single + ((:url . "http://elpa.gnu.org/packages/tramp-theme.html") + (:keywords "convenience" "faces") + (:authors + ("Michael Albinus" . "michael.albinus@gmx.de")) + (:maintainer "Michael Albinus" . "michael.albinus@gmx.de"))]) + (transcribe . + [(1 5 2) + nil "Package for audio transcriptions" single + ((:url . "http://elpa.gnu.org/packages/transcribe.html") + (:authors + ("David Gonzalez Gandara" . "dggandara@member.fsf.org")) + (:maintainer "David Gonzalez Gandara" . "dggandara@member.fsf.org"))]) + (trie . + [(0 4) + ((tNFA + (0 1 1)) + (heap + (0 3))) + "Trie data structure" single + ((:keywords "extensions" "matching" "data structures trie" "ternary search tree" "tree" "completion" "regexp") + (:authors + ("Toby Cubitt" . "toby-predictive@dr-qubit.org")) + (:maintainer "Toby Cubitt" . "toby-predictive@dr-qubit.org") + (:url . "http://www.dr-qubit.org/emacs.php"))]) + (undo-tree . + [(0 7 4) + nil "Treat undo history as a tree" single + ((:keywords "convenience" "files" "undo" "redo" "history" "tree") + (:authors + ("Toby Cubitt" . "toby-undo-tree@dr-qubit.org")) + (:maintainer "Toby Cubitt" . "toby-undo-tree@dr-qubit.org") + (:url . "http://www.dr-qubit.org/emacs.php"))]) + (uni-confusables . + [(0 1) + nil "Unicode confusables table" tar + ((:maintainer "Teodor Zlatanov" . "tzz@lifelogs.com") + (:url . "http://elpa.gnu.org/packages/uni-confusables.html"))]) + (uniquify-files . + [(1 0 2) + ((emacs + (25 0))) + "Completion style for files, minimizing directories" tar + ((:maintainer "Stephen Leake" . "stephen_leake@stephe-leake.org") + (:authors + ("Stephen Leake" . "stephen_leake@stephe-leake.org")) + (:keywords "completion" "table" "uniquify") + (:url . "http://elpa.gnu.org/packages/uniquify-files.html"))]) + (url-http-ntlm . + [(2 0 4) + ((cl-lib + (0 5)) + (ntlm + (2 1 0))) + "NTLM authentication for the url library" single + ((:keywords "comm" "data" "processes" "hypermedia") + (:authors + ("Tom Schutzer-Weissmann" . "tom.weissmann@gmail.com")) + (:maintainer "Thomas Fitzsimmons" . "fitzsim@fitzsim.org") + (:url . "https://code.google.com/p/url-http-ntlm/"))]) + (validate . + [(1 0 4) + ((emacs + (24 1)) + (cl-lib + (0 5)) + (seq + (2 16))) + "Schema validation for Emacs-lisp" single + ((:url . "http://elpa.gnu.org/packages/validate.html") + (:keywords "lisp") + (:authors + ("Artur Malabarba" . "emacs@endlessparentheses.com")) + (:maintainer "Artur Malabarba" . "emacs@endlessparentheses.com"))]) + (vcard . + [(0 1) + ((emacs + (27 1))) + "Package for handling vCard files" tar + ((:maintainer "Eric Abrahamsen" . "eric@ericabrahamsen.net") + (:authors + ("Eric Abrahamsen" . "eric@ericabrahamsen.net")) + (:url . "http://elpa.gnu.org/packages/vcard.html"))]) + (vcl-mode . + [(1 1) + nil "Major mode for Varnish Configuration Language" single + ((:url . "http://elpa.gnu.org/packages/vcl-mode.html") + (:keywords "varnish" "vcl") + (:authors + ("Sergey Poznyakoff" . "gray@gnu.org.ua")) + (:maintainer "Sergey Poznyakoff" . "gray@gnu.org.ua"))]) + (vdiff . + [(0 2 3) + ((emacs + (24 4)) + (hydra + (0 13 0))) + "A diff tool similar to vimdiff" single + ((:keywords "diff") + (:authors + ("Justin Burkett" . "justin@burkett.cc")) + (:maintainer "Justin Burkett" . "justin@burkett.cc") + (:url . "https://github.com/justbur/emacs-vdiff"))]) + (verilog-mode . + [(2020 2 23 232634261) + nil "major mode for editing verilog source in Emacs" single + ((:keywords "languages") + (:authors + ("Michael McNamara" . "mac@verilog.com") + ("Wilson Snyder" . "wsnyder@wsnyder.org")) + (:maintainer "Michael McNamara" . "mac@verilog.com") + (:url . "https://www.veripool.org"))]) + (vigenere . + [(1 0) + ((emacs + (25 1))) + "Run a vigenere cipher on a block of text ;" single + ((:keywords "data" "vigenere" "cipher") + (:authors + ("Ian Dunn" . "dunni@gnu.org")) + (:maintainer "Ian Dunn" . "dunni@gnu.org") + (:url . "https://elpa.gnu.org/packages/vigenere.html"))]) + (visual-filename-abbrev . + [(1 0) + ((emacs + (26 1))) + "Visually abbreviate filenames" single + ((:url . "http://elpa.gnu.org/packages/visual-filename-abbrev.html") + (:keywords "tools") + (:authors + ("Tassilo Horn" . "tsdh@gnu.org")) + (:maintainer "Tassilo Horn" . "tsdh@gnu.org"))]) + (visual-fill . + [(0 1) + nil "Auto-refill paragraphs without modifying the buffer" single + ((:url . "http://elpa.gnu.org/packages/visual-fill.html") + (:authors + ("Stefan Monnier" . "monnier@iro.umontreal.ca")) + (:maintainer "Stefan Monnier" . "monnier@iro.umontreal.ca"))]) + (vlf . + [(1 7 1) + nil "View Large Files" tar + ((:url . "https://github.com/m00natic/vlfi") + (:maintainer "Andrey Kotlarski" . "m00naticus@gmail.com") + (:keywords "large files" "utilities"))]) + (wcheck-mode . + [(2019 6 17) + nil "General interface for text checkers" single + ((:keywords "text" "spell" "check" "languages" "ispell") + (:authors + ("Teemu Likonen" . "tlikonen@iki.fi")) + (:maintainer "Teemu Likonen" . "tlikonen@iki.fi") + (:url . "https://github.com/tlikonen/wcheck-mode"))]) + (wconf . + [(0 2 1) + ((emacs + (24 4))) + "Minimal window layout manager" single + ((:keywords "windows" "frames" "layout") + (:authors + ("Ingo Lohmar" . "i.lohmar@gmail.com")) + (:maintainer "Ingo Lohmar" . "i.lohmar@gmail.com") + (:url . "https://github.com/ilohmar/wconf"))]) + (web-server . + [(0 1 2) + ((emacs + (24 3))) + "Emacs Web Server" tar + ((:url . "https://github.com/eschulte/emacs-web-server") + (:maintainer "Eric Schulte" . "schulte.eric@gmail.com") + (:authors + ("Eric Schulte" . "schulte.eric@gmail.com")) + (:keywords "http" "server" "network"))]) + (webfeeder . + [(1 0 0) + ((emacs + (25 1))) + "Build RSS and Atom webfeeds from HTML files" tar + ((:url . "https://gitlab.com/Ambrevar/emacs-webfeeder") + (:maintainer "Pierre Neidhardt" . "mail@ambrevar.xyz") + (:authors + ("Pierre Neidhardt" . "mail@ambrevar.xyz")) + (:keywords "news" "hypermedia" "blog" "feed" "rss" "atom"))]) + (websocket . + [(1 12) + ((cl-lib + (0 5))) + "Emacs WebSocket client and server" tar + ((:maintainer "Andrew Hyatt" . "ahyatt@gmail.com") + (:authors + ("Andrew Hyatt" . "ahyatt@gmail.com")) + (:keywords "communication" "websocket" "server") + (:url . "http://elpa.gnu.org/packages/websocket.html"))]) + (which-key . + [(3 3 0) + ((emacs + (24 4))) + "Display available keybindings in popup" tar + ((:url . "https://github.com/justbur/emacs-which-key") + (:maintainer "Justin Burkett" . "justin@burkett.cc") + (:authors + ("Justin Burkett" . "justin@burkett.cc")))]) + (windower . + [(0 0 1) + ((emacs + (25))) + "Helper functions for window manipulation." single + ((:keywords "convenience" "tools") + (:authors + ("Pierre Neidhardt" . "mail@ambrevar.xyz")) + (:maintainer "Pierre Neidhardt" . "mail@ambrevar.xyz") + (:url . "https://gitlab.com/ambrevar/windower"))]) + (windresize . + [(0 1) + nil "Resize windows interactively" single + ((:url . "http://elpa.gnu.org/packages/windresize.html") + (:keywords "window") + (:authors + ("Bastien" . "bzg@gnu.org")) + (:maintainer "Bastien" . "bzg@gnu.org"))]) + (wisi . + [(3 0 1) + ((emacs + (25 0)) + (seq + (2 20))) + "Utilities for implementing an indentation/navigation engine using a generalized LALR parser" tar + ((:url . "http://stephe-leake.org/ada/wisitoken.html") + (:maintainer "Stephen Leake" . "stephen_leake@stephe-leake.org") + (:authors + ("Stephen Leake" . "stephen_leake@stephe-leake.org")) + (:keywords "parser" "indentation" "navigation"))]) + (wisitoken-grammar-mode . + [(1 0 3) + ((wisi + (2 2 1)) + (emacs + (25 0)) + (mmm-mode + (0 5 7))) + "Major mode for editing WisiToken grammar files" tar + ((:maintainer "Stephen Leake" . "stephen_leake@stephe-leake.org") + (:authors + ("Stephen Leake" . "stephen_leake@stephe-leake.org")) + (:keywords "languages") + (:url . "http://elpa.gnu.org/packages/wisitoken-grammar-mode.html"))]) + (wpuzzle . + [(1 1) + nil "find as many word in a given time" single + ((:url . "http://elpa.gnu.org/packages/wpuzzle.html") + (:authors + ("Ivan Kanis" . "ivan@kanis.fr")) + (:maintainer "Ivan Kanis" . "ivan@kanis.fr"))]) + (xclip . + [(1 10) + nil "Copy&paste GUI clipboard from text terminal" single + ((:url . "http://elpa.gnu.org/packages/xclip.html") + (:keywords "convenience" "tools") + (:authors + ("Leo Liu" . "sdl.web@gmail.com")) + (:maintainer "Leo Liu" . "sdl.web@gmail.com"))]) + (xelb . + [(0 18) + ((emacs + (24 4)) + (cl-generic + (0 2))) + "X protocol Emacs Lisp Binding" tar + ((:url . "https://github.com/ch11ng/xelb") + (:maintainer "Chris Feng" . "chris.w.feng@gmail.com") + (:authors + ("Chris Feng" . "chris.w.feng@gmail.com")) + (:keywords "unix"))]) + (xpm . + [(1 0 4) + nil "edit XPM images" tar + ((:url . "http://www.gnuvola.org/software/xpm/") + (:maintainer "Thien-Thi Nguyen" . "ttn@gnu.org") + (:authors + ("Thien-Thi Nguyen" . "ttn@gnu.org")) + (:keywords "multimedia" "xpm"))]) + (xr . + [(1 19) + ((emacs + (26 1))) + "Convert string regexp to rx notation" tar + ((:url . "https://github.com/mattiase/xr") + (:maintainer "Mattias Engdegård" . "mattiase@acm.org") + (:authors + ("Mattias Engdegård" . "mattiase@acm.org")) + (:keywords "lisp" "regexps"))]) + (yasnippet . + [(0 14 0) + ((cl-lib + (0 5))) + "Yet another snippet extension for Emacs" tar + ((:url . "http://github.com/joaotavora/yasnippet") + (:maintainer "Noam Postavsky" . "npostavs@gmail.com") + (:keywords "convenience" "emulation"))]) + (yasnippet-classic-snippets . + [(1 0 2) + ((yasnippet + (0 9 1))) + "\"Classic\" yasnippet snippets" tar + ((:maintainer "Noam Postavsky" . "npostavs@gmail.com") + (:keywords "snippets") + (:url . "http://elpa.gnu.org/packages/yasnippet-classic-snippets.html"))]) + (zones . + [(2019 7 13) + nil "Zones of text - like multiple regions" single + ((:keywords "narrow" "restriction" "widen" "region" "zone") + (:authors + ("Drew Adams")) + (:maintainer "Drew Adams" . "drew.adams@oracle.com") + (:url . "https://elpa.gnu.org/packages/zones.html"))]) + (ztree . + [(1 0 5) + ((cl-lib + (0))) + "Text mode directory tree" tar + ((:url . "https://github.com/fourier/ztree") + (:maintainer "Alexey Veretennikov" . "alexey.veretennikov@gmail.com") + (:authors + ("Alexey Veretennikov" . "alexey.veretennikov@gmail.com")) + (:keywords "files" "tools"))])) diff --git a/emacs.d/elpa/blacken-20191123.1547/blacken-autoloads.el b/emacs.d/elpa/blacken-20191123.1547/blacken-autoloads.el new file mode 100644 index 0000000..4b291ba --- /dev/null +++ b/emacs.d/elpa/blacken-20191123.1547/blacken-autoloads.el @@ -0,0 +1,34 @@ +;;; blacken-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + + +;;;### (autoloads nil "blacken" "blacken.el" (0 0 0 0)) +;;; Generated autoloads from blacken.el + +(autoload 'blacken-buffer "blacken" "\ +Try to blacken the current buffer. + +Show black output, if black exit abnormally and DISPLAY is t. + +\(fn &optional DISPLAY)" t nil) + +(autoload 'blacken-mode "blacken" "\ +Automatically run black before saving. + +\(fn &optional ARG)" t nil) + +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "blacken" '("blacken-"))) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; blacken-autoloads.el ends here diff --git a/emacs.d/elpa/blacken-20191123.1547/blacken-pkg.el b/emacs.d/elpa/blacken-20191123.1547/blacken-pkg.el new file mode 100644 index 0000000..65ce077 --- /dev/null +++ b/emacs.d/elpa/blacken-20191123.1547/blacken-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "blacken" "20191123.1547" "Reformat python buffers using the \"black\" formatter" '((emacs "25.2")) :commit "a09f8e2564739792a1b86bc8a6ce41039db3bbf8" :authors '(("Artem Malyshev" . "proofit404@gmail.com")) :maintainer '("Artem Malyshev" . "proofit404@gmail.com") :url "https://github.com/proofit404/blacken") diff --git a/emacs.d/elpa/blacken-20191123.1547/blacken.el b/emacs.d/elpa/blacken-20191123.1547/blacken.el new file mode 100644 index 0000000..ded35e0 --- /dev/null +++ b/emacs.d/elpa/blacken-20191123.1547/blacken.el @@ -0,0 +1,176 @@ +;;; blacken.el --- Reformat python buffers using the "black" formatter + +;; Copyright (C) 2018-2019 Artem Malyshev + +;; Author: Artem Malyshev +;; Homepage: https://github.com/proofit404/blacken +;; Version: 0.0.1 +;; Package-Version: 20191123.1547 +;; Package-Requires: ((emacs "25.2")) + +;; This file 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, or (at your +;; option) any later version. +;; +;; This file 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. +;; +;; For a full copy of the GNU General Public License +;; see . + +;;; Commentary: +;; +;; Blacken uses black to format a Python buffer. It can be called +;; explicitly on a certain buffer, but more conveniently, a minor-mode +;; 'blacken-mode' is provided that turns on automatically running +;; black on a buffer before saving. +;; +;; Installation: +;; +;; Add blacken.el to your load-path. +;; +;; To automatically format all Python buffers before saving, add the +;; function blacken-mode to python-mode-hook: +;; +;; (add-hook 'python-mode-hook 'blacken-mode) +;; +;;; Code: + +(require 'cl-lib) + +(defgroup blacken nil + "Reformat Python code with \"black\"." + :group 'python) + +(defcustom blacken-executable "black" + "Name of the executable to run." + :type 'string) + +(defcustom blacken-line-length nil + "Line length to enforce. + +It must be an integer, nil or `fill'. +If `fill', the `fill-column' variable value is used." + :type '(choice :tag "Line Length Limit" + (const :tag "Use default" nil) + (const :tag "Use fill-column" fill) + (integer :tag "Line Length")) + :safe 'integerp) + +(defcustom blacken-allow-py36 nil + "Allow using Python 3.6-only syntax on all input files." + :type 'boolean + :safe 'booleanp) + +(defcustom blacken-skip-string-normalization nil + "Don't normalize string quotes or prefixes." + :type 'boolean + :safe 'booleanp) + +(defcustom blacken-fast-unsafe nil + "Skips temporary sanity checks." + :type 'boolean + :safe 'booleanp) + +(defcustom blacken-only-if-project-is-blackened nil + "Only blacken if project has a pyproject.toml with a [tool.black] section." + :type 'boolean + :safe 'booleanp) + +(defun blacken-call-bin (input-buffer output-buffer error-buffer) + "Call process black. + +Send INPUT-BUFFER content to the process stdin. Saving the +output to OUTPUT-BUFFER. Saving process stderr to ERROR-BUFFER. +Return black process the exit code." + (with-current-buffer input-buffer + (let ((process (make-process :name "blacken" + :command `(,blacken-executable ,@(blacken-call-args)) + :buffer output-buffer + :stderr error-buffer + :noquery t + :sentinel (lambda (process event))))) + (set-process-query-on-exit-flag (get-buffer-process error-buffer) nil) + (set-process-sentinel (get-buffer-process error-buffer) (lambda (process event))) + (save-restriction + (widen) + (process-send-region process (point-min) (point-max))) + (process-send-eof process) + (accept-process-output process nil nil t) + (while (process-live-p process) + (accept-process-output process nil nil t)) + (process-exit-status process)))) + +(defun blacken-call-args () + "Build black process call arguments." + (append + (when blacken-line-length + (list "--line-length" + (number-to-string (cl-case blacken-line-length + ('fill fill-column) + (t blacken-line-length))))) + (when blacken-allow-py36 + (list "--py36")) + (when blacken-fast-unsafe + (list "--fast")) + (when blacken-skip-string-normalization + (list "--skip-string-normalization")) + (when (and (buffer-file-name (current-buffer)) + (string-match "\.pyi$" (buffer-file-name (current-buffer)))) + (list "--pyi")) + '("-"))) + +(defun blacken-project-is-blackened (&optional display) + "Whether the project has a pyproject.toml with [tool.black] in it." + (when-let ((parent (locate-dominating-file default-directory "pyproject.toml"))) + (with-temp-buffer + (insert-file-contents (concat parent "pyproject.toml")) + (re-search-forward "^\\[tool.black\\]$" nil t 1)))) + +;;;###autoload +(defun blacken-buffer (&optional display) + "Try to blacken the current buffer. + +Show black output, if black exit abnormally and DISPLAY is t." + (interactive (list t)) + (let* ((original-buffer (current-buffer)) + (original-point (point)) + (original-window-pos (window-start)) + (tmpbuf (get-buffer-create "*blacken*")) + (errbuf (get-buffer-create "*blacken-error*"))) + ;; This buffer can be left after previous black invocation. It + ;; can contain error message of the previous run. + (dolist (buf (list tmpbuf errbuf)) + (with-current-buffer buf + (erase-buffer))) + (condition-case err + (if (not (zerop (blacken-call-bin original-buffer tmpbuf errbuf))) + (error "Black failed, see %s buffer for details" (buffer-name errbuf)) + (unless (eq (compare-buffer-substrings tmpbuf nil nil original-buffer nil nil) 0) + (with-current-buffer tmpbuf + (copy-to-buffer original-buffer (point-min) (point-max))) + (goto-char original-point) + (set-window-start (selected-window) original-window-pos)) + (mapc 'kill-buffer (list tmpbuf errbuf))) + (error (message "%s" (error-message-string err)) + (when display + (with-current-buffer errbuf + (setq-local scroll-conservatively 0)) + (pop-to-buffer errbuf)))))) + +;;;###autoload +(define-minor-mode blacken-mode + "Automatically run black before saving." + :lighter " Black" + (if blacken-mode + (when (or (not blacken-only-if-project-is-blackened) + (blacken-project-is-blackened)) + (add-hook 'before-save-hook 'blacken-buffer nil t)) + (remove-hook 'before-save-hook 'blacken-buffer t))) + +(provide 'blacken) + +;;; blacken.el ends here diff --git a/emacs.d/elpa/flymake-easy-20140818.755/flymake-easy-autoloads.el b/emacs.d/elpa/flymake-easy-20140818.755/flymake-easy-autoloads.el new file mode 100644 index 0000000..f737771 --- /dev/null +++ b/emacs.d/elpa/flymake-easy-20140818.755/flymake-easy-autoloads.el @@ -0,0 +1,22 @@ +;;; flymake-easy-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + + +;;;### (autoloads nil "flymake-easy" "flymake-easy.el" (0 0 0 0)) +;;; Generated autoloads from flymake-easy.el + +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "flymake-easy" '("flymake-easy-"))) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; flymake-easy-autoloads.el ends here diff --git a/emacs.d/elpa/flymake-easy-20140818.755/flymake-easy-pkg.el b/emacs.d/elpa/flymake-easy-20140818.755/flymake-easy-pkg.el new file mode 100644 index 0000000..a2f59d5 --- /dev/null +++ b/emacs.d/elpa/flymake-easy-20140818.755/flymake-easy-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "flymake-easy" "20140818.755" "Helpers for easily building flymake checkers" 'nil :commit "de41ea49503f71f997e5c359a2ad08df696c0147" :keywords '("convenience" "internal") :authors '(("Steve Purcell" . "steve@sanityinc.com")) :maintainer '("Steve Purcell" . "steve@sanityinc.com") :url "https://github.com/purcell/flymake-easy") diff --git a/emacs.d/elpa/flymake-easy-20140818.755/flymake-easy.el b/emacs.d/elpa/flymake-easy-20140818.755/flymake-easy.el new file mode 100644 index 0000000..a6b3c23 --- /dev/null +++ b/emacs.d/elpa/flymake-easy-20140818.755/flymake-easy.el @@ -0,0 +1,152 @@ +;;; flymake-easy.el --- Helpers for easily building flymake checkers + +;; Copyright (C) 2012 Steve Purcell + +;; Author: Steve Purcell +;; URL: https://github.com/purcell/flymake-easy +;; Package-Version: 20140818.755 +;; Package-Commit: de41ea49503f71f997e5c359a2ad08df696c0147 +;; Version: DEV +;; Keywords: convenience, internal + +;; 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 library provides the `flymake-easy-load' helper function for +;; setting up flymake checkers. Just call that function with the +;; appropriate arguments in a major mode hook function. See +;; `flymake-ruby' for an example: +;; https://github.com/purcell/flymake-ruby + +;;; Code: + +(require 'flymake) + +(defvar flymake-easy--active nil + "Indicates when flymake-easy-load has successfully run in this buffer.") +(defvar flymake-easy--command-fn nil + "The user-specified function for building the flymake command.") +(defvar flymake-easy--location nil + "Where to create the temp file when checking, one of 'tempdir, 'inplace or +'temp-with-folder.") +(defvar flymake-easy--extension nil + "The canonical file name extension to use for the current file.") + +(mapc 'make-variable-buffer-local + '(flymake-easy--active + flymake-easy--command-fn + flymake-easy--location + flymake-easy--extension)) + +(defun flymake-easy--tempfile-in-temp-dir (file-name prefix) + "Create a temporary file for storing the contents of FILE-NAME in the system tempdir. +Argument PREFIX temp file prefix, supplied by flymake." + (make-temp-file (or prefix "flymake-easy") + nil + (concat "." flymake-easy--extension))) + +(defun flymake-easy--flymake-init () + "A catch-all flymake init function for use in `flymake-allowed-file-name-masks'." + (let* ((tempfile + (flymake-init-create-temp-buffer-copy + (cond + ((eq 'tempdir flymake-easy--location) + 'flymake-easy--tempfile-in-temp-dir) + ((eq 'inplace flymake-easy--location) + 'flymake-create-temp-inplace) + ((eq 'temp-with-folder flymake-easy--location) + 'flymake-create-temp-with-folder-structure) + (t + (error "unknown location for flymake-easy: %s" flymake-easy--location))))) + (command (funcall flymake-easy--command-fn tempfile))) + (list (car command) (cdr command)))) + +(defun flymake-easy-exclude-buffer-p () + "Whether to skip flymake in the current buffer." + (and (fboundp 'tramp-tramp-file-p) + (buffer-file-name) + (tramp-tramp-file-p (buffer-file-name)))) + +(defun flymake-easy-load (command-fn &optional err-line-patterns location extension warning-re info-re) + "Enable flymake in the containing buffer using a specific narrow configuration. +Argument COMMAND-FN function called to build the + command line to run (receives filename, returns list). +Argument ERR-LINE-PATTERNS patterns for identifying errors (see `flymake-err-line-patterns'). +Argument EXTENSION a canonical extension for this type of source file, e.g. \"rb\". +Argument LOCATION where to create the temporary copy: one of 'tempdir (default), 'inplace or 'temp-with-folder +Argument WARNING-RE a pattern which identifies error messages as warnings. +Argument INFO-RE a pattern which identifies messages as infos (supported only +by the flymake fork at https://github.com/illusori/emacs-flymake)." + (let ((executable (car (funcall command-fn "dummy")))) + (if (executable-find executable) ;; TODO: defer this checking + (unless (flymake-easy-exclude-buffer-p) + (setq flymake-easy--command-fn command-fn + flymake-easy--location (or location 'tempdir) + flymake-easy--extension extension + flymake-easy--active t) + (set (make-local-variable 'flymake-allowed-file-name-masks) + '(("." flymake-easy--flymake-init))) + (when err-line-patterns + (set (make-local-variable 'flymake-err-line-patterns) err-line-patterns)) + (dolist (var '(flymake-warning-re flymake-warn-line-regexp)) + (set (make-local-variable var) (or warning-re "^[wW]arn"))) + (when (boundp 'flymake-info-line-regexp) + (set (make-local-variable 'flymake-info-line-regexp) + (or info-re "^[iI]nfo"))) + (flymake-mode t)) + (message "Not enabling flymake: '%s' program not found" executable)))) + +;; Internal overrides for flymake + +(defun flymake-easy--find-all-matches (str) + "Return every match for `flymake-err-line-patterns' in STR. + +This is a judicious override for `flymake-split-output', enabled +by the advice below, which allows for matching multi-line +patterns." + (let (matches + (last-match-end-pos 0)) + (dolist (pattern flymake-err-line-patterns) + (let ((regex (car pattern)) + (pos 0)) + (while (string-match regex str pos) + (push (match-string 0 str) matches) + (setq pos (match-end 0))) + (setq last-match-end-pos (max pos last-match-end-pos)))) + (let ((residual (substring str last-match-end-pos))) + (list matches + (unless (string= "" residual) residual))))) + +(defadvice flymake-split-output (around flymake-easy--split-output (output) activate protect) + "Override `flymake-split-output' to support mult-line error messages." + (setq ad-return-value (if flymake-easy--active + (flymake-easy--find-all-matches output) + ad-do-it))) + + +(defadvice flymake-post-syntax-check (before flymake-easy--force-check-was-interrupted activate) + (when flymake-easy--active + (setq flymake-check-was-interrupted t))) + + +(provide 'flymake-easy) + +;; Local Variables: +;; coding: utf-8 +;; byte-compile-warnings: (not cl-functions) +;; eval: (checkdoc-minor-mode 1) +;; End: + +;;; flymake-easy.el ends here diff --git a/emacs.d/elpa/flymake-rust-20170729.2139/flymake-rust-autoloads.el b/emacs.d/elpa/flymake-rust-20170729.2139/flymake-rust-autoloads.el new file mode 100644 index 0000000..89860d3 --- /dev/null +++ b/emacs.d/elpa/flymake-rust-20170729.2139/flymake-rust-autoloads.el @@ -0,0 +1,22 @@ +;;; flymake-rust-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + + +;;;### (autoloads nil "flymake-rust" "flymake-rust.el" (0 0 0 0)) +;;; Generated autoloads from flymake-rust.el + +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "flymake-rust" '("flymake-rust-"))) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; flymake-rust-autoloads.el ends here diff --git a/emacs.d/elpa/flymake-rust-20170729.2139/flymake-rust-pkg.el b/emacs.d/elpa/flymake-rust-20170729.2139/flymake-rust-pkg.el new file mode 100644 index 0000000..7ce9a6f --- /dev/null +++ b/emacs.d/elpa/flymake-rust-20170729.2139/flymake-rust-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "flymake-rust" "20170729.2139" "A flymake handler for rust-mode files" '((flymake-easy "0.1")) :commit "2f42d1f2dad73ec9de460eda6176e3ab25c446f0" :authors '(("Joao Oliveira" . "joaoxsouls@gmail.com")) :maintainer '("Joao Oliveira" . "joaoxsouls@gmail.com") :url "https://github.com/joaoxsouls/flymake-rust") diff --git a/emacs.d/elpa/flymake-rust-20170729.2139/flymake-rust.el b/emacs.d/elpa/flymake-rust-20170729.2139/flymake-rust.el new file mode 100644 index 0000000..b148c55 --- /dev/null +++ b/emacs.d/elpa/flymake-rust-20170729.2139/flymake-rust.el @@ -0,0 +1,70 @@ +;;; flymake-rust.el --- A flymake handler for rust-mode files +;; +;;; Author: Joao Oliveira +;;; URL: https://github.com/joaoxsouls/flymake-rust +;; Package-Version: 20170729.2139 +;; Package-Commit: 2f42d1f2dad73ec9de460eda6176e3ab25c446f0 +;;; Version: DEV +;;; Package-Requires: ((flymake-easy "0.1")) + +;; This file 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, or (at your option) +;; any later version. + +;; This file 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: +;; Usage: +;; (require 'flymake-rust) +;; (add-hook 'rust-mode-hook 'flymake-rust-load) +;; +;; If you want to use rustc compiler, you must add following string: +;; (setq flymake-rust-use-cargo 1) +;; +;; Uses flymake-easy, from https://github.com/purcell/flymake-easy + +;;; Code: + +(require 'flymake-easy) + +(defconst flymake-rust-err-line-patterns + '(("^\\(.*\\)\n --> \\(.*.rs\\):\\([0-9]+\\):\\([0-9]+\\)$" 2 3 4 1) + ("^\\(.*.rs\\):\\([0-9]+\\):[0-9]+: [0-9]+:[0-9]+ [a-z]+: \\(.*\\)$" 1 2 nil 3) + ("^\\(.*.rs\\):\\([0-9]+\\) \\(.*\\)$" 1 2 nil 3))) + +(setq-default flymake-rust-use-cargo 1) + +(if flymake-rust-use-cargo + (defvar flymake-rust-executable "cargo" + "The rust executable to use for syntax checking.") + (defvar flymake-rust-executable "rustc" + "The rust executable to use for syntax checking.") +) + +;; Invoke rust "--parse-only" to get syntax checking +(defun flymake-rust-command (filename) + "Construct a command that flymake can use to check rust source." + (if flymake-rust-use-cargo + (list flymake-rust-executable "build") + (list flymake-rust-executable "--no-trans" filename) + ) + ) + +;; Load rust-flymake +(defun flymake-rust-load () + "Configure flymake mode to check the current buffer's rust syntax." + (interactive) + (flymake-easy-load 'flymake-rust-command + flymake-rust-err-line-patterns + 'inplace + "rs")) + +(provide 'flymake-rust) +;;; flymake-rust.el ends here diff --git a/emacs.d/elpa/python-mode-20200508.1756/completion/pycomplete.el b/emacs.d/elpa/python-mode-20200508.1756/completion/pycomplete.el new file mode 100644 index 0000000..9b20372 --- /dev/null +++ b/emacs.d/elpa/python-mode-20200508.1756/completion/pycomplete.el @@ -0,0 +1,436 @@ +;;; 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) diff --git a/emacs.d/elpa/python-mode-20200508.1756/completion/pycomplete.py b/emacs.d/elpa/python-mode-20200508.1756/completion/pycomplete.py new file mode 100644 index 0000000..be381c7 --- /dev/null +++ b/emacs.d/elpa/python-mode-20200508.1756/completion/pycomplete.py @@ -0,0 +1,798 @@ +""" +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 : diff --git a/emacs.d/elpa/python-mode-20200508.1756/python-mode-autoloads.el b/emacs.d/elpa/python-mode-20200508.1756/python-mode-autoloads.el new file mode 100644 index 0000000..87329af --- /dev/null +++ b/emacs.d/elpa/python-mode-20200508.1756/python-mode-autoloads.el @@ -0,0 +1,137 @@ +;;; python-mode-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + + +;;;### (autoloads nil "python-mode" "python-mode.el" (0 0 0 0)) +;;; Generated autoloads from python-mode.el + +(autoload 'py-backward-class "python-mode" "\ +Go to beginning of ‘class’. + +If already at beginning, go one ‘class’ backward. +Return beginning of form if successful, nil otherwise + +\(fn)" t nil) + +(autoload 'py-backward-def "python-mode" "\ +Go to beginning of ‘def’. + +If already at beginning, go one ‘def’ backward. +Return beginning of form if successful, nil otherwise + +\(fn)" t nil) + +(autoload 'py-backward-def-or-class "python-mode" "\ +Go to beginning of ‘def-or-class’. + +If already at beginning, go one ‘def-or-class’ backward. +Return beginning of form if successful, nil otherwise + +\(fn)" t nil) + +(autoload 'py-backward-class-bol "python-mode" "\ +Go to beginning of ‘class’, go to BOL. +If already at beginning, go one ‘class’ backward. +Return beginning of ‘class’ if successful, nil otherwise + +\(fn)" t nil) + +(autoload 'py-backward-def-bol "python-mode" "\ +Go to beginning of ‘def’, go to BOL. +If already at beginning, go one ‘def’ backward. +Return beginning of ‘def’ if successful, nil otherwise + +\(fn)" t nil) + +(autoload 'py-backward-def-or-class-bol "python-mode" "\ +Go to beginning of ‘def-or-class’, go to BOL. +If already at beginning, go one ‘def-or-class’ backward. +Return beginning of ‘def-or-class’ if successful, nil otherwise + +\(fn)" t nil) + +(autoload 'py-forward-class "python-mode" "\ +Go to end of class. + +Return end of ‘class’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position + +\(fn &optional ORIG BOL)" t nil) + +(autoload 'py-forward-def "python-mode" "\ +Go to end of def. + +Return end of ‘def’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position + +\(fn &optional ORIG BOL)" t nil) + +(autoload 'py-forward-def-or-class "python-mode" "\ +Go to end of def-or-class. + +Return end of ‘def-or-class’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position + +\(fn &optional ORIG BOL)" t nil) + +(autoload 'py-auto-completion-mode "python-mode" "\ +Run auto-completion + +\(fn)" t nil) + +(autoload 'python-mode "python-mode" "\ +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' Start an interactive Python interpreter in another window +`py-execute-statement' Send statement at point to Python default interpreter +`py-backward-statement' Go 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} + +\(fn)" t nil) + +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "python-mode" '("pdb-track-stack-from-shell-p" "pep8" "pst-here" "pps-emacs-version" "pios" "autopair-mode" "all-mode-setting" "info-lookup-mode" "ios" "ipy" "iyp" "Python" "IPython" "Ipython" "jython" "virtualenv-" "eva" "force-py-shell-name-p-o" "flake8" "toggle-" "turn-o" "with-buffer-prepared-for-jit-lock" "highlight-indent-active" "hs-hide-comments-when-hiding-all" "strip-chars-"))) + +;;;*** + +;;;### (autoloads nil nil ("python-mode-pkg.el") (0 0 0 0)) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; python-mode-autoloads.el ends here diff --git a/emacs.d/elpa/python-mode-20200508.1756/python-mode-pkg.el b/emacs.d/elpa/python-mode-20200508.1756/python-mode-pkg.el new file mode 100644 index 0000000..a2f3140 --- /dev/null +++ b/emacs.d/elpa/python-mode-20200508.1756/python-mode-pkg.el @@ -0,0 +1,4 @@ +(define-package "python-mode" "20200508.1756" "Python major mode" 'nil) +;; Local Variables: +;; no-byte-compile: t +;; End: diff --git a/emacs.d/elpa/python-mode-20200508.1756/python-mode.el b/emacs.d/elpa/python-mode-20200508.1756/python-mode.el new file mode 100644 index 0000000..021ef26 --- /dev/null +++ b/emacs.d/elpa/python-mode-20200508.1756/python-mode.el @@ -0,0 +1,28002 @@ +;;; python-mode.el --- Edit, debug, develop, run Python programs. -*- lexical-binding: t; -*- + +;; Version: 6.2.3 + +;; Keywords: languages, processes, python, oop + +;; URL: https://gitlab.com/groups/python-mode-devs + +;; Package-Requires: ((emacs "24")) + +;; Copyright (C) 1992,1993,1994 Tim Peters + +;; Author: 2015-2020 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: + +;; Includes a minor mode for handling a Python/IPython shell, and can +;; take advantage of Pymacs when installed. + +;; See documentation in README.org, README.DEVEL.org + +;; Please report bugs at +;; https://gitlab.com/python-mode-devs/python-mode/issues + +;; available commands are documented in directory "doc" as +;; commands-python-mode.org + +;; 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: + +(ignore-errors (require 'subr-x)) +;; (require 'org) + +(defgroup python-mode nil + "Support for the Python programming language, " + :group 'languages + :prefix "py-") + +(defconst py-version "6.2.3") + +(defvar py-install-directory "") +(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-font-lock-defaults-p t + "If fontification is not required, + +avoiding it might speed up things." + + :type 'boolean + :group 'python-mode + :safe 'booleanp) + +(defcustom py-eldoc-mode-p nil + "If eldoc-mode is loaded by python-mode. + +Default is nil" + + :type 'boolean + :group 'python-mode + :safe 'booleanp) + +(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-python2-modeline-display "Py2" + "String to display in Emacs modeline." + + :type 'string + :tag "python2-mode-modeline-display" + :group 'python-mode) + +(defcustom py-python3-modeline-display "Py3" + "String to display in Emacs modeline." + + :type 'string + :tag "python3-mode-modeline-display" + :group 'python-mode) + +(defcustom py-ipython-modeline-display "IPy" + "String to display in Emacs modeline." + + :type 'string + :tag "ipython-modeline-display" + :group 'python-mode) + +(defcustom py-jython-modeline-display "Jy" + "String to display in Emacs modeline." + + :type 'string + :tag "jython-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 \\ \\[info] ... +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 + :safe 'booleanp) + +;; credits to python.el +(defcustom py-shell-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)) + "`compilation-error-regexp-alist' for py-shell." + :type '(alist string) + :group 'python-mode) + +(defcustom py-shift-require-transient-mark-mode-p t + "If py-shift commands on regions should require variable ‘transient-mark-mode’. + +Default is t" + + :type 'boolean + :group 'python-mode + :safe 'booleanp) + +(defvar py-fast-output-buffer "*Python Fast*" + "Internally used. ‘buffer-name’ for fast-processes.") + +(defvar py-this-result nil + "Internally used, store return-value.") + +(defvar py-coding-re + "\\(# *coding[ \t]*=\\|#[ \t]*\-*\-[ \t]*coding:\\|#[ \t]*encoding:\\)[ \t]*\\([[:graph:]+]\\)" + "") + +(setq py-coding-re + "\\(# *coding[ \t]*=\\|#[ \t]*\-*\-[ \t]*coding:\\|#[ \t]*encoding:\\)[ \t]*\\([[:graph:]+]\\)") + +;; and + +;; #[ \t]*-*-[ \t]*coding:[ \t]* utf-8 -*- + +;; What about + +;; #[ \t]*encoding:[ \t]* utf-8" + +(defcustom py-comment-auto-fill-p nil + "When non-nil, fill comments. + +Defaut is nil" + + :type 'boolean + :group 'python-mode + :safe 'booleanp) + +(defcustom py-sexp-use-expression-p nil + "If non-nil, ‘forward-sexp’ will call ‘py-forward-expression’. + +Respective ‘backward-sexp’ will call ‘py-backward-expression’ +Default is t" + :type 'boolean + :group 'python-mode + :safe 'booleanp) + +(defcustom py-session-p t + "If commands would use an existing process. + +Default is t" + + :type 'boolean + :tag "py-session-p" + :group 'python-mode + :safe 'booleanp) + +(defun py-toggle-session-p (&optional arg) + "Switches boolean variable ‘py-session-p’. + +With optional ARG message state switched to" + (interactive "p") + (setq py-session-p (not py-session-p)) + (when arg (message "py-session-p: %s" py-session-p))) + +(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 + :safe 'booleanp) + +(defcustom py-highlight-error-source-p nil + "Respective code in source-buffer will be highlighted. + +Default is nil. + +\\ `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'. + +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" + + :type 'boolean + :tag "py-empty-line-closes-p" + :group 'python-mode) + +(defcustom py-prompt-on-changed-p t + "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 + "Put resulting string of `py-execute-...' into ‘kill-ring’. + +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." ) + +(setq py-shell--font-lock-buffer "*PSFLB*") + +(defvar py-return-result-p nil + "Internally used. + +When non-nil, return resulting string of `py-execute-...'. +Imports will use it with nil. +Default is nil") + +(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 if no longer needed. + +Works around a bug in `choose-completion'. +Default is nil" + :type 'boolean + :group 'python-mode) + +(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 variable ‘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 \\ \\[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 to 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’." + + :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', `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) + +(defvar py-modeline-display "" + "Internally used") + +(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-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 highlight-indent-active nil) +(defvar autopair-mode nil) + +(defvar-local py--editbeg nil + "Internally used by `py-edit-docstring' and others") + +(defvar-local py--editend nil + "Internally used by `py-edit-docstring' and others") + +(defvar py--oldbuf nil + "Internally used by `py-edit-docstring'.") + +(defvar py-edit-buffer "Edit docstring" + "Name of the temporary buffer to use when editing.") + +(defvar py--edit-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-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'. + +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 variable `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 + "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-list-style 'line-up-with-first-element + "Sets the basic indentation style of lists. + +Setting here might be ignored in case of canonical indent. + +‘line-up-with-first-element’ indents to 1+ column of opening delimiter +def foo (a, + b): + +‘one-level-to-beginning-of-statement’ adds ‘py-indent-offset’ to beginning of statement +def long_function_name( + var_one, var_two, var_three, + var_four): + print(var_one) + +‘one-level-from-first-element’ adds ‘py-indent-offset’ from first element +def foo(): + if (foo && + baz): + bar()" + :type '(choice + (const :tag "line-up-with-first-element" line-up-with-first-element) + (const :tag "one-level-to-beginning-of-statement" one-level-to-beginning-of-statement) + (const :tag "one-level-from-first-element" one-level-from-first-element)) + :tag "py-indent-list-style" + :group 'python-mode) +(make-variable-buffer-local 'py-indent-list-style) + +(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 +URL: https://www.python.org/dev/peps/pep-0008/#indentation" + + :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 99 + "Heuristic exit. +e +Limiting number of recursive calls by ‘py-forward-statement’ and related. +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, variable `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 + "If ‘beginning-of-defun’, ‘end-of-defun’ calls function ‘top-level’ form. + +Default is nil. + +beginning-of defun, ‘end-of-defun’ forms use +commands `py-beginning-of-top-level', `py-end-of-top-level' + +‘mark-defun’ marks function ‘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 nil + "Guess `py-indent-offset'. Default is nil. + +Setting it to t seems useful only in cases where customizing +`py-indent-offset' is no option - for example because the +indentation step is unknown or differs inside the code. + +When this variable is non-nil, `py-indent-offset' is guessed from existing code in the buffer, which might slow down the proceeding." + + :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-shell-completion-native-output-timeout 5.0 + "Time in seconds to wait for completion output before giving up." + :version "25.1" + :type 'float) + +(defcustom py-shell-completion-native-try-output-timeout 1.0 + "Time in seconds to wait for *trying* native completion output." + :version "25.1" + :type 'float) + +(defvar py-shell--first-prompt-received-output-buffer nil) +(defvar py-shell--first-prompt-received nil) + +(defcustom py-shell-first-prompt-hook nil + "Hook run upon first (non-pdb) shell prompt detection. +This is the place for shell setup functions that need to wait for +output. Since the first prompt is ensured, this helps the +current process to not hang while waiting. This is useful to +safely attach setup code for long-running processes that +eventually provide a shell." + :version "25.1" + :type 'hook + :group 'python-mode) + +(defvar py-shell--parent-buffer nil) + +(defvar py-shell--package-depth 10) + +(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-import-check-point-max + 20000 + "Max number of characters to search Java-ish import statement. + +When `python-mode' tries to calculate the shell +-- either a CPython or a Jython shell -- +it looks at the so-called `shebang'. +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) + +;; (setq py-shells +;; (list +;; "" +;; 'ipython +;; 'ipython2.7 +;; 'ipython3 +;; 'jython +;; 'python +;; 'python2 +;; 'python3 +;; 'pypy +;; )) + +(defcustom py-known-shells + (list + "ipython" + "ipython2.7" + "ipython3" + "jython" + "python" + "python2" + "python3" + "pypy" + ) + "A list of available shells instrumented for commands. + Expects its executables installed + +Edit for your needs." + :type '(repeat string) + :tag "py-shells" + :group 'python-mode) + +(defcustom py-known-shells-extended-commands + (list "ipython" + "python" + "python3" + "pypy" + ) + "A list of shells instrumented for finer grained commands +like ‘py-execute-statement-ipython’ +Expects its executables installed + +Edit for your needs." + :type '(repeat string) + :tag "py-shells" + :group 'python-mode) + +(defun py-install-named-shells-fix-doc (ele) + (cond ((string-match "^i" ele) + (concat "I" (capitalize (substring ele 1)))) + ((string-match "^pypy" ele) + "PyPy") + (t (capitalize ele)))) + +(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. + +Highlights it while waiting PY-WHICH-FUNC-DELAY seconds. +Afterwards 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 1 + "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-python3-send-delay 1 + "Seconds to wait for output, used by `py--send-...' functions. + +See also ‘py-ipython-send-delay’" + + :type 'number + :tag "py-python3-send-delay" + :group 'python-mode) + +(defcustom py-ipython-send-delay 1 + "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 + "Execute the named master file instead of the buffer's file. + +Default is nil. +With relative path variable `default-directory' is prepended. + +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) + +(defvar py-pdbtrack-input-prompt "^[(<]*[Ii]?[Pp]y?db[>)]+ *" + "Recognize the prompt.") + +(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. + +Applies to the shell after the first line of input." + :type 'string + :tag "py-shell-input-prompt-2-regexp" + :group 'python-mode) + +(defvar py-shell-ipython-input-prompt-1-regexp "In \\[[0-9]+\\]: " + "Regular Expression matching top-level input prompt of python shell. +It should not contain a caret (^) at the beginning.") + +(defvar py-shell-ipython-input-prompt-2-regexp " \\.\\.\\.: " + "Regular Expression matching top-level input prompt of python shell. +It should not contain a caret (^) at the beginning.") + +(defcustom py-shell-input-prompt-2-regexps + '(">>> " "\\.\\.\\. " ; Python + "In \\[[0-9]+\\]: " ; IPython + " \\.\\.\\.: " ; IPython + ;; Using ipdb outside IPython may fail to cleanup and leave static + ;; IPython prompts activated, this adds some safeguard for that. + "In : " "\\.\\.\\.: ") + "List of regular expressions matching input prompts." + :type '(repeat string) + :version "24.4" + :group 'python-mode) + +(defcustom py-shell-input-prompt-regexps + '(">>> " "\\.\\.\\. " ; Python + "In \\[[0-9]+\\]: " ; IPython + " \\.\\.\\.: " ; IPython + ;; Using ipdb outside IPython may fail to cleanup and leave static + ;; IPython prompts activated, this adds some safeguard for that. + "In : " "\\.\\.\\.: ") + "List of regular expressions matching input prompts." + :type '(repeat regexp) + :version "24.4" + :group 'python-mode) + +(defvar py-ipython-output-prompt-re "^Out\\[[0-9]+\\]: " + "A regular expression to match the output prompt of IPython.") + +(defcustom py-shell-output-prompt-regexps + '("" ; Python + "Out\\[[0-9]+\\]: " ; IPython + "Out :") ; ipdb safeguard + "List of regular expressions matching output prompts." + :type '(repeat string) + :version "24.4" + :group 'python-mode) + +(defvar py-pydbtrack-input-prompt "^[(]*ipydb[>)]+ " + "Recognize the pydb-prompt.") +;; (setq py-pdbtrack-input-prompt "^[(< \t]*[Ii]?[Pp]y?db[>)]*.*") + +(defvar py-ipython-input-prompt-re "In \\[?[0-9 ]*\\]?: *\\|^[ ]\\{3\\}[.]\\{3,\\}: *" + "A regular expression to match the IPython input prompt.") + +(defvar py-shell-prompt-regexp + (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]: \"") + +(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]: \"") + +(defcustom py-shell-prompt-detect-p nil + "Non-nil enables autodetection of interpreter prompts." + :type 'boolean + :safe 'booleanp + :version "24.4") + +(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) + +(setq 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,\\}:? *" + )) + "\\|") + "\\)")) + +(defcustom py-honor-IPYTHONDIR-p nil + "When non-nil ipython-history file is constructed by $IPYTHONDIR. + +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 - th 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) +;; made buffer-local as pdb might need t in all circumstances +(make-variable-buffer-local 'py-switch-buffers-on-execute-p) + +(defcustom py-split-window-on-execute 'just-two + "When non-nil split windows. + +Default is just-two - when code is send to interpreter. +Splits 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) + +(defun py-toggle-py-split-window-on-execute () + "Toggle between customized value and nil" + (interactive) + (setq py-split-window-on-execute (not py-split-window-on-execute)) + (when (interactive-p) + (message "py-split-window-on-execute: %s" py-split-window-on-execute) + py-split-window-on-execute)) + +(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-p 'input + "Fontify current input in Python shell. Default is input. + +INPUT will leave output unfontified. + +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-p" + :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.") + +(defcustom py-python-command + (if (eq system-type 'windows-nt) + ;; "C:\\Python27\\python.exe" + "python" + ;; "C:/Python33/Lib/site-packages/IPython" + "python") + + "Make sure directory in in the PATH-variable. + +Windows: 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 '(repeat 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. + +Unless 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, +Unless 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") + ;; --simple-prompt seems to exist from IPython 5. + (if (string-match "^[0-4]" (shell-command-to-string (concat "ipython" " -V"))) + '("--pylab" "--automagic") + '("--pylab" "--automagic" "--simple-prompt"))) + "String arguments to be used when starting a IPython 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 '(repeat 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 '(repeat string) + :tag "py-jython-command +" + :group 'python-mode) + +(defcustom py-jython-command-args '("-i") + "String arguments to be used when starting a Jython shell." + :type '(repeat 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.") + +(defvar py-cleanup-p nil + "Internally used. + +Cleanup Python shell when output is used in other places.") + +(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'. + +Alternative to 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 + "Don't 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) + +(defun py-toggle-python-mode-v5-behavior () + "Switch the values of ‘python-mode-v5-behavior-p’" + (interactive) + (setq python-mode-v5-behavior-p (not python-mode-v5-behavior-p)) + (when (interactive-p) (message "python-mode-v5-behavior-p: %s" python-mode-v5-behavior-p))) + +(defun py-toggle-py-verbose-p () + "Switch the values of ‘py-verbose-p-p’ + +Default is nil. +If on, messages value of ‘py-result’ for instance." + (interactive) + (setq py-verbose-p-p (not py-verbose-p-p)) + (when (interactive-p) (message "py-verbose-p-p: %s" py-verbose-p-p))) + +(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-index + "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) + (const :tag "py--imenu-index, honor type annotations" py--imenu-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.") + +(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 + "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 + "Current directory used for output. + +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-buffer-name nil + "Internal use. + +The buffer last output was sent to.") + +(defvar py-orig-buffer-or-file nil + "Internal use.") + +(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*" + "Used if ‘python-mode-v5-behavior-p’ is t. + +Otherwise output buffer is created dynamically according to Python version and kind of process-handling") +;; (make-variable-buffer-local 'py-output-buffer) + +(defcustom py-force-default-output-buffer-p nil + "Enforce sending output to the default output ‘buffer-name’. + +Set by defvar ‘py-output-buffer’ +Bug #31 - wrong fontification caused by string-delimiters in output" + + :type 'boolean + :tag "py-force-default-output-buffer-p" + :group 'python-mode) + +(defcustom py-shell-unbuffered t + "Should shell output be unbuffered?. +When non-nil, this may prevent delayed and missing output in the +Python shell. See commentary for details." + :type 'boolean + :group 'python-mode + :safe 'booleanp) + +(defcustom py-shell-process-environment nil + "List of overridden environment variables for subprocesses to inherit. +Each element should be a string of the form ENVVARNAME=VALUE. +When this variable is non-nil, values are exported into the +process environment before starting it. Any variables already +present in the current environment are superseded by variables +set here." + :type '(repeat string) + :group 'python-mode) + +(defcustom py-shell-extra-pythonpaths nil + "List of extra pythonpaths for Python shell. +When this variable is non-nil, values added at the beginning of +the PYTHONPATH before starting processes. Any values present +here that already exists in PYTHONPATH are moved to the beginning +of the list so that they are prioritized when looking for +modules." + :type '(repeat string) + :group 'python-mode) + +(defcustom py-shell-exec-path nil + "List of paths for searching executables. +When this variable is non-nil, values added at the beginning of +the PATH before starting processes. Any values present here that +already exists in PATH are moved to the beginning of the list so +that they are prioritized when looking for executables." + :type '(repeat string) + :group 'python-mode) + +(defcustom py-shell-remote-exec-path nil + "List of paths to be ensured remotely for searching executables. +When this variable is non-nil, values are exported into remote +hosts PATH before starting processes. Values defined in +`py-shell-exec-path' will take precedence to paths defined +here. Normally you wont use this variable directly unless you +plan to ensure a particular set of paths to all Python shell +executed through tramp connections." + :version "25.1" + :type '(repeat string) + :group 'python-mode) + +(defcustom py-shell-virtualenv-root nil + "Path to virtualenv root. +This variable, when set to a string, makes the environment to be +modified such that shells are started within the specified +virtualenv." + :type '(choice (const nil) string) + :group 'python-mode) + +(defvar py-eldoc-window-configuration nil + "Keeps window-configuration when function ‘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-python-eldoc-setup-code + "def __PYDOC_get_help(obj): + try: + import inspect + try: + str_type = basestring + argspec_function = inspect.getargspec + except NameError: + str_type = str + argspec_function = inspect.getfullargspec + if isinstance(obj, str_type): + 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(*argspec_function(target)) + name = obj.__name__ + doc = '{objtype} {name}{args}'.format( + objtype=objtype, name=name, args=args + ) + else: + doc = doc.splitlines()[0] + except: + doc = '' + return doc" + "Python code to setup documentation retrieval." + :type 'string + :group 'python-mode) + +(defcustom py-python-eldoc-string-code + "__PYDOC_get_help('''%s''')" + "Python code used to get a string with the documentation of an object." + :type 'string + :group 'python-mode) + +(defcustom py-python-ffap-setup-code + " +def __FFAP_get_module_path(objstr): + try: + import inspect + import os.path + # NameError exceptions are delayed until this point. + obj = eval(objstr) + module = inspect.getmodule(obj) + filename = module.__file__ + ext = os.path.splitext(filename)[1] + if ext in ('.pyc', '.pyo'): + # Point to the source file. + filename = filename[:-1] + if os.path.exists(filename): + return filename + return '' + except: + return ''" + "Python code to get a module path." + :type 'string + :group 'python-mode) + +(defcustom py-python-ffap-string-code + "__FFAP_get_module_path('''%s''')" + "Python code used to get a string with the path of a module." + :type 'string + :group 'python-mode) + +(defvar py-shell-completion-native-redirect-buffer + " *Py completions redirect*" + "Buffer to be used to redirect output of readline commands.") + +(defvar py-shell--block-prompt nil + "Input block prompt for inferior python shell. +Do not set this variable directly, instead use +`py-shell-prompt-set-calculated-regexps'.") + +(defvar py-shell-output-filter-in-progress nil) +(defvar py-shell-output-filter-buffer nil) + +(defvar py-shell--prompt-calculated-input-regexp nil + "Calculated input prompt regexp for inferior python shell. +Do not set this variable directly. + +Iff ‘py-shell--prompt-calculated-input-regexp’ +or ‘py-shell--prompt-calculated-output-regexp’ are set +‘py-shell-prompt-set-calculated-regexps’ isn't run.") + +(defvar py-shell--prompt-calculated-output-regexp nil + "Calculated output prompt regexp for inferior python shell. + +py-shell-prompt-set-calculated-regexps +Do not set this variable directly. + +Iff ‘py-shell--prompt-calculated-input-regexp’ +or ‘py-shell--prompt-calculated-output-regexp’ are set +‘py-shell-prompt-set-calculated-regexps’ isn't run. +") + +;; make sure it exists here +(unless (boundp 'py-rx-constituents) + (eval-and-compile + (defconst py-rx-constituents + `((block-start . ,(rx symbol-start + (or "def" "class" "if" "elif" "else" "try" + "except" "finally" "for" "while" "with" + ;; Python 3.5+ PEP492 + (and "async" (+ space) + (or "def" "for" "with"))) + symbol-end)) + (dedenter . ,(rx symbol-start + (or "elif" "else" "except" "finally") + symbol-end)) + (block-ender . ,(rx symbol-start + (or + "break" "continue" "pass" "raise" "return") + symbol-end)) + (decorator . ,(rx line-start (* space) ?@ (any letter ?_) + (* (any word ?_)))) + ;; probably useless here + (defun . ,(rx symbol-start + (or "def" "class" + ;; Python 3.5+ PEP492 + (and "async" (+ space) "def")) + symbol-end)) + (def . ,(rx symbol-start + (or "def" + ;; Python 3.5+ PEP492 + (and "async" (+ space) "def")) + symbol-end)) + (class . ,(rx symbol-start + (or "class" + ;; Python 3.5+ PEP492 + (and "async" (+ space) "class")) + symbol-end)) + (def-or-class . ,(rx symbol-start + (or "def" "class" + ;; Python 3.5+ PEP492 + (and "async" (+ space) (or "def" "class"))) + symbol-end)) + (if-name-main . ,(rx line-start "if" (+ space) "__name__" + (+ space) "==" (+ space) + (any ?' ?\") "__main__" (any ?' ?\") + (* space) ?:)) + (symbol-name . ,(rx (any letter ?_) (* (any word ?_)))) + (open-paren . ,(rx (or "{" "[" "("))) + (close-paren . ,(rx (or "}" "]" ")"))) + (simple-operator . ,(rx (any ?+ ?- ?/ ?& ?^ ?~ ?| ?* ?< ?> ?= ?%))) + ;; FIXME: rx should support (not simple-operator). + (not-simple-operator . ,(rx + (not + (any ?+ ?- ?/ ?& ?^ ?~ ?| ?* ?< ?> ?= ?%)))) + ;; FIXME: Use regexp-opt. + (operator . ,(rx (or "+" "-" "/" "&" "^" "~" "|" "*" "<" ">" + "=" "%" "**" "//" "<<" ">>" "<=" "!=" + "==" ">=" "is" "not"))) + ;; FIXME: Use regexp-opt. + (assignment-operator . ,(rx (or "=" "+=" "-=" "*=" "/=" "//=" "%=" "**=" + ">>=" "<<=" "&=" "^=" "|="))) + (string-delimiter . ,(rx (and + ;; Match even number of backslashes. + (or (not (any ?\\ ?\' ?\")) point + ;; Quotes might be preceded by an escaped quote. + (and (or (not (any ?\\)) point) ?\\ + (* ?\\ ?\\) (any ?\' ?\"))) + (* ?\\ ?\\) + ;; Match single or triple quotes of any kind. + (group (or "\"\"\"" "\"" "'''" "'"))))) + (coding-cookie . ,(rx line-start ?# (* space) + (or + ;; # coding= + (: "coding" (or ?: ?=) (* space) (group-n 1 (+ (or word ?-)))) + ;; # -*- coding: -*- + (: "-*-" (* space) "coding:" (* space) + (group-n 1 (+ (or word ?-))) (* space) "-*-") + ;; # vim: set fileencoding= : + (: "vim:" (* space) "set" (+ space) + "fileencoding" (* space) ?= (* space) + (group-n 1 (+ (or word ?-))) (* space) ":"))))) + "Additional Python specific sexps for `py-rx'") + + (defmacro py-rx (&rest regexps) + "Python mode specialized rx macro. +This variant of `rx' supports common Python named REGEXPS." + (let ((rx-constituents (append py-rx-constituents rx-constituents))) + (cond ((null regexps) + (error "No regexp")) + ((cdr regexps) + (rx-to-string `(and ,@regexps) t)) + (t + (rx-to-string (car regexps) t))))))) + +(defvar py-shell-prompt-output-regexp "" + "See py-shell-prompt-output-regexps") + +(defvar py-shell-prompt-output-regexps + '("" ; Python + "Out\\[[0-9]+\\]: " ; IPython + "Out :") ; ipdb safeguard + "List of regular expressions matching output prompts.") + +(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'. +Travels 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 + "Select command according to IPython version. + +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-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-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-shell-complete-p nil + "Enable native completion. + +Set TAB accordingly. " + + :type 'boolean + :group 'python-mode) +(make-variable-buffer-local 'py-shell-complete-p) + +(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. + +See also `py-assignment-re'") + +;; (setq py-operator-re "[ \t]*\\(\\.\\|+\\|-\\|*\\|//\\|//\\|&\\|%\\||\\|\\^\\|>>\\|<<\\|<\\|<=\\|>\\|>=\\|==\\|!=\\|=\\)[ \t]*") + +(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 (interactive-p) (switch-to-buffer (current-buffer)) + (goto-char (point-max))))) +") + +;; 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]*\\_<\\(return\\|raise\\|break\\|continue\\|pass\\)\\_>[ \n\t]") + +(defconst py-finally-re + "[ \t]*\\_" + "Matches the beginning of a `except' block.") + +;; (defconst py-except-re +;; "[ \t]*\\_[:( \n\t]*" +;; "Regular expression matching keyword which composes a 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 + "elif" + "else" + "except" + "finally" + ) + "Used by ‘py-outdent-re’." + :type '(repeat string) + :tag "py-outdent-re-raw" + :group 'python-mode + ) + +(defconst py-outdent-re + (concat + "[ \t]*" + (regexp-opt py-outdent-re-raw 'symbols) + "[)\t]*") + "Regular expression matching statements to be dedented one level.") + +(defcustom py-no-outdent-re-raw + (list + "break" + "continue" + "import" + "pass" + "raise" + "return") + "Uused by ‘py-no-outdent-re’." + :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 'symbols) + "[)\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+\\_>[[:alnum:]:, \t]*[ \t]*\\)\\(=\\|+=\\|*=\\|%=\\|&=\\|^=\\|<<=\\|-=\\|/=\\|**=\\||=\\|>>=\\|//=\\)\\(.*\\)" + "If looking at the beginning of an assignment.") + +;; 'name': +(defconst py-dict-re "'\\_<\\w+\\_>':") + +(defvar py-block-re-raw (list + "async def" + "async for" + "async with" + "class" + "def" + "for" + "if" + "try" + "while" + "with" + ) + "Used by ‘py-block-re’") + +(defconst py-block-re (concat + ;; "[ \t]*" + (regexp-opt py-block-re-raw 'symbols) + "[:( \n\t]" + ) + "Matches the beginning of a compound statement.") + +(defconst py-minor-block-re-raw (list + "async for" + "async with" + "except" + "for" + "if" + "try" + "with" + ) + "Matches the beginning of an `for', `if', `try', `except' or `with' block.") + +(defconst py-minor-block-re + (concat + "[ \t]*" + (regexp-opt py-minor-block-re-raw 'symbols) + "[:( \n\t]") + + "Regular expression matching lines not to augment indent after. + +See ‘py-minor-block-re-raw’ for better readable content") + +(defconst py-try-re "[ \t]*\\_[: \n\t]" + "Matches the beginning of a `try' block.") + +(defconst py-for-re "[ \t]*\\_<\\(async for\\|for\\)\\_> +[[:alpha:]_][[:alnum:]_]* +in +[[:alpha:]_][[:alnum:]_()]* *[: \n\t]" + "Matches the beginning of a `try' block.") + +(defconst py-if-re "[ \t]*\\_ +[^\n\r\f]+ *[: \n\t]" + "Matches the beginning of an `if' block.") + +(defconst py-else-re "[ \t]*\\_[( \n\t]" + "Matches the beginning of a compound if-statement's clause exclusively.") + +;; (defconst py-elif-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]+\\([[:alnum:]_]*\\)" + "Matches the beginning of a class- or functions definition. + +Second group grabs the name") + +;; (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" + "async def" + "async class" + "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-block-or-clause-re-raw" + :group 'python-mode) + +(defvar py-block-or-clause-re + (concat + "[ \t]*" + (regexp-opt py-block-or-clause-re-raw 'symbols) + "[( \t]*.*:?") + "See ‘py-block-or-clause-re-raw’, which it reads.") + +(defcustom py-block-re-raw + (list + "async with" + "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 'symbols) + "[( \t]*.*:?") + "See ‘py-block-or-clause-re-raw’, which it reads.") + +(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 'symbols) + "[( \t]*.*:?") + "See ‘py-block-or-clause-re-raw’, which it reads.") + +(defconst py-clause-re py-extended-block-or-clause-re) + +(defcustom py-minor-clause-re-raw + (list + "elif" + "else" + "except" + "finally" + ) + "Matches the beginning of a clause." + :type '(repeat string) + :tag "py-minor-clause-re-raw" + :group 'python-mode) + +(defconst py-minor-clause-re + (concat + "[ \t]*" + (regexp-opt py-minor-clause-re-raw 'symbols) + "[( \t]*.*:?") + "See ‘py-minor-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 + (regexp-opt py-block-or-clause-re-raw 'symbols) + "Matches known keywords opening a block. + +Customizing `py-block-or-clause-re-raw' will change values here") + +(defconst py-try-clause-re + (concat + "[ \t]*\\_<\\(" + (mapconcat 'identity + (list + "else" + "except" + "finally") + "\\|") + "\\)\\_>[( \t]*.*:") + "Matches the beginning of a compound try-statement's clause.") + +(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* ((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 + (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.") + +(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) + +;; Pdb +;; #62, pdb-track in a shell buffer +(defcustom pdb-track-stack-from-shell-p t + "If t, track source from shell-buffer. + +Default is t. +Add hook 'comint-output-filter-functions 'py--pdbtrack-track-stack-file" + + :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) + +(defcustom py-pdb-executable nil + "Indicate PATH/TO/pdb. + +Default is nil +See lp:963253" + :type 'string + :tag "py-pdb-executable" + :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. + For example \"/usr/lib/python3.4\" might be an option too. + +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-shell-prompt-pdb-regexp "[(<]*[Ii]?[Pp]db[>)]+ " + "Regular expression matching pdb input prompt of Python shell. +It should not contain a caret (^) at the beginning." + :type 'string) + +(defcustom py-pdbtrack-stacktrace-info-regexp + "> \\([^\"(<]+\\)(\\([0-9]+\\))\\([?a-zA-Z0-9_<>]+\\)()" + "Regular expression matching stacktrace information. +Used to extract the current line and module being inspected." + :type 'string + :group 'python-mode + :safe 'stringp) + +(defvar py-pdbtrack-tracked-buffer nil + "Variable containing the value of the current tracked buffer. +Never set this variable directly, use +`py-pdbtrack-set-tracked-buffer' instead.") + +(defvar py-pdbtrack-buffers-to-kill nil + "List of buffers to be deleted after tracking finishes.") + +(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) + +(defconst py-pdbtrack-stack-entry-regexp + (concat ".*\\("py-shell-input-prompt-1-regexp">\\|"py-ipython-input-prompt-re">\\|>\\) *\\(.*\\)(\\([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) + +(defvar py-shell--font-lock-buffer nil) + +(defvar py--docbeg nil + "internally used by py--write-edit") + +(defvar py--docend nil + "internally used by py--write-edit") + +(defcustom py-completion-setup-code + " +def __PYTHON_EL_get_completions(text): + completions = [] + completer = None + + try: + import readline + + try: + import __builtin__ + except ImportError: + # Python 3 + import builtins as __builtin__ + builtins = dir(__builtin__) + + is_ipython = ('__IPYTHON__' in builtins or + '__IPYTHON__active' in builtins) + splits = text.split() + is_module = splits and splits[0] in ('from', 'import') + + if is_ipython and is_module: + from IPython.core.completerlib import module_completion + completions = module_completion(text.strip()) + elif is_ipython and '__IP' in builtins: + completions = __IP.complete(text) + elif is_ipython and 'get_ipython' in builtins: + completions = get_ipython().Completer.all_completions(text) + else: + # Try to reuse current completer. + completer = readline.get_completer() + if not completer: + # importing rlcompleter sets the completer, use it as a + # last resort to avoid breaking customizations. + import rlcompleter + completer = readline.get_completer() + if getattr(completer, 'PYTHON_EL_WRAPPED', False): + completer.print_mode = False + i = 0 + while True: + completion = completer(text, i) + if not completion: + break + i += 1 + completions.append(completion) + except: + pass + finally: + if getattr(completer, 'PYTHON_EL_WRAPPED', False): + completer.print_mode = True + return completions" + "Code used to setup completion in inferior Python processes." + :type 'string + :group 'python) + +(defcustom py-shell-completion-string-code + "';'.join(__PYTHON_EL_get_completions('''%s'''))" + "Python code used to get a string of completions separated by semicolons. +The string passed to the function is the current python name or +the full statement in the case of imports." + :type 'string + :group 'python) + +(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) + +;; subr-x.el might not exist yet +;; #73, Byte compilation on Emacs 25.3 fails on different trim-right signature +(unless (or (functionp 'string-trim) (functionp 'string-trim-right)(functionp 'string-trim-left)) + (defsubst string-trim-left (strg &optional regexp) + "Trim STRING of leading string matching REGEXP. + +REGEXP defaults to \"[ \\t\\n\\r]+\"." + (if (string-match (concat "\\`\\(?:" (or regexp "[ \t\n\r]+") "\\)") strg) + (replace-match "" t t strg) + strg)) + + (defsubst string-trim-right (strg &optional regexp) + "Trim STRING of trailing string matching REGEXP. + +REGEXP defaults to \"[ \\t\\n\\r]+\"." + (if (string-match (concat "\\(?:" (or regexp "[ \t\n\r]+") "\\)\\'") strg) + (replace-match "" t t strg) + strg)) + + (defsubst string-trim (strg &optional trim-left trim-right) + "Trim STRING of leading and trailing strings matching TRIM-LEFT and TRIM-RIGHT. + +TRIM-LEFT and TRIM-RIGHT default to \"[ \\t\\n\\r]+\"." + (string-trim-left (string-trim-right strg trim-right) trim-left)) + + (defsubst string-blank-p (strg) + "Check whether STRING is either empty or only whitespace." + (string-match-p "\\`[ \t\n\r]*\\'" strg)) + + (defsubst string-remove-prefix (prefix strg) + "Remove PREFIX from STRING if present." + (if (string-prefix-p prefix strg) + (substring strg (length prefix)) + strg))) + +(defun py-toggle-imenu-create-index () + "Toggle value of ‘py--imenu-create-index-p’" + (interactive) + (setq py--imenu-create-index-p (not py--imenu-create-index-p)) + (when (interactive-p) (message "py--imenu-create-index-p: %s" py--imenu-create-index-p))) + +(defun py-toggle-shell-completion () + "Switches value of buffer-local var ‘py-shell-complete-p’" + (interactive) + (setq py-shell-complete-p (not py-shell-complete-p)) + (when (interactive-p) (message "py-shell-complete-p: %s" py-shell-complete-p))) + +(defun py--python-send-setup-code-intern (name buffer) + (save-excursion + (let ((setup-file (concat (py--normalize-directory py-temp-directory) "py-" name "-setup-code.py")) + py-return-result-p py-store-result-p) + (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 (get-buffer-process buffer) setup-file nil buffer nil t) + ;; (when py-verbose-p (message "%s" (concat name " setup-code sent to " (process-name (get-buffer-process buffer))))) + ))) + +(defun py--python-send-completion-setup-code (buffer) + "For Python see py--python-send-setup-code." + (py--python-send-setup-code-intern "shell-completion" buffer)) + +(defun py--python-send-eldoc-setup-code (buffer) + "For Python see py--python-send-setup-code." + (py--python-send-setup-code-intern "eldoc" buffer)) + +(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) nil t))) + +(defun py--at-raw-string () + "If at beginning of a raw-string." + (and (looking-at "\"\"\"\\|'''") (member (char-before) (list ?u ?U ?r ?R)))) + +(defun py--docstring-p (pos) + "Check to see if there is a docstring at POS." + (save-excursion + (let ((erg + (progn + (goto-char pos) + (and (looking-at "\"\"\"\\|'''") + ;; https://github.com/swig/swig/issues/889 + ;; def foo(rho, x): + ;; r"""Calculate :math:`D^\nu \rho(x)`.""" + ;; return True + (if (py--at-raw-string) + (progn + (forward-char -1) + (point)) + (point)))))) + (when (and erg (py-backward-statement)) + (when (looking-at py-def-or-class-re) + erg))))) + +(defun py--font-lock-syntactic-face-function (state) + "STATE expected as result von (parse-partial-sexp (point-min) (point)." + (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) + "SEPARATOR-CHAR according to system ‘path-separator’. + +Select Python executable according to version desplayed in path. +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) + "Return version of Python of current environment, a number. +Optional argument SHELL selected shell." + (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 () + "Return 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 shell) + "Return an appropriate executable as a string. + +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 +Return nil, if no executable found." + (interactive) + ;; org-babel uses ‘py-toggle-shells’ with arg, just return it + (or shell + (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 (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 ((install-directory (py--normalize-directory py-install-directory))) + (cond ((and (not (string= "" install-directory))(stringp install-directory)) + (push (expand-file-name install-directory) load-path) + (push (concat (expand-file-name install-directory) "completion") load-path) + (push (concat (expand-file-name install-directory) "extensions") load-path) + (push (concat (expand-file-name install-directory) "test") load-path) + (push (concat (expand-file-name install-directory) "tools") load-path) + (push (concat (expand-file-name install-directory) "autopair") 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 +Optional argument BEG specify beginning. +Optional argument END specify end." + (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-shell-prompt-regexp 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) + "Escape doublequotes in region by 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) + "Start from position START until position END." + (goto-char start) + (while (re-search-forward "^(" end t 1) + (insert "\\") + (end-of-line))) + +(and py-company-pycomplete-p (require 'company-pycomplete)) + +(defcustom py-empty-line-p-chars "^[ \t\r]*$" + "empty-line-p-chars" + :type 'regexp + :group 'convenience) + +(defun py-empty-line-p (&optional iact) + "Return t if cursor is at an empty line, nil otherwise. +Optional argument INTERACT bla." + (interactive "p") + (save-excursion + (beginning-of-line) + (when (and iact py-verbose-p) + (message "%s" (looking-at py-empty-line-p-chars))) + (looking-at py-empty-line-p-chars))) + +(defun py-toggle-closing-list-dedents-bos (&optional arg) + "Switches boolean variable ‘py-closing-list-dedents-bos’. + +With optional ARG message state switched to" + (interactive "p") + (setq py-closing-list-dedents-bos (not py-closing-list-dedents-bos)) + (when arg (message "py-closing-list-dedents-bos: %s" py-closing-list-dedents-bos))) + +(defmacro py-test-with-temp-buffer-point-min (contents &rest body) + "Create temp buffer in `python-mode' inserting CONTENTS. +BODY is code to be executed within the temp buffer. Point is + at the beginning of buffer." + (declare (indent 1) (debug t)) + `(with-temp-buffer + (let (hs-minor-mode py--imenu-create-index-p) + (insert ,contents) + (python-mode) + (goto-char (point-min)) + (when py-debug-p + (switch-to-buffer (current-buffer)) + (font-lock-fontify-region (point-min) (point-max))) + ,@body))) + +(defmacro py-test-with-temp-buffer (contents &rest body) + "Create temp buffer in `python-mode' inserting CONTENTS. +BODY is code to be executed within the temp buffer. Point is + at the end of buffer." + (declare (indent 1) (debug t)) + `(with-temp-buffer + (let (hs-minor-mode py--imenu-create-index-p) + (insert ,contents) + (python-mode) + (when py-debug-p + (switch-to-buffer (current-buffer)) + (font-lock-fontify-region (point-min) (point-max))) + ,@body))) + +;; from jit-lock.el +(defmacro with-buffer-prepared-for-jit-lock (&rest body) + "Execute BODY in current buffer, overriding several variables. +Preserves the `buffer-modified-p' state of the current buffer." + (declare (debug t)) + `(let ((inhibit-point-motion-hooks t)) + (with-silent-modifications + ,@body))) + +;; now installed by py-load-named-shells +;; (require 'python-components-named-shells) + + + +(require 'ansi-color) +(ignore-errors (require 'subr-x)) +(require 'cc-cmds) +(require 'cl) +(require 'comint) +(require 'compile) +(require 'custom) +(require 'ert) +(require 'flymake) +(require 'hippie-exp) +(require 'shell) +(require 'thingatpt) +(require 'which-func) +(require 'tramp) +(require 'tramp-sh) + +(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."]) + ("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 def or class" py-backward-def-or-class + :help " `py-backward-def-or-class' +Go to beginning of def-or-class."] + + ["Backward class" py-backward-class + :help " `py-backward-class' +Go to beginning of class."] + + ["Backward def" py-backward-def + :help " `py-backward-def' +Go to beginning of def."] + + ["Backward block" py-backward-block + :help " `py-backward-block' +Go to beginning of ‘block’."] + + ["Backward statement" py-backward-statement + :help " `py-backward-statement' +Go to the initial line of a simple statement."] + + ["Backward indent" py-backward-indent + :help " `py-backward-indent' +Go to the beginning of a section of equal indent."] + + ["Backward top level" py-backward-top-level + :help " `py-backward-top-level' +Go up to beginning of statments until level of indentation is null."] + + ("Other" + ["Backward section" py-backward-section + :help " `py-backward-section' +Go to next section start upward in buffer."] + + ["Backward expression" py-backward-expression + :help " `py-backward-expression'"] + + ["Backward partial expression" py-backward-partial-expression + :help " `py-backward-partial-expression'"] + + ["Backward assignment" py-backward-assignment + :help " `py-backward-assignment'"] + + ["Backward block or clause" py-backward-block-or-clause + :help " `py-backward-block-or-clause' +Go to beginning of ‘block-or-clause’."] + + ["Backward clause" py-backward-clause + :help " `py-backward-clause' +Go to beginning of ‘clause’."] + + ["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 if block" py-backward-if-block + :help " `py-backward-if-block' +Go to beginning of ‘if-block’."] + + ["Backward minor block" py-backward-minor-block + :help " `py-backward-minor-block' +Go to beginning of ‘minor-block’."] + + ["Backward try block" py-backward-try-block + :help " `py-backward-try-block' +Go to beginning of ‘try-block’."])) + ("Forward" + ["Forward def or class" py-forward-def-or-class + :help " `py-forward-def-or-class' +Go to end of def-or-class."] + + ["Forward class" py-forward-class + :help " `py-forward-class' +Go to end of class."] + + ["Forward def" py-forward-def + :help " `py-forward-def' +Go to end of def."] + + ["Forward block" py-forward-block + :help " `py-forward-block' +Go to end of block."] + + ["Forward statement" py-forward-statement + :help " `py-forward-statement' +Go to the last char of current statement."] + + ["Forward indent" py-forward-indent + :help " `py-forward-indent' +Go to the end of a section of equal indentation."] + + ["Forward top level" py-forward-top-level + :help " `py-forward-top-level' +Go to end of top-level form at point."] + + ("Other" + ["Forward section" py-forward-section + :help " `py-forward-section' +Go to next section end downward in buffer."] + + ["Forward expression" py-forward-expression + :help " `py-forward-expression'"] + + ["Forward partial expression" py-forward-partial-expression + :help " `py-forward-partial-expression'"] + + ["Forward assignment" py-forward-assignment + :help " `py-forward-assignment'"] + + ["Forward block or clause" py-forward-block-or-clause + :help " `py-forward-block-or-clause' +Go to end of block-or-clause."] + + ["Forward clause" py-forward-clause + :help " `py-forward-clause' +Go to end of clause."] + + ["Forward for block" py-forward-for-block + :help " `py-forward-for-block' +Go to end of for-block."] + + ["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 if block" py-forward-if-block + :help " `py-forward-if-block' +Go to end of if-block."] + + ["Forward minor block" py-forward-minor-block + :help " `py-forward-minor-block' +Go to end of minor-block."] + ["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" + ["Execute block ipython2" py-execute-block-ipython2 + :help " `py-execute-block-ipython2'"] + + ["Execute block or clause ipython2" py-execute-block-or-clause-ipython2 + :help " `py-execute-block-or-clause-ipython2'"] + + ["Execute buffer ipython2" py-execute-buffer-ipython2 + :help " `py-execute-buffer-ipython2'"] + + ["Execute class ipython2" py-execute-class-ipython2 + :help " `py-execute-class-ipython2'"] + + ["Execute clause ipython2" py-execute-clause-ipython2 + :help " `py-execute-clause-ipython2'"] + + ["Execute def ipython2" py-execute-def-ipython2 + :help " `py-execute-def-ipython2'"] + + ["Execute def or class ipython2" py-execute-def-or-class-ipython2 + :help " `py-execute-def-or-class-ipython2'"] + + ["Execute expression ipython2" py-execute-expression-ipython2 + :help " `py-execute-expression-ipython2'"] + + ["Execute indent ipython2" py-execute-indent-ipython2 + :help " `py-execute-indent-ipython2'"] + + ["Execute line ipython2" py-execute-line-ipython2 + :help " `py-execute-line-ipython2'"] + + ["Execute minor block ipython2" py-execute-minor-block-ipython2 + :help " `py-execute-minor-block-ipython2'"] + + ["Execute paragraph ipython2" py-execute-paragraph-ipython2 + :help " `py-execute-paragraph-ipython2'"] + + ["Execute partial expression ipython2" py-execute-partial-expression-ipython2 + :help " `py-execute-partial-expression-ipython2'"] + + ["Execute region ipython2" py-execute-region-ipython2 + :help " `py-execute-region-ipython2'"] + + ["Execute statement ipython2" py-execute-statement-ipython2 + :help " `py-execute-statement-ipython2'"] + + ["Execute top level ipython2" py-execute-top-level-ipython2 + :help " `py-execute-top-level-ipython2'"]) + ("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 top level" py-hide-top-level + :help " `py-hide-top-level' +Hide top-level 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 statement" py-hide-statement + :help " `py-hide-statement' +Hide statement 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 block or clause" py-hide-block-or-clause + :help " `py-hide-block-or-clause' +Hide block-or-clause at point."] + + ["Hide comment" py-hide-comment + :help " `py-hide-comment' +Hide comment at point."] + + ["Hide indent" py-hide-indent + :help " `py-hide-indent' +Hide indent at point."] + + ["Hide expression" py-hide-expression + :help " `py-hide-expression' +Hide expression at point."] + + ["Hide line" py-hide-line + :help " `py-hide-line' +Hide line 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 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 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."]) + ("Show" + ["Show all" py-show-all + :help " `py-show-all' +Show all in buffer."] + + ["Show" py-show + :help " `py-show' +Show hidden code 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" + ("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 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] + + ["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] + ;; ["No session mode " + ;; (setq py-no-session-p + ;; (not py-no-session-p)) + ;; :help "If shell should be in session-mode. + + ;; Default is nil. Use `M-x customize-variable' to set it permanently" + ;; :style toggle :selected py-no-session-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-docstring-style + :help " `py-docstring-style'"] + + ["Py fill comment" py-fill-comment + :help " `py-fill-comment'"] + + ["Py fill paragraph" py-fill-paragraph + :help " `py-fill-paragraph'"] + + ["Py fill string" py-fill-string + :help " `py-fill-string'"] + + ["Py fill string django" py-fill-string-django + :help " `py-fill-string-django'"] + + ["Py fill string onetwo" py-fill-string-onetwo + :help " `py-fill-string-onetwo'"] + + ["Py fill string pep 257" py-fill-string-pep-257 + :help " `py-fill-string-pep-257'"] + + ["Py fill string pep 257 nn" py-fill-string-pep-257-nn + :help " `py-fill-string-pep-257-nn'"] + + ["Py fill string symmetric" py-fill-string-symmetric + :help " `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-indent-or-complete + :help " `py-indent-or-complete'"] + + ["Py shell complete" py-shell-complete + :help " `py-shell-complete'"] + + ["Py complete" py-complete + :help " `py-complete'"]) + + ["Find function" py-find-function + :help " `py-find-function' +Find source of definition of SYMBOL."]))) + map) + +;; python-components-extra + +;; Stuff merged/adapted from python.el +(defun py-info-encoding () + "Return encoding for file. +Try `py-info-encoding-from-cookie', if none is found then +default to utf-8." + (or (py-info-encoding-from-cookie) + 'utf-8)) + +(defun py-util-comint-last-prompt () + "Return comint last prompt overlay start and end. +This is for compatibility with Emacs < 24.4." + (cond ((bound-and-true-p comint-last-prompt-overlay) + (cons (overlay-start comint-last-prompt-overlay) + (overlay-end comint-last-prompt-overlay))) + ((bound-and-true-p comint-last-prompt) + comint-last-prompt) + (t nil))) + +(defun py-shell-accept-process-output (process &optional timeout regexp) + "Accept PROCESS output with TIMEOUT until REGEXP is found. +Optional argument TIMEOUT is the timeout argument to +`accept-process-output' calls. Optional argument REGEXP +overrides the regexp to match the end of output, defaults to +`comint-prompt-regexp'. Returns non-nil when output was +properly captured. + +This utility is useful in situations where the output may be +received in chunks, since `accept-process-output' gives no +guarantees they will be grabbed in a single call. An example use +case for this would be the CPython shell start-up, where the +banner and the initial prompt are received separately." + (let ((regexp (or regexp comint-prompt-regexp))) + (catch 'found + (while t + (when (not (accept-process-output process timeout)) + (throw 'found nil)) + (when (looking-back + regexp (car (py-util-comint-last-prompt))) + (throw 'found t)))))) + +(defmacro py-shell--add-to-path-with-priority (pathvar paths) + "Modify PATHVAR and ensure PATHS are added only once at beginning." + `(dolist (path (reverse ,paths)) + (cl-delete path ,pathvar :test #'string=) + (cl-pushnew path ,pathvar :test #'string=))) + +(defun py-shell-calculate-pythonpath () + "Calculate the PYTHONPATH using `py-shell-extra-pythonpaths'." + (let ((pythonpath + (split-string + (or (getenv "PYTHONPATH") "") path-separator 'omit))) + (py-shell--add-to-path-with-priority + pythonpath py-shell-extra-pythonpaths) + (mapconcat 'identity pythonpath path-separator))) + +(defun py-shell-calculate-process-environment () + "Calculate `process-environment' or `tramp-remote-process-environment'. +Prepends `py-shell-process-environment', sets extra +pythonpaths from `py-shell-extra-pythonpaths' and sets a few +virtualenv related vars. If `default-directory' points to a +remote host, the returned value is intended for +`tramp-remote-process-environment'." + (let* ((remote-p (file-remote-p default-directory)) + (process-environment (if remote-p + tramp-remote-process-environment + process-environment)) + (virtualenv (when py-shell-virtualenv-root + (directory-file-name py-shell-virtualenv-root)))) + (dolist (env py-shell-process-environment) + (pcase-let ((`(,key ,value) (split-string env "="))) + (setenv key value))) + (when py-shell-unbuffered + (setenv "PYTHONUNBUFFERED" "1")) + (when py-shell-extra-pythonpaths + (setenv "PYTHONPATH" (py-shell-calculate-pythonpath))) + (if (not virtualenv) + process-environment + (setenv "PYTHONHOME" nil) + (setenv "VIRTUAL_ENV" virtualenv)) + process-environment)) + +(defun py-shell-calculate-exec-path () + "Calculate `exec-path'. +Prepends `py-shell-exec-path' and adds the binary directory +for virtualenv if `py-shell-virtualenv-root' is set - this +will use the python interpreter from inside the virtualenv when +starting the shell. If `default-directory' points to a remote host, +the returned value appends `py-shell-remote-exec-path' instead +of `exec-path'." + (let ((new-path (copy-sequence + (if (file-remote-p default-directory) + py-shell-remote-exec-path + exec-path))) + + ;; Windows and POSIX systems use different venv directory structures + (virtualenv-bin-dir (if (eq system-type 'windows-nt) "Scripts" "bin"))) + (py-shell--add-to-path-with-priority + new-path py-shell-exec-path) + (if (not py-shell-virtualenv-root) + new-path + (py-shell--add-to-path-with-priority + new-path + (list (expand-file-name virtualenv-bin-dir py-shell-virtualenv-root))) + new-path))) + +(defun py-shell-tramp-refresh-remote-path (vec paths) + "Update VEC's remote-path giving PATHS priority." + (let ((remote-path (tramp-get-connection-property vec "remote-path" nil))) + (when remote-path + (py-shell--add-to-path-with-priority remote-path paths) + (tramp-set-connection-property vec "remote-path" remote-path) + (tramp-set-remote-path vec)))) + +(defun py-shell-tramp-refresh-process-environment (vec env) + "Update VEC's process environment with ENV." + ;; Stolen from `tramp-open-connection-setup-interactive-shell'. + (let ((env (append (when (fboundp 'tramp-get-remote-locale) + ;; Emacs<24.4 compat. + (list (tramp-get-remote-locale vec))) + (copy-sequence env))) + (tramp-end-of-heredoc + (if (boundp 'tramp-end-of-heredoc) + tramp-end-of-heredoc + (md5 tramp-end-of-output))) + unset vars item) + (while env + (setq item (split-string (car env) "=" 'omit)) + (setcdr item (mapconcat 'identity (cdr item) "=")) + (if (and (stringp (cdr item)) (not (string-equal (cdr item) ""))) + (push (format "%s %s" (car item) (cdr item)) vars) + (push (car item) unset)) + (setq env (cdr env))) + (when vars + (tramp-send-command + vec + (format "while read var val; do export $var=$val; done <<'%s'\n%s\n%s" + tramp-end-of-heredoc + (mapconcat 'identity vars "\n") + tramp-end-of-heredoc) + t)) + (when unset + (tramp-send-command + vec (format "unset %s" (mapconcat 'identity unset " ")) t)))) + +(defmacro py-shell-with-environment (&rest body) + "Modify shell environment during execution of BODY. +Temporarily sets `process-environment' and `exec-path' during +execution of body. If `default-directory' points to a remote +machine then modifies `tramp-remote-process-environment' and +`py-shell-remote-exec-path' instead." + (declare (indent 0) (debug (body))) + (let ((vec (make-symbol "vec"))) + `(progn + (let* ((,vec + (when (file-remote-p default-directory) + (ignore-errors + (tramp-dissect-file-name default-directory 'noexpand)))) + (process-environment + (if ,vec + process-environment + (py-shell-calculate-process-environment))) + (exec-path + (if ,vec + exec-path + (py-shell-calculate-exec-path))) + (tramp-remote-process-environment + (if ,vec + (py-shell-calculate-process-environment) + tramp-remote-process-environment))) + (when (tramp-get-connection-process ,vec) + ;; For already existing connections, the new exec path must + ;; be re-set, otherwise it won't take effect. One example + ;; of such case is when remote dir-locals are read and + ;; *then* subprocesses are triggered within the same + ;; connection. + (py-shell-tramp-refresh-remote-path + ,vec (py-shell-calculate-exec-path)) + ;; The `tramp-remote-process-environment' variable is only + ;; effective when the started process is an interactive + ;; shell, otherwise (like in the case of processes started + ;; with `process-file') the environment is not changed. + ;; This makes environment modifications effective + ;; unconditionally. + (py-shell-tramp-refresh-process-environment + ,vec tramp-remote-process-environment)) + ,(macroexp-progn body))))) + +(defun py-shell-prompt-detect () + "Detect prompts for the current interpreter. +When prompts can be retrieved successfully from the +interpreter run with +`py-python-command-args', returns a list of +three elements, where the first two are input prompts and the +last one is an output prompt. When no prompts can be detected +shows a warning with instructions to avoid hangs and returns nil. +When `py-shell-prompt-detect-p' is nil avoids any +detection and just returns nil." + (when py-shell-prompt-detect-p + (py-shell-with-environment + (let* ((code (concat + "import sys\n" + "ps = [getattr(sys, 'ps%s' % i, '') for i in range(1,4)]\n" + ;; JSON is built manually for compatibility + "ps_json = '\\n[\"%s\", \"%s\", \"%s\"]\\n' % tuple(ps)\n" + "print (ps_json)\n" + "sys.exit(0)\n")) + ;; (interpreter py-shell-name) + ;; (interpreter-arg py-python-command-args) + (output + (with-temp-buffer + ;; TODO: improve error handling by using + ;; `condition-case' and displaying the error message to + ;; the user in the no-prompts warning. + (ignore-errors + (let ((code-file + ;; Python 2.x on Windows does not handle + ;; carriage returns in unbuffered mode. + (let ((inhibit-eol-conversion (getenv "PYTHONUNBUFFERED"))) + (py-shell--save-temp-file code)))) + (unwind-protect + ;; Use `process-file' as it is remote-host friendly. + (process-file + py-shell-name + code-file + '(t nil) + nil + py-python-command-args) + ;; Try to cleanup + (delete-file code-file)))) + (buffer-string))) + (prompts + (catch 'prompts + (dolist (line (split-string output "\n" t)) + (let ((res + ;; Check if current line is a valid JSON array + (and (string= (substring line 0 2) "[\"") + (ignore-errors + ;; Return prompts as a list, not vector + (append (json-read-from-string line) nil))))) + ;; The list must contain 3 strings, where the first + ;; is the input prompt, the second is the block + ;; prompt and the last one is the output prompt. The + ;; input prompt is the only one that can't be empty. + (when (and (= (length res) 3) + (cl-every #'stringp res) + (not (string= (car res) ""))) + (throw 'prompts res)))) + nil))) + (if (not prompts) + (lwarn + '(python py-shell-prompt-regexp) + :warning + (concat + "Python shell prompts cannot be detected.\n" + "If your emacs session hangs when starting python shells\n" + "recover with `keyboard-quit' and then try fixing the\n" + "interactive flag for your interpreter by adjusting the\n" + "`py-python-command-args' or add regexps\n" + "matching shell prompts in the directory-local friendly vars:\n" + " + `py-shell-prompt-regexp'\n" + " + `py-shell-input-prompt-2-regexp'\n" + " + `py-shell-prompt-output-regexp'\n" + "Or alternatively in:\n" + " + `py-shell-input-prompt-regexps'\n" + " + `py-shell-prompt-output-regexps'")) + prompts))))) + +(defun python-util-valid-regexp-p (regexp) + "Return non-nil if REGEXP is valid." + (ignore-errors (string-match regexp "") t)) + +(defun py-shell-prompt-validate-regexps () + "Validate all user provided regexps for prompts. +Signals `user-error' if any of these vars contain invalid +regexps: `py-shell-prompt-regexp', +`py-shell-input-prompt-2-regexp', +`py-shell-prompt-pdb-regexp', +`py-shell-prompt-output-regexp', +`py-shell-input-prompt-regexps', +`py-shell-prompt-output-regexps'." + (dolist (symbol (list 'py-shell-input-prompt-1-regexp + 'py-shell-prompt-output-regexps + 'py-shell-input-prompt-2-regexp + 'py-shell-prompt-pdb-regexp)) + (dolist (regexp (let ((regexps (symbol-value symbol))) + (if (listp regexps) + regexps + (list regexps)))) + (when (not (python-util-valid-regexp-p regexp)) + (user-error "Invalid regexp %s in `%s'" + regexp symbol))))) + +(defun py-shell-prompt-set-calculated-regexps () + "Detect and set input and output prompt regexps. + +Build and set the values for input- and output-prompt regexp +using the values from `py-shell-prompt-regexp', +`py-shell-input-prompt-2-regexp', `py-shell-prompt-pdb-regexp', +`py-shell-prompt-output-regexp', `py-shell-input-prompt-regexps', + and detected prompts from `py-shell-prompt-detect'." + (when (not (and py-shell--prompt-calculated-input-regexp + py-shell--prompt-calculated-output-regexp)) + (let* ((detected-prompts (py-shell-prompt-detect)) + (input-prompts nil) + (output-prompts nil) + (build-regexp + (lambda (prompts) + (concat "^\\(" + (mapconcat #'identity + (sort prompts + (lambda (a b) + (let ((length-a (length a)) + (length-b (length b))) + (if (= length-a length-b) + (string< a b) + (> (length a) (length b)))))) + "\\|") + "\\)")))) + ;; Validate ALL regexps + (py-shell-prompt-validate-regexps) + ;; Collect all user defined input prompts + (dolist (prompt (append py-shell-input-prompt-regexps + (list py-shell-input-prompt-2-regexp + py-shell-prompt-pdb-regexp))) + (cl-pushnew prompt input-prompts :test #'string=)) + ;; Collect all user defined output prompts + (dolist (prompt (cons py-shell-prompt-output-regexp + py-shell-prompt-output-regexps)) + (cl-pushnew prompt output-prompts :test #'string=)) + ;; Collect detected prompts if any + (when detected-prompts + (dolist (prompt (butlast detected-prompts)) + (setq prompt (regexp-quote prompt)) + (cl-pushnew prompt input-prompts :test #'string=)) + (setq py-shell--block-prompt (nth 1 detected-prompts)) + (cl-pushnew (regexp-quote + (car (last detected-prompts))) + output-prompts :test #'string=)) + ;; Set input and output prompt regexps from collected prompts + (setq py-shell--prompt-calculated-input-regexp + (funcall build-regexp input-prompts) + py-shell--prompt-calculated-output-regexp + (funcall build-regexp output-prompts))))) + +(defun py-shell-comint-end-of-output-p (output) + "Return non-nil if OUTPUT ends with input prompt." + (ignore-errors (string-match + ;; XXX: It seems on macOS an extra carriage return is attached + ;; at the end of output, this handles that too. + (concat + "\r?\n?" + ;; Remove initial caret from calculated regexp + (ignore-errors (replace-regexp-in-string + (rx string-start ?^) "" + py-shell--prompt-calculated-input-regexp)) + (rx eos)) + output))) + +(defun py-shell-completion-get-completions (process import input) + "Do completion at point using PROCESS for IMPORT or INPUT. +When IMPORT is non-nil takes precedence over INPUT for +completion." + (setq input (or import input)) + (with-current-buffer (process-buffer process) + (let ((completions + (ignore-errors + (string-trim + (py-send-string-no-output + (format + (concat py-completion-setup-code + "\nprint (" py-shell-completion-string-code ")") + input) process (buffer-name (current-buffer))))))) + (when (> (length completions) 2) + (split-string completions + "^'\\|^\"\\|;\\|'$\\|\"$" t))))) + +(defun py-shell-completion-at-point (&optional process) + "Function for `completion-at-point-functions' in `py-shell-mode'. +Optional argument PROCESS forces completions to be retrieved +using that one instead of current buffer's process." + ;; (setq process (or process (get-buffer-process (current-buffer)))) + (let* + ((process (or process (get-buffer-process (current-buffer)))) + (line-start (if (derived-mode-p 'py-shell-mode) + ;; Working on a shell buffer: use prompt end. + (or (cdr (py-util-comint-last-prompt)) + (line-beginning-position)) + (line-beginning-position))) + (import-statement + (when (string-match-p + (rx (* space) word-start (or "from" "import") word-end space) + (buffer-substring-no-properties line-start (point))) + (buffer-substring-no-properties line-start (point)))) + (start + (save-excursion + (if (not (re-search-backward + (py-rx + (or whitespace open-paren close-paren string-delimiter simple-operator)) + line-start + t 1)) + line-start + (forward-char (length (match-string-no-properties 0))) + (point)))) + (end (point)) + (completion-fn + (with-current-buffer (process-buffer process) + #'py-shell-completion-get-completions))) + (list start end + (completion-table-dynamic + (apply-partially + completion-fn + process import-statement))))) + +(defun py-comint-watch-for-first-prompt-output-filter (output) + "Run `py-shell-first-prompt-hook' when first prompt is found in OUTPUT." + (when (not py-shell--first-prompt-received) + (set (make-local-variable 'py-shell--first-prompt-received-output-buffer) + (concat py-shell--first-prompt-received-output-buffer + (ansi-color-filter-apply output))) + (when (py-shell-comint-end-of-output-p + py-shell--first-prompt-received-output-buffer) + (if (string-match-p + (concat py-shell-prompt-pdb-regexp (rx eos)) + (or py-shell--first-prompt-received-output-buffer "")) + ;; Skip pdb prompts and reset the buffer. + (setq py-shell--first-prompt-received-output-buffer nil) + (set (make-local-variable 'py-shell--first-prompt-received) t) + (setq py-shell--first-prompt-received-output-buffer nil) + (with-current-buffer (current-buffer) + (let ((inhibit-quit nil)) + (run-hooks 'py-shell-first-prompt-hook)))))) + output) + +(defun python-shell-package-enable (directory package) + "Add DIRECTORY parent to $PYTHONPATH and enable PACKAGE." + (interactive + (let* ((dir (expand-file-name + (read-directory-name + "Package root: " + (file-name-directory + (or (buffer-file-name) default-directory))))) + (name (completing-read + "Package: " + (python-util-list-packages + dir py-shell--package-depth)))) + (list dir name))) + (py-shell-send-string + (format + (concat + "import os.path;import sys;" + "sys.path.append(os.path.dirname(os.path.dirname('''%s''')));" + "__package__ = '''%s''';" + "import %s") + directory package package) + (or (get-buffer-process (current-buffer)) (get-buffer-process (py-shell))))) + +(defun py-comint-postoutput-scroll-to-bottom (output) + "Faster version of `comint-postoutput-scroll-to-bottom'. +Avoids `recenter' calls until OUTPUT is completely sent." + (when (and (not (string= "" output)) + (py-shell-comint-end-of-output-p + (ansi-color-filter-apply output))) + (comint-postoutput-scroll-to-bottom output)) + output) + +(defun py-shell-font-lock-get-or-create-buffer () + "Get or create a font-lock buffer for current inferior process." + (with-current-buffer (current-buffer) + (if py-shell--font-lock-buffer + py-shell--font-lock-buffer + (let ((process-name + (process-name (get-buffer-process (current-buffer))))) + (generate-new-buffer + (format " *%s-font-lock*" process-name)))))) + +(defun py-font-lock-kill-buffer () + "Kill the font-lock buffer safely." + (when (and py-shell--font-lock-buffer + (buffer-live-p py-shell--font-lock-buffer)) + (kill-buffer py-shell--font-lock-buffer) + (when (derived-mode-p 'py-shell-mode) + (setq py-shell--font-lock-buffer nil)))) + +(defmacro py-shell-font-lock-with-font-lock-buffer (&rest body) + "Execute the forms in BODY in the font-lock buffer. +The value returned is the value of the last form in BODY. See +also `with-current-buffer'." + (declare (indent 0) (debug t)) + `(save-current-buffer + (when (not (and py-shell--font-lock-buffer + (get-buffer py-shell--font-lock-buffer))) + (setq py-shell--font-lock-buffer + (py-shell-font-lock-get-or-create-buffer))) + (set-buffer py-shell--font-lock-buffer) + (when (not font-lock-mode) + (font-lock-mode 1)) + (set (make-local-variable 'delay-mode-hooks) t) + (let (py-smart-indentation) + (when (not (derived-mode-p 'python-mode)) + (python-mode)) + ,@body))) + +(defun py-shell-font-lock-cleanup-buffer () + "Cleanup the font-lock buffer. +Provided as a command because this might be handy if something +goes wrong and syntax highlighting in the shell gets messed up." + (interactive) + (with-current-buffer (current-buffer) + (py-shell-font-lock-with-font-lock-buffer + (erase-buffer)))) + +(defun py-shell-font-lock-comint-output-filter-function (output) + "Clean up the font-lock buffer after any OUTPUT." + (if (and (not (string= "" output)) + ;; Is end of output and is not just a prompt. + (not (member + (py-shell-comint-end-of-output-p + (ansi-color-filter-apply output)) + '(nil 0)))) + ;; If output is other than an input prompt then "real" output has + ;; been received and the font-lock buffer must be cleaned up. + (py-shell-font-lock-cleanup-buffer) + ;; Otherwise just add a newline. + (py-shell-font-lock-with-font-lock-buffer + (goto-char (point-max)) + (newline 1))) + output) + +(defun py-font-lock-post-command-hook () + "Fontifies current line in shell buffer." + (let ((prompt-end + (or (cdr (py-util-comint-last-prompt)) + (progn (sit-for 0.1) + (cdr (py-util-comint-last-prompt)))))) + (when (and prompt-end (> (point) prompt-end) + (process-live-p (get-buffer-process (current-buffer)))) + (let* ((input (buffer-substring-no-properties + prompt-end (point-max))) + (deactivate-mark nil) + (start-pos prompt-end) + (buffer-undo-list t) + (font-lock-buffer-pos nil) + (replacement + (py-shell-font-lock-with-font-lock-buffer + (delete-region (line-beginning-position) + (point-max)) + (setq font-lock-buffer-pos (point)) + (insert input) + ;; Ensure buffer is fontified, keeping it + ;; compatible with Emacs < 24.4. + (when py-shell-fontify-p + (if (fboundp 'font-lock-ensure) + (funcall 'font-lock-ensure) + (font-lock-default-fontify-buffer))) + (buffer-substring font-lock-buffer-pos + (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-pos i) (+ start-pos next-change) plist) + (setq i next-change))))))) + +(defun py-shell-font-lock-turn-on (&optional msg) + "Turn on shell font-lock. +With argument MSG show activation message." + (interactive "p") + (save-current-buffer + (py-font-lock-kill-buffer) + (set (make-local-variable 'py-shell--font-lock-buffer) nil) + (add-hook 'post-command-hook + #'py-font-lock-post-command-hook nil 'local) + (add-hook 'kill-buffer-hook + #'py-font-lock-kill-buffer nil 'local) + (add-hook 'comint-output-filter-functions + #'py-shell-font-lock-comint-output-filter-function + 'append 'local) + (when msg + (message "Shell font-lock is enabled")))) + +(defun py-shell-font-lock-turn-off (&optional msg) + "Turn off shell font-lock. +With argument MSG show deactivation message." + (interactive "p") + (with-current-buffer (current-buffer) + (py-font-lock-kill-buffer) + (when (py-util-comint-last-prompt) + ;; Cleanup current fontification + (remove-text-properties + (cdr (py-util-comint-last-prompt)) + (line-end-position) + '(face nil font-lock-face nil))) + (set (make-local-variable 'py-shell--font-lock-buffer) nil) + (remove-hook 'post-command-hook + #'py-font-lock-post-command-hook 'local) + (remove-hook 'kill-buffer-hook + #'py-font-lock-kill-buffer 'local) + (remove-hook 'comint-output-filter-functions + #'py-shell-font-lock-comint-output-filter-function + 'local) + (when msg + (message "Shell font-lock is disabled")))) + +(defun py-shell-font-lock-toggle (&optional msg) + "Toggle font-lock for shell. +With argument MSG show activation/deactivation message." + (interactive "p") + (with-current-buffer (current-buffer) + (set (make-local-variable 'py-shell-fontify-p) + (not py-shell-fontify-p)) + (if py-shell-fontify-p + (py-shell-font-lock-turn-on msg) + (py-shell-font-lock-turn-off msg)) + py-shell-fontify-p)) + +(defun py-info-encoding-from-cookie () + "Detect current buffer's encoding from its coding cookie. +Returns the encoding as a symbol." + (let ((first-two-lines + (save-excursion + (save-restriction + (widen) + (goto-char (point-min)) + (forward-line 2) + (buffer-substring-no-properties + (point) + (point-min)))))) + (when (string-match (py-rx coding-cookie) first-two-lines) + (intern (match-string-no-properties 1 first-two-lines))))) + +(unless (functionp 'file-local-name) + (defun file-local-name (file) + "Return the local name component of FILE. +This function removes from FILE the specification of the remote host +and the method of accessing the host, leaving only the part that +identifies FILE locally on the remote system. +The returned file name can be used directly as argument of +`process-file', `start-file-process', or `shell-command'." + (or (file-remote-p file 'localname) file))) + +;; 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-def-or-class) + ;; 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)) + +(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-def-or-class) + ;; 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" + ;; OSError subclasses + "BlockIOError" "ChildProcessError" "ConnectionError" + "BrokenPipError" "ConnectionAbortedError" + "ConnectionRefusedError" "ConnectionResetError" + "FileExistsError" "FileNotFoundError" "InterruptedError" + "IsADirectoryError" "NotADirectoryError" "PermissionError" + "ProcessLookupError" "TimeoutError") + 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)) + ;; https://emacs.stackexchange.com/questions/55184/ + ;; how-to-highlight-in-different-colors-for-variables-inside-fstring-on-python-mo + ;; + ;; this is the full string. + ;; group 1 is the quote type and a closing quote is matched + ;; group 2 is the string part + ("f\\(['\"]\\{1,3\\}\\)\\([^\\1]+?\\)\\1" + ;; these are the {keywords} + ("{[^}]*?}" + ;; Pre-match form + (progn (goto-char (match-beginning 0)) (match-end 0)) + ;; Post-match form + (goto-char (match-end 0)) + ;; face for this match + (0 font-lock-variable-name-face t))) + ;; 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 + +;; Smart indentation +(defalias 'toggle-py-smart-indentation 'py-toggle-smart-indentation) +(defun py-toggle-smart-indentation (&optional arg) + "Toggle `py-smart-indentation' - on with positiv ARG. + +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) + "Toggle`py-smart-indentation' - on with positive ARG. + +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) + "Toggle `py-smart-indentation' according to ARG. + +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))) + +;; py-switch-buffers-on-execute-p forms +(defun toggle-py-switch-buffers-on-execute-p (&optional arg) + "Toggle `py-switch-buffers-on-execute-p' according to ARG. + + 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) + "Toggle `py-switch-buffers-on-execute-p' according to ARG. + +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) + "Toggle `py-split-window-on-execute' according to ARG. + + 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) + "Toggle `py-split-window-on-execute' according to ARG. + +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) + "Toggle `py-fontify-shell-buffer-p' according to ARG. + + 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) + "Toggle `py-fontify-shell-buffer-p' according to ARG. + +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) + "Toggle `python-mode-v5-behavior-p' according to ARG. + + 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) + "To `python-mode-v5-behavior-p' according to ARG. + +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) + "Toggle `py-jump-on-exception' according to ARG. + + 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) + "Toggle py-jump-on-exception' according to ARG. + +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) + "Toggle `py-use-current-dir-when-execute-p' according to ARG. + + 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) + "Toggle py-use-current-dir-when-execute-p' according to ARG. + +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) + "Toggle `py-electric-comment-p' according to ARG. + + 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) + "Toggle py-electric-comment-p' according to ARG. + +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) + "Toggle `py-underscore-word-syntax-p' according to ARG. + + 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) + "Toggle py-underscore-word-syntax-p' according to ARG. + +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. + +I.e. not of `symbol'. + +Underscores in word-class like `forward-word' 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--beginning-of-expression-p (&optional pps) + "Return 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 (concat "\\b" py-expression-re)) + (point)))) + +(defun py--top-level-form-p () + "Return non-nil, if line start 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] ARG 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. + +Requires BEG, END as the boundery of region" + (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-current-line (need) + "Indent current line to NEED." + (beginning-of-line) + (delete-horizontal-space) + (indent-to need)) + +(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)) + (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-or-region-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. + +Requires current indent as CUI +Requires current indent-offset as INDENT-OFFSET" + (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 ARG. + +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, \\[quoted-insert] 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. + +\\[quoted-insert] 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 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-or-region-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. + +Either `py-newline-delete-trailing-whitespace-p' +or ` +py-trailing-whitespace-smart-delete-p' must be t. + +Start from position ORIG" + (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 (py-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 1) + (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 1) + (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. + +If IACT is provided, message result" + (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' according to ARG." + (interactive "p") + (py-indent-tabs-mode (abs arg)(called-interactively-p 'any))) + +(defun py-indent-tabs-mode-off (arg) + "Switch `indent-tabs-mode' according to ARG." + (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. + +Expects INDENTS, a cons" + (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. +Unless DIRECTION is symbol 'forward, go backward first" + (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 () + "Go to beginning of current paragraph. + +If already at beginning, go to start of next paragraph upwards" + (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 () + "Go to end of current paragraph. + +If already at end, go to end of next paragraph downwards" + (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 +BEG END deliver the boundaries of region to work within" + (goto-char beg) + (py-indent-and-forward) + ;; (forward-line 1) + (while (< (line-end-position) end) + (if (py-empty-line-p) + (forward-line 1) + (py-indent-and-forward))) + (unless (py-empty-line-p) (py-indent-and-forward))) + +(defun py-indent-region (beg end) + "Reindent a region delimited by BEG END. + +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 () + "Provided for abstract reasons." + (point-min)) + +(defun py--end-of-buffer-position () + "Provided for abstract reasons." + (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 () + "Forms 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))) + ;; backward-statement shouldn't stop in string + ;; (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 delimited by BEG END." + (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-set-vars () + (save-excursion + (let ((py--editbeg (when (use-region-p) (region-beginning))) + (py--editend (when (use-region-p) (region-end))) + (pps (parse-partial-sexp (point-min) (point)))) + (when (nth 3 pps) + (setq py--editbeg (or py--editbeg (progn (goto-char (nth 8 pps)) + (skip-chars-forward (char-to-string (char-after)))(push-mark) (point)))) + (setq py--editend (or py--editend + (progn (goto-char (nth 8 pps)) + (forward-sexp) + (skip-chars-backward (char-to-string (char-before))) + (point))))) + (cons (copy-marker py--editbeg) (copy-marker py--editend))))) + +(defun py--write-edit () + "When edit is finished, write docstring back to orginal buffer." + (interactive) + (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-register) + ;; (py-restore-window-configuration) + (delete-region py--docbeg py--docend) + (insert-buffer-substring py-edit-buffer)) + +(defun py-edit--intern (buffer-name mode &optional beg end prefix suffix action) + "Edit string or active region in ‘python-mode’. + +arg BUFFER-NAME: a string. +arg MODE: which buffer-mode used in edit-buffer" + (interactive "*") + (save-excursion + (save-restriction + (window-configuration-to-register py--edit-register) + (setq py--oldbuf (current-buffer)) + (let* ((orig (point)) + (bounds (or (and beg end)(py--edit-set-vars))) + relpos editstrg + erg) + (setq py--docbeg (or beg (car bounds))) + (setq py--docend (or end (cdr bounds))) + ;; store relative position in editstrg + (setq relpos (1+ (- orig py--docbeg))) + (setq editstrg (buffer-substring py--docbeg py--docend)) + (set-buffer (get-buffer-create buffer-name)) + (erase-buffer) + (switch-to-buffer (current-buffer)) + (when prefix (insert prefix)) + (insert editstrg) + (when suffix (insert suffix)) + (funcall mode) + (when action + (setq erg (funcall action)) + (erase-buffer) + (insert erg)) + (local-set-key [(control c) (control c)] 'py--write-edit) + (goto-char relpos) + (message "%s" "Type C-c C-c writes contents back"))))) + +(defun py-edit-docstring () + "Edit docstring or active region in ‘python-mode’." + (interactive "*") + (py-edit--intern "Edit docstring" 'python-mode)) + +(defun py-unpretty-assignment () + "Revoke prettyprint, write assignment in a shortest way." + (interactive "*") + (save-excursion + (let* ((beg (py-beginning-of-assignment)) + (end (copy-marker (py-forward-assignment))) + last) + (goto-char beg) + (while (and (not (eobp))(re-search-forward "^\\([ \t]*\\)\[\]\"'{}]" end t 1) (setq last (copy-marker (point)))) + (save-excursion (goto-char (match-end 1)) + (when (eq (current-column) (current-indentation)) (delete-region (point) (progn (skip-chars-backward " \t\r\n\f") (point))))) + (when last (goto-char last)))))) + +(defun py--prettyprint-assignment-intern (beg end name buffer) + (let ((proc (get-buffer-process buffer)) + erg) + ;; (py-send-string "import pprint" proc nil t) + (py-fast-send-string "import json" proc buffer) + ;; send the dict/assigment + (py-fast-send-string (buffer-substring-no-properties beg end) proc buffer) + ;; do pretty-print + ;; print(json.dumps(neudict4, indent=4)) + (setq erg (py-fast-send-string (concat "print(json.dumps("name", indent=5))") proc buffer t)) + ;; (message "%s" erg) + ;; (py-edit--intern "PPrint" 'python-mode beg end) + ;; (message "%s" (current-buffer)) + ;; (switch-to-buffer (current-buffer)) + (goto-char beg) + (skip-chars-forward "^{") + (delete-region (point) (progn (forward-sexp) (point))) + (insert erg))) + +(defun py-prettyprint-assignment () + "Prettyprint assignment in ‘python-mode’." + (interactive "*") + (window-configuration-to-register py-windows-config-register) + (save-excursion + (let* ((beg (py-beginning-of-assignment)) + (name (py-expression)) + (end (py-end-of-assignment)) + (proc-buf (python nil nil "Fast Intern Utility Re-Use"))) + (py--prettyprint-assignment-intern beg end name proc-buf))) + (py-restore-window-configuration)) + +;; 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 () + "Go to beginning of ‘block’. + +If already at beginning, go one ‘block’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-block-re)))) + (when py-mark-decorators (and (py-backward-decorator) + (setq erg (point)))) + erg)) + +;;;###autoload +(defun py-backward-class () + "Go to beginning of ‘class’. + +If already at beginning, go one ‘class’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-class-re)))) + (when py-mark-decorators (and (py-backward-decorator) + (setq erg (point)))) + erg)) + +;;;###autoload +(defun py-backward-def () + "Go to beginning of ‘def’. + +If already at beginning, go one ‘def’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-def-re)))) + (when py-mark-decorators (and (py-backward-decorator) + (setq erg (point)))) + erg)) + +;;;###autoload +(defun py-backward-def-or-class () + "Go to beginning of ‘def-or-class’. + +If already at beginning, go one ‘def-or-class’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-def-or-class-re)))) + (when py-mark-decorators (and (py-backward-decorator) + (setq erg (point)))) + erg)) + +(defun py-backward-block-bol () + "Go to beginning of ‘block’, go to BOL. +If already at beginning, go one ‘block’ backward. +Return beginning of ‘block’ if successful, nil otherwise" + (interactive) + (and (py-backward-block) + (progn (beginning-of-line)(point)))) + +;;;###autoload +(defun py-backward-class-bol () + "Go to beginning of ‘class’, go to BOL. +If already at beginning, go one ‘class’ backward. +Return beginning of ‘class’ if successful, nil otherwise" + (interactive) + (and (py-backward-class) + (progn (beginning-of-line)(point)))) + +;;;###autoload +(defun py-backward-def-bol () + "Go to beginning of ‘def’, go to BOL. +If already at beginning, go one ‘def’ backward. +Return beginning of ‘def’ if successful, nil otherwise" + (interactive) + (and (py-backward-def) + (progn (beginning-of-line)(point)))) + +;;;###autoload +(defun 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. +Return beginning of ‘def-or-class’ if successful, nil otherwise" + (interactive) + (and (py-backward-def-or-class) + (progn (beginning-of-line)(point)))) + +(defun py-backward-block-or-clause () + "Go to beginning of ‘block-or-clause’. + +If already at beginning, go one ‘block-or-clause’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-block-or-clause-re)))) + erg)) + +(defun py-backward-clause () + "Go to beginning of ‘clause’. + +If already at beginning, go one ‘clause’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-clause-re)))) + erg)) + +(defun py-backward-elif-block () + "Go to beginning of ‘elif-block’. + +If already at beginning, go one ‘elif-block’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-elif-re)))) + erg)) + +(defun py-backward-else-block () + "Go to beginning of ‘else-block’. + +If already at beginning, go one ‘else-block’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-else-re)))) + erg)) + +(defun py-backward-except-block () + "Go to beginning of ‘except-block’. + +If already at beginning, go one ‘except-block’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-except-re)))) + erg)) + +(defun py-backward-for-block () + "Go to beginning of ‘for-block’. + +If already at beginning, go one ‘for-block’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-for-re)))) + erg)) + +(defun py-backward-if-block () + "Go to beginning of ‘if-block’. + +If already at beginning, go one ‘if-block’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-if-re)))) + erg)) + +(defun py-backward-minor-block () + "Go to beginning of ‘minor-block’. + +If already at beginning, go one ‘minor-block’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-minor-block-re)))) + erg)) + +(defun py-backward-try-block () + "Go to beginning of ‘try-block’. + +If already at beginning, go one ‘try-block’ backward. +Return beginning of form if successful, nil otherwise" + (interactive) + (let (erg) + (setq erg (car-safe (cdr-safe (py--go-to-keyword 'py-try-re)))) + erg)) + +(defun 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. +Return beginning of ‘block-or-clause’ if successful, nil otherwise" + (interactive) + (and (py-backward-block-or-clause) + (progn (beginning-of-line)(point)))) + +(defun py-backward-clause-bol () + "Go to beginning of ‘clause’, go to BOL. +If already at beginning, go one ‘clause’ backward. +Return beginning of ‘clause’ if successful, nil otherwise" + (interactive) + (and (py-backward-clause) + (progn (beginning-of-line)(point)))) + +(defun py-backward-elif-block-bol () + "Go to beginning of ‘elif-block’, go to BOL. +If already at beginning, go one ‘elif-block’ backward. +Return beginning of ‘elif-block’ if successful, nil otherwise" + (interactive) + (and (py-backward-elif-block) + (progn (beginning-of-line)(point)))) + +(defun py-backward-else-block-bol () + "Go to beginning of ‘else-block’, go to BOL. +If already at beginning, go one ‘else-block’ backward. +Return beginning of ‘else-block’ if successful, nil otherwise" + (interactive) + (and (py-backward-else-block) + (progn (beginning-of-line)(point)))) + +(defun py-backward-except-block-bol () + "Go to beginning of ‘except-block’, go to BOL. +If already at beginning, go one ‘except-block’ backward. +Return beginning of ‘except-block’ if successful, nil otherwise" + (interactive) + (and (py-backward-except-block) + (progn (beginning-of-line)(point)))) + +(defun py-backward-for-block-bol () + "Go to beginning of ‘for-block’, go to BOL. +If already at beginning, go one ‘for-block’ backward. +Return beginning of ‘for-block’ if successful, nil otherwise" + (interactive) + (and (py-backward-for-block) + (progn (beginning-of-line)(point)))) + +(defun py-backward-if-block-bol () + "Go to beginning of ‘if-block’, go to BOL. +If already at beginning, go one ‘if-block’ backward. +Return beginning of ‘if-block’ if successful, nil otherwise" + (interactive) + (and (py-backward-if-block) + (progn (beginning-of-line)(point)))) + +(defun py-backward-minor-block-bol () + "Go to beginning of ‘minor-block’, go to BOL. +If already at beginning, go one ‘minor-block’ backward. +Return beginning of ‘minor-block’ if successful, nil otherwise" + (interactive) + (and (py-backward-minor-block) + (progn (beginning-of-line)(point)))) + +(defun py-backward-try-block-bol () + "Go to beginning of ‘try-block’, go to BOL. +If already at beginning, go one ‘try-block’ backward. +Return beginning of ‘try-block’ if successful, nil otherwise" + (interactive) + (and (py-backward-try-block) + (progn (beginning-of-line)(point)))) + +;; 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 orig bol) + "Go to end of block. + +Return end of ‘block’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-block-re orig bol))) + +(defun py-forward-block-bol () + "Goto beginning of line following end of ‘block’. + +Return position reached, if successful, nil otherwise. +See also ‘py-down-block’: down from current definition to next beginning of ‘block’ below." + (interactive) + (py-forward-block nil t)) + +(defun py-forward-block-or-clause (&optional orig bol) + "Go to end of block-or-clause. + +Return end of ‘block-or-clause’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-block-or-clause-re orig bol))) + +(defun py-forward-block-or-clause-bol () + "Goto beginning of line following end of ‘block-or-clause’. + +Return 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) + (py-forward-block-or-clause nil t)) + +;;;###autoload +(defun py-forward-class (&optional orig bol) + "Go to end of class. + +Return end of ‘class’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-class-re orig bol))) + +(defun py-forward-class-bol () + "Goto beginning of line following end of ‘class’. + +Return position reached, if successful, nil otherwise. +See also ‘py-down-class’: down from current definition to next beginning of ‘class’ below." + (interactive) + (py-forward-class nil t)) + +(defun py-forward-clause (&optional orig bol) + "Go to end of clause. + +Return end of ‘clause’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-clause-re orig bol))) + +(defun py-forward-clause-bol () + "Goto beginning of line following end of ‘clause’. + +Return position reached, if successful, nil otherwise. +See also ‘py-down-clause’: down from current definition to next beginning of ‘clause’ below." + (interactive) + (py-forward-clause nil t)) + +;;;###autoload +(defun py-forward-def (&optional orig bol) + "Go to end of def. + +Return end of ‘def’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-def-re orig bol))) + +(defun py-forward-def-bol () + "Goto beginning of line following end of ‘def’. + +Return position reached, if successful, nil otherwise. +See also ‘py-down-def’: down from current definition to next beginning of ‘def’ below." + (interactive) + (py-forward-def nil t)) + +;;;###autoload +(defun py-forward-def-or-class (&optional orig bol) + "Go to end of def-or-class. + +Return end of ‘def-or-class’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-def-or-class-re orig bol))) + +(defun py-forward-def-or-class-bol () + "Goto beginning of line following end of ‘def-or-class’. + +Return 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) + (py-forward-def-or-class nil t)) + +(defun py-forward-elif-block (&optional orig bol) + "Go to end of elif-block. + +Return end of ‘elif-block’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-elif-re orig bol))) + +(defun py-forward-elif-block-bol () + "Goto beginning of line following end of ‘elif-block’. + +Return position reached, if successful, nil otherwise. +See also ‘py-down-elif-block’: down from current definition to next beginning of ‘elif-block’ below." + (interactive) + (py-forward-elif-block nil t)) + +(defun py-forward-else-block (&optional orig bol) + "Go to end of else-block. + +Return end of ‘else-block’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-else-re orig bol))) + +(defun py-forward-else-block-bol () + "Goto beginning of line following end of ‘else-block’. + +Return position reached, if successful, nil otherwise. +See also ‘py-down-else-block’: down from current definition to next beginning of ‘else-block’ below." + (interactive) + (py-forward-else-block nil t)) + +(defun py-forward-except-block (&optional orig bol) + "Go to end of except-block. + +Return end of ‘except-block’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-except-re orig bol))) + +(defun py-forward-except-block-bol () + "Goto beginning of line following end of ‘except-block’. + +Return position reached, if successful, nil otherwise. +See also ‘py-down-except-block’: down from current definition to next beginning of ‘except-block’ below." + (interactive) + (py-forward-except-block nil t)) + +(defun py-forward-for-block (&optional orig bol) + "Go to end of for-block. + +Return end of ‘for-block’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-for-re orig bol))) + +(defun py-forward-for-block-bol () + "Goto beginning of line following end of ‘for-block’. + +Return position reached, if successful, nil otherwise. +See also ‘py-down-for-block’: down from current definition to next beginning of ‘for-block’ below." + (interactive) + (py-forward-for-block nil t)) + +(defun py-forward-if-block (&optional orig bol) + "Go to end of if-block. + +Return end of ‘if-block’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-if-re orig bol))) + +(defun py-forward-if-block-bol () + "Goto beginning of line following end of ‘if-block’. + +Return position reached, if successful, nil otherwise. +See also ‘py-down-if-block’: down from current definition to next beginning of ‘if-block’ below." + (interactive) + (py-forward-if-block nil t)) + +(defun py-forward-minor-block (&optional orig bol) + "Go to end of minor-block. + +Return end of ‘minor-block’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-minor-block-re orig bol))) + +(defun py-forward-minor-block-bol () + "Goto beginning of line following end of ‘minor-block’. + +Return position reached, if successful, nil otherwise. +See also ‘py-down-minor-block’: down from current definition to next beginning of ‘minor-block’ below." + (interactive) + (py-forward-minor-block nil t)) + +(defun py-forward-try-block (&optional orig bol) + "Go to end of try-block. + +Return end of ‘try-block’ if successful, nil otherwise +Optional ORIG: start position +Optional BOL: go to beginning of line following end-position" + (interactive) + (cdr-safe (py--end-base 'py-try-re orig bol))) + +(defun py-forward-try-block-bol () + "Goto beginning of line following end of ‘try-block’. + +Return position reached, if successful, nil otherwise. +See also ‘py-down-try-block’: down from current definition to next beginning of ‘try-block’ below." + (interactive) + (py-forward-try-block nil t)) + +;; python-components-forward-forms.el ends here +;; python-components-move + +;; Indentation +;; Travel current level of indentation +(defun py--travel-this-indent-backward (&optional indent) + "Travel current INDENT backward. + +With optional INDENT travel bigger or equal indentation" + (let ((indent (or indent (current-indentation))) + last) + (while (and (not (bobp)) + (py-backward-statement) + (<= indent (current-indentation)) + (setq last (point)))) + (when last (goto-char last)) + last)) + +(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 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) + "Internal use. + +Travel this INDENT backward until bol" + (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) + "Internal use. + +Travel this INDENT forward" + (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) + (let (done + (last (point)) + (orig (point)) + (indent (current-indentation))) + (while (and (not (eobp)) (not done) (progn (forward-line 1) (back-to-indentation) (or (py-empty-line-p) (and (<= indent (current-indentation))(< last (point))(setq last (point)))(setq done t)))) + (and (< indent (current-indentation))(setq done t))) + (if (and last (< orig last)) + (progn (goto-char last) + (end-of-line) + (skip-chars-backward " \t\r\n\f")) + (skip-chars-forward " \t\r\n\f") + (end-of-line) + (skip-chars-backward " \t\r\n\f")) + (and (< orig (point))(point)))) + +(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 + +ORIG - consider orignial position or point. +DONE - transaktional argument +REPEAT - count and consider repeats" + (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. +ORIG - consider orignial position or point. +DONE - transaktional argument +REPEAT - count and consider repeats" + (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)) + ;; looking at opening delimiter + ((eq 4 (car-safe (syntax-after (point)))) + (goto-char (scan-sexps (point) 1)) + (skip-chars-forward py-expression-skip-chars) + (setq done t)) + ((nth 1 pps) + (goto-char (nth 1 pps)) + (goto-char (scan-sexps (point) 1)) + (skip-chars-forward py-expression-skip-chars) + (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 () + "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 () + "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 maxindent) + "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 +ORIG - consider orignial position or point. +DONE - transaktional argument +LIMIT - honor limit +IGNORE-IN-STRING-P - also much inside a string +REPEAT - count and consider repeats +Optional MAXINDENT: don't stop if indentation is larger" + (interactive) + (save-restriction + (unless (bobp) + (let* ((repeat (or (and repeat (1+ repeat)) 0)) + (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 maxindent)) + ;; 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 maxindent)) + ((nth 4 pps) + (while (ignore-errors (goto-char (nth 8 pps))) + (skip-chars-backward " \t\r\n\f") + (setq pps (parse-partial-sexp (line-beginning-position) (point)))) + (py-backward-statement orig done limit ignore-in-string-p repeat maxindent)) + ((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 maxindent)) + ((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 maxindent)) + ;; at raw-string + ;; (and (looking-at "\"\"\"\\|'''") (member (char-before) (list ?u ?U ?r ?R))) + ((and (looking-at "\"\"\"\\|'''") (member (char-before) (list ?u ?U ?r ?R))) + (forward-char -1) + (py-backward-statement orig done limit ignore-in-string-p repeat maxindent)) + ;; 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 maxindent))) + ;; 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 maxindent)) + ;; 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 maxindent)) + ;; after end of statement + ((and (not done) (eq (char-before) ?\;)) + (skip-chars-backward ";") + (py-backward-statement orig done limit ignore-in-string-p repeat maxindent)) + ;; travel until indentation or semicolon + ((and (not done) (py--skip-to-semicolon-backward)) + (unless (and maxindent (< maxindent (current-indentation))) + (setq done t)) + (py-backward-statement orig done limit ignore-in-string-p repeat maxindent)) + ;; 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 maxindent)) + ((and maxindent (< maxindent (current-indentation))) + (forward-line -1) + (py-backward-statement orig done limit ignore-in-string-p repeat maxindent))) + ;; 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 start. +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. + +ORIG - consider orignial position or point. +DONE - transaktional argument +REPEAT - count and consider repeats" + (interactive) + (switch-to-buffer (current-buffer)) + (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 + ((and comment-start (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" orig)) + ;; point at orig due to a trailing whitespace + (and (eq (point) orig) (skip-chars-forward " \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)) + (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) + (let ((orig (point))) + (unless (bobp) (forward-line -1) + (back-to-indentation) + (while (and (progn (looking-at "@\\w+")(not (looking-at "\\w+"))) + (not + ;; (py-empty-line-p) + (member (char-after) (list 9 10))) + (not (bobp))(forward-line -1)) + (back-to-indentation)) + (or (and (looking-at "@\\w+") (match-beginning 0)) + (goto-char orig))))) + +(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. + +Start from POS if specified" + (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-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 ((last (point))) + (while (and (not (bobp)) + (py-backward-statement) + (eq (current-indentation) indent) + (if (looking-at py-decorator-re) + (progn (setq last (point)) nil) + t))) + (goto-char last))) + +(defun py--go-to-keyword (regexp &optional maxindent condition ignoreindent) + "Expects being called from beginning of a statement. + +Argument REGEXP: a symbol. + +Return a list, whose car is indentation, cdr position. + +Keyword detected from REGEXP +Honor MAXINDENT if provided +Optional IGNOREINDENT: find next keyword at any indentation" + (unless (bobp) + ;; (when (py-empty-line-p) (skip-chars-backward " \t\r\n\f")) + (let* ((orig (point)) + (condition + (or condition '<)) + ;; py-clause-re would not match block + (regexp (if (eq regexp 'py-clause-re) 'py-extended-block-or-clause-re regexp)) + (regexpvalue (symbol-value regexp)) + (maxindent + (if ignoreindent + ;; just a big value + 9999 + (or maxindent + (if + (or (looking-at regexpvalue) (eq 0 (current-indentation))) + (current-indentation) + (abs + (- (current-indentation) py-indent-offset)))))) + erg) + (unless (py-beginning-of-statement-p) + (py-backward-statement)) + (cond + ((looking-at (concat (symbol-value regexp))) + (if (eq (point) orig) + (setq erg (py--backward-regexp regexp maxindent condition orig regexpvalue)) + (setq erg (point)))) + (t (setq erg (py--backward-regexp regexp maxindent condition orig regexpvalue)))) + (when erg (setq erg (cons (current-indentation) erg))) + (list (car erg) (cdr erg) (py--end-base-determine-secondvalue regexp))))) + +(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. + +IACT - if called interactively +LAST - was last match. +Optional PPSTART indicates a start-position for `parse-partial-sexp'. +ORIG - consider orignial position or point. +DONE - transaktional argument +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. +IACT - if called interactively +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) + "Move down until clause is closed, i.e. current indentation is reached. + +Takes a list, INDENT and ORIG 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 start 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)))) + +;; (defun py-forward-paragraph () +;; (interactive) +;; (py--end-of-paragraph 'py-paragraph-re)) + +(defun py-backward-assignment() + "Go to backward in buffer to beginning of an assigment. + +Return position if successful." + (interactive) + (let* (last + (erg + (progn + (while (and (setq last (py-backward-statement)) + (not (looking-at py-assignment-re)))) + (and (looking-at py-assignment-re) last)))) + (when (and py-verbose-p (interactive-p)) + (message "%s" erg)) + erg)) + +(defun py-beginning-of-assignment() + "Go to beginning of assigment if inside. + +Return position of successful, nil of not started from inside." + (interactive) + (let* (last + (erg + (or (py--beginning-of-assignment-p) + (progn + (while (and (setq last (py-backward-statement)) + (not (looking-at py-assignment-re)) + ;; (not (bolp)) + )) + (and (looking-at py-assignment-re) last))))) + (when (and py-verbose-p (interactive-p)) + (message "%s" erg)) + erg)) + +(defun py--forward-assignment-intern () + (and (looking-at py-assignment-re) + (goto-char (match-end 2)) + (skip-chars-forward " \t\r\n\f") + ;; (eq (car (syntax-after (point))) 4) + (progn (forward-sexp) (point)))) + +(defun py-end-of-assignment() + "Go to end of assigment at point if inside. + +Return position of successful, nil of not started from inside" + (interactive) + (unless (eobp) + (if (eq last-command 'py-backward-assignment) + ;; assume at start of an assignment + (py--forward-assignment-intern) + ;; ‘py-backward-assignment’ here, avoid ‘py--beginning-of-assignment-p’ a second time + (let* (last + (beg + (or (py--beginning-of-assignment-p) + (progn + (while (and (setq last (py-backward-statement)) + (not (looking-at py-assignment-re)) + ;; (not (bolp)) + )) + (and (looking-at py-assignment-re) last)))) + erg) + (and beg (setq erg (py--forward-assignment-intern))) + (when (and py-verbose-p (interactive-p)) (message "%s" erg)) + erg)))) + +(defun py-forward-assignment() + "Go to end of assigment at point if inside. + +Return position of successful, nil of not started from inside +When called at the end of an assignment, check next form downwards." + (interactive) + (unless (eobp) + (if (eq last-command 'py-backward-assignment) + ;; assume at start of an assignment + (py--forward-assignment-intern) + ;; ‘py-backward-assignment’ here, avoid ‘py--beginning-of-assignment-p’ a second time + (let* (last + (orig (point)) + (beg + (or (py--beginning-of-assignment-p) + (progn + (while (and (setq last (py-backward-statement)) + (not (looking-at py-assignment-re)) + ;; (not (bolp)) + )) + (and (looking-at py-assignment-re) last)))) + erg) + (and beg (setq erg (py--forward-assignment-intern))) + (when (eq (point) orig) + (while (and (not (eobp)) (re-search-forward py-assignment-re) (setq last (match-beginning 1)) (py-in-string-or-comment-p))) + (when last + (goto-char last) + (setq erg (point)))) + (when (and py-verbose-p (interactive-p)) (message "%s" erg)) + erg)))) + +;; 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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 ARG \\[universal-argument] or ‘py-mark-decorators’ set to t, decorators are marked too. +Return 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. + +Return 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 ARG \\[universal-argument] or ‘py-mark-decorators’ set to t, decorators are marked too. +Return 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 ARG \\[universal-argument] or ‘py-mark-decorators’ set to t, decorators are marked too. +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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 ARG \\[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 ARG \\[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 ARG \\[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 STRG to Python interpreter process. + +Return collected output + +Optional SHELL BUFFER PROC" + (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 t)) + (unwind-protect + (condition-case nil + (progn + (with-current-buffer outbuf + (delete-region (point-min) (point-max))) + (with-current-buffer procbuf + (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 EOB-P, go to end of buffer." + (interactive "p") + (pop-to-buffer (process-buffer (py-proc)) t) ;Runs python if needed. + (when eob-p + (goto-char (point-max)))) + +(defun toggle-force-local-shell (&optional arg) + "If locally indicated Python shell should be taken. + +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. + +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))) + (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 () + "Make sure, ‘py-force-local-shell-p’ is on. + +Returns value of ‘py-force-local-shell-p’. +Optional FAST +Kind of an option 'follow', local shell sets ‘py-shell-name’, enforces its use afterwards" + (interactive) + (toggle-force-local-shell 1) + (when (or py-verbose-p (called-interactively-p 'any)) + (message "Enforce %s" py-shell-name))) + +(defun py-force-local-shell-off () + "Restore ‘py-shell-name’ default value and ‘behaviour’. + +Optional FAST" + (interactive) + (toggle-force-local-shell 1) + (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. + +Optional ARG +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 () + "Switch ‘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. + +optional ARG + 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’ according to ARG. + +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’ according to ARG. + + 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’ according to ARG. + +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 () + "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 interpreter in another window according to ARGPROMPT. + +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 nil t)) + +(defun py-ipython--which-version (shell) + "Returns IPython version as string" + (shell-command-to-string (concat (downcase (replace-regexp-in-string "[[:punct:]+]" "" shell)) " -V"))) + +(defun py-set-ipython-completion-command-string (shell) + "Set and return ‘py-ipython-completion-command-string’ according to SHELL." + (interactive) + (let* ((ipython-version (py-ipython--which-version shell))) + (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 according to PROC." + (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 according to LISTE." + (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--prepare-shell-name (erg) + "Provide a readable shell name by capitalizing etc." + (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)) + ((string-match "^pypy" erg) + (replace-regexp-in-string "pypy" "PyPy" erg)) + (t erg))) + +(defun py--choose-buffer-name (&optional name dedicated fast-process) + "Return an appropriate NAME to display in modeline. + +Optional DEDICATED FAST-PROCESS +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 erg py-shell-name)) + (setq prefix nil)) + (when fast-process (setq erg (concat erg " Fast"))) + (setq erg + (py--prepare-shell-name 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 PERR Python code at ORIGLINE in optional FILE." + (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 (buffer) + "If one window, split BUFFER. + +according to ‘py-split-windows-on-execute-function’." + (interactive) + (set-buffer buffer) + (or + ;; (split-window (selected-window) nil ’below) + (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 exception-buffer) + (unless (window-live-p output-buffer) + (with-current-buffer (get-buffer exception-buffer) + + (when (< number-of-windows py-split-window-on-execute-threshold) + (unless + (member (get-buffer-window output-buffer) (window-list)) + (py--manage-windows-split exception-buffer))) + (display-buffer output-buffer t) + (switch-to-buffer exception-buffer) + ))) + +(defun py--shell-manage-windows (output-buffer &optional exception-buffer split switch) + "Adapt or restore window configuration from OUTPUT-BUFFER. + +Optional EXCEPTION-BUFFER SPLIT SWITCH +Return nil." + (let* ((exception-buffer (or exception-buffer (other-buffer))) + (old-window-list (window-list)) + (number-of-windows (length old-window-list)) + (split (or split py-split-window-on-execute)) + (switch + (or py-switch-buffers-on-execute-p switch py-pdbtrack-tracked-buffer))) + ;; (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 exception-buffer) + ;; otherwise new window appears above + (save-excursion + (other-window 1) + (switch-to-buffer output-buffer)) + (display-buffer 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 exception-buffer) + (display-buffer output-buffer) + (pop-to-buffer exception-buffer))) + ((and + (eq split 'just-two) + switch) + (switch-to-buffer (current-buffer)) + (delete-other-windows) + (py--manage-windows-split 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 exception-buffer) + (delete-other-windows) + (unless + (member (get-buffer-window output-buffer) (window-list)) + (py--manage-windows-split 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 exception-buffer)) + ((and split switch) + (unless + (member (get-buffer-window output-buffer) (window-list)) + (py--manage-windows-split 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)))) + (ignore-errors (py-kill-buffer-unconditional shell)))) + +(defun py-kill-default-shell-unconditional () + "Kill buffer \"\*Python\*\" and its process." + (interactive) + (ignore-errors (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--guess-buffer-name (argprompt dedicated) + "Guess the ‘buffer-name’ core string according to ARGPROMPT DEDICATED." + (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 according to NAME." + (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--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 (shell fast-process) + "Unbuffered WRT fast-process" + (let ((erg + (delq nil + (cond + ;; ((eq 2 (prefix-numeric-value argprompt)) + ;; py-python2-command-args) + ((string-match "^[Ii]" shell) + (if (string-match "^[0-4]" (py-ipython--which-version shell)) + (remove "--simple-prompt" py-ipython-command-args) + (if (member "--simple-prompt" py-ipython-command-args) + py-ipython-command-args + (cons "--simple-prompt" py-ipython-command-args)))) + ((string-match "^[^-]+3" shell) + py-python3-command-args) + (t + py-python-command-args))))) + (if (and fast-process (not (member "-u" erg))) + (cons "-u" erg) + erg))) + +(defun py-shell-get-process (&optional argprompt args dedicated shell buffer) + "Get appropriate Python process for current buffer and return it. + +Optional ARGPROMPT DEDICATED SHELL BUFFER" + (interactive) + (or (and buffer (get-buffer-process buffer)) + (get-buffer-process (current-buffer)) + (get-buffer-process (py-shell argprompt args dedicated shell buffer)))) + +(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 and FILENAME. + +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 ERG for yank." + (and (not py-error) erg (or py-debug-p py-store-result-p) (kill-new erg))) + +(defcustom py-default-working-directory "" + "If not empty used by ‘py-set-current-working-directory’" + :type 'string + :tag "py-default-working-directory" + :group 'python-mode) + +(defun py-current-working-directory () + "Return the directory of current python SHELL." + (interactive) + (let* ((proc (get-buffer-process (current-buffer))) + erg) + (if proc + (setq erg (py-send-string (concat "import os\;os.getcwd()") proc nil t)) + (setq erg (replace-regexp-in-string "\n" "" (shell-command-to-string (concat py-shell-name " -c \"import os; print(os.getcwd())\""))))) + (when (interactive-p) (message "CWD: %s" erg)) + erg)) + +(defun py-set-working-directory (&optional directory) + "Set working directory according to optional DIRECTORY + +when given, to value of ‘py-default-working-directory’ otherwise" + (interactive) + (let* ((proc (get-buffer-process (current-buffer))) + (dir (or directory py-default-working-directory)) + erg) + (py-send-string (concat "import os\;os.chdir(\"" dir "\")") proc nil t) + (setq erg (py-send-string "os.getcwd()" proc nil t)) + (when (interactive-p) (message "CWD changed to: %s" erg)) + erg)) + +(defun py--update-execute-directory-intern (dir proc procbuf fast) + (let ((strg (concat "import os\;os.chdir(\"" dir "\")"))) + (if fast + (py-fast-send-string strg proc procbuf t t) + (py-send-string strg proc nil t)))) +;; (comint-send-string proc (concat "import os;os.chdir(\"" dir "\")\n"))) + +(defun py--update-execute-directory (proc procbuf execute-directory fast) + (with-current-buffer procbuf + (let ((cwd (py-current-working-directory))) + (unless (string= execute-directory (concat cwd "/")) + (py--update-execute-directory-intern (or py-execute-directory execute-directory) proc procbuf fast))))) + +(defun py--close-execution (tempbuf tempfile) + "Delete TEMPBUF and TEMPFILE." + (unless py-debug-p + (when tempfile (py-delete-temporary tempfile tempbuf)))) + +(defun py-shell-send-file (file-name &optional process temp-file-name + delete) + "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. If TEMP-FILE-NAME and DELETE are non-nil, then +TEMP-FILE-NAME is deleted after evaluation is performed. When +optional argument." + (interactive + (list + (read-file-name "File to send: "))) + (let* ((proc (or process (py-shell-get-process))) + (encoding (with-temp-buffer + (insert-file-contents + (or temp-file-name file-name)) + (py-info-encoding))) + (file-name (expand-file-name (file-local-name file-name))) + (temp-file-name (when temp-file-name + (expand-file-name + (file-local-name temp-file-name))))) + (py-shell-send-string + (format + (concat + "import codecs, os;" + "__pyfile = codecs.open('''%s''', encoding='''%s''');" + "__code = __pyfile.read().encode('''%s''');" + "__pyfile.close();" + (when (and delete temp-file-name) + (format "os.remove('''%s''');" temp-file-name)) + "exec(compile(__code, '''%s''', 'exec'));") + (or temp-file-name file-name) encoding encoding file-name) + proc))) + +(defun py--fetch-result (buffer limit &optional cmd) + "CMD: some shells echo the command in output-buffer +Delete it here" + (when py-verbose-p (message "(current-buffer): %s" (current-buffer)) + (switch-to-buffer (current-buffer))) + (if python-mode-v5-behavior-p + (with-current-buffer buffer + (string-trim (buffer-substring-no-properties (point-min) (point-max)) nil "\n")) + (when (< limit (point-max)) + (string-trim (replace-regexp-in-string py-shell-prompt-regexp "" (buffer-substring-no-properties limit (point-max))))))) + +(defun py--postprocess (output-buffer origline limit &optional cmd filename) + "Provide return values, check result for error, manage windows. + +According to OUTPUT-BUFFER ORIGLINE ORIG" + ;; py--fast-send-string doesn't set origline + (when (or py-return-result-p py-store-result-p) + (with-current-buffer output-buffer + (when py-debug-p (switch-to-buffer (current-buffer))) + (sit-for (py--which-delay-process-dependent (prin1-to-string output-buffer))) + ;; (catch 'py--postprocess + (setq py-result (py--fetch-result output-buffer limit cmd)) + ;; (throw 'py--postprocess (error "py--postprocess failed")) + ;;) + (if (and py-result (not (string= "" py-result))) + (if (string-match "^Traceback" py-result) + (if filename + (setq py-error py-result) + (progn + (with-temp-buffer + (insert py-result) + (sit-for 0.1 t) + (setq py-error (py--fetch-error origline filename))))) + (when py-store-result-p + (kill-new py-result)) + (when py-verbose-p (message "py-result: %s" py-result)) + py-result) + (when py-verbose-p (message "py--postprocess: %s" "Don't see any result")))))) + +(defun py--execute-file-base (&optional proc filename cmd procbuf origline fast) + "Send to Python interpreter process PROC. + +In Python version 2.. \"execfile('FILENAME')\". + +Takes also CMD PROCBUF ORIGLINE NO-OUTPUT. + +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." + ;; (message "(current-buffer) %s" (current-buffer)) + (let* ((buffer (or procbuf (and proc (process-buffer proc)) (py-shell nil nil nil nil nil fast))) + (proc (or proc (get-buffer-process buffer))) + (limit (marker-position (process-mark proc))) + (cmd (or cmd (py-which-execute-file-command filename))) + erg) + (if fast + (process-send-string proc cmd) + (py-send-string cmd proc)) + ;; (message "%s" (current-buffer)) + (with-current-buffer buffer + (when (or py-return-result-p py-store-result-p) + (setq erg (py--postprocess buffer origline limit cmd filename)) + (if py-error + (setq py-error (prin1-to-string py-error)) + erg))))) + +(defun py--execute-buffer-finally (strg proc procbuf origline filename fast wholebuf) + (if (and filename wholebuf (not (buffer-modified-p))) + (unwind-protect + (py--execute-file-base proc filename nil procbuf origline fast)) + (let* ((tempfile (concat (expand-file-name py-temp-directory) py-separator-char "temp" (md5 (format "%s" (nth 3 (current-time)))) ".py"))) + (with-temp-buffer + (insert strg) + (write-file tempfile)) + (unwind-protect + (py--execute-file-base proc tempfile nil procbuf origline fast) + (and (file-readable-p tempfile) (delete-file tempfile py-debug-p)))))) + +(defun py-execute-python-mode-v5 (start end origline filename) + "Take START END &optional EXCEPTION-BUFFER ORIGLINE." + (interactive "r") + (let ((output-buffer "*Python Output*") + (py-split-window-on-execute 'just-two) + (pcmd (concat py-shell-name (if (string-equal py-which-bufname + "Jython") + " -" + ;; " -c " + "")))) + (save-excursion + (shell-command-on-region start end + pcmd output-buffer)) + (if (not (get-buffer output-buffer)) + (message "No output.") + (setq py-result (py--fetch-result (get-buffer output-buffer) nil)) + (if (string-match "Traceback" py-result) + (message "%s" (setq py-error (py--fetch-error output-buffer origline filename))) + py-result)))) + +(defun py--execute-base-intern (strg filename proc file wholebuf buffer origline execute-directory start end &optional fast) + "Select the handler according to: + +STRG FILENAME PROC FILE WHOLEBUF +BUFFER ORIGLINE EXECUTE-DIRECTORY START END WHICH-SHELL +Optional FAST RETURN" + (setq py-error nil) + (cond ;; (fast (py-fast-send-string strg proc buffer result)) + ;; enforce proceeding as python-mode.el v5 + (python-mode-v5-behavior-p + (py-execute-python-mode-v5 start end origline filename)) + (py-execute-no-temp-p + (py--execute-ge24.3 start end execute-directory py-shell-name py-exception-buffer proc file origline)) + ((and filename wholebuf) + (py--execute-file-base proc filename nil buffer origline fast)) + (t + ;; (message "(current-buffer) %s" (current-buffer)) + (py--execute-buffer-finally strg proc buffer origline filename fast wholebuf) + ;; (py--delete-temp-file tempfile) + ))) + +(defun py--execute-base (&optional start end shell filename proc file wholebuf fast dedicated split switch) + "Update optional variables START END SHELL FILENAME PROC FILE WHOLEBUF FAST DEDICATED SPLIT SWITCH." + (setq py-error nil) + (when py-debug-p (message "py--execute-base: (current-buffer): %s" (current-buffer))) + (when (or fast py-fast-process-p) (ignore-errors (py-kill-buffer-unconditional py-output-buffer))) + (let* ((orig (point)) + (fast (or fast py-fast-process-p)) + (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)))))) + ;; error messages may mention differently when running from a temp-file + (origline + (format "%s" (save-restriction + (widen) + (py-count-lines (point-min) orig)))) + ;; 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)))) + ;; (save-excursion + (py-choose-shell) + ;;) + )) + (shell (or shell (py-choose-shell))) + (buffer-name + (py--choose-buffer-name shell dedicated 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")))) + (filename (or (and filename (expand-file-name filename)) + (py--buffer-filename-remote-maybe))) + (py-orig-buffer-or-file (or filename (current-buffer))) + (proc-raw (or proc (get-buffer-process buffer-name))) + + (proc (or proc-raw (get-buffer-process buffer-name) + (prog1 + (get-buffer-process (py-shell nil nil dedicated shell buffer-name fast exception-buffer split switch)) + (sit-for 0.1)))) + (split (if python-mode-v5-behavior-p 'just-two split))) + (setq py-output-buffer (or (and python-mode-v5-behavior-p py-output-buffer) (and proc (buffer-name (process-buffer proc))) + (py--choose-buffer-name shell dedicated fast))) + (py--execute-base-intern strg filename proc file wholebuf py-output-buffer origline execute-directory start end fast) + (when (or split py-split-window-on-execute py-switch-buffers-on-execute-p) + (py--shell-manage-windows py-output-buffer exception-buffer (or split py-split-window-on-execute) switch)))) + +;; (defmacro py--execute-prepare (form shell dedicated switch beg end file fast proc wholebuf split) +;; "Used by python-components-extended-executes ." +;; (declare (debug t)) +;; (save-excursion +;; `(let* ((form ,(prin1-to-string form)) +;; (origline (py-count-lines)) +;; (fast +;; (or ,fast ,py-fast-process-p) +;; ) +;; (py-exception-buffer (current-buffer)) +;; (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 (save-excursion (funcall (intern-soft (concat "py-forward-" form))))))) +;; filename) +;; ;; (setq py-buffer-name nil) +;; (if ,file +;; (progn +;; (setq filename (expand-file-name ,file)) +;; (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--execute-prepare (form shell &optional dedicated switch beg end file fast proc wholebuf split) + "Update some vars." + (save-excursion + (let* ((form (prin1-to-string form)) + (origline (py-count-lines)) + (fast + (or fast py-fast-process-p)) + (py-exception-buffer (current-buffer)) + (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 (save-excursion (funcall (intern-soft (concat "py-forward-" form))))))) + filename) + ;; (setq py-buffer-name nil) + (if file + (progn + (setq filename (expand-file-name file)) + (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--delete-temp-file (tempfile &optional tempbuf) +;; "After ‘py--execute-buffer-finally’ returned delete TEMPFILE &optional TEMPBUF." +;; (sit-for py--delete-temp-file-delay t) +;; (py--close-execution tempbuf tempfile)) + +(defun py--fetch-error (output-buffer &optional origline filename) + "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 ORIGLINE of source buffer" + (with-current-buffer output-buffer + (when py-debug-p (switch-to-buffer (current-buffer))) + ;; (setq py-error (buffer-substring-no-properties (point) (point-max))) + (goto-char (point-max)) + (when (re-search-backward "File \"\\(.+\\)\", line \\([0-9]+\\)\\(.*\\)$" nil t) + (when (and filename (re-search-forward "File \"\\(.+\\)\", line \\([0-9]+\\)\\(.*\\)$" nil t) + (replace-match filename nil nil nil 1)) + (when (and origline (re-search-forward "line \\([0-9]+\\)\\(.*\\)$" (line-end-position) t 1)) + (replace-match origline nil nil nil 2))) + (setq py-error (buffer-substring-no-properties (point) (point-max)))) + ;; (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--execute-ge24.3 (start end execute-directory which-shell &optional exception-buffer proc file origline) + "An alternative way to do it. + +According to START END EXECUTE-DIRECTORY WHICH-SHELL +Optional EXCEPTION-BUFFER PROC FILE ORIGLINE +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 nil t which-shell)) + (or (get-buffer-process py-buffer-name) + (get-buffer-process (py-shell nil 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--insert-offset-lines (line) + "Fix offline amount, make error point at the correct LINE." + (insert (make-string (- line (py-count-lines (point-min) (point))) 10))) + +(defun py-execute-file (filename) + "When called interactively, user is prompted for FILENAME." + (interactive "fFilename: ") + (let (;; postprocess-output-buffer might want origline + (origline 1) + (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?")) + (py--shell-manage-windows py-output-buffer py-exception-buffer nil (or (interactive-p))) + erg)) + +(defun py-execute-string (&optional strg shell dedicated switch fast) + "Send the optional argument STRG to Python default interpreter. + +Optional SHELL DEDICATED SWITCH FAST +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 STRG to an unique Python interpreter. + +Optional SHELL SWITCH FAST +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 (eq 9 (char-after)) (newline 1)) + (insert (concat "import os; os.chdir(\"" directory "\")\n")))))) + +(defun py--fix-if-name-main-permission (strg) + "Remove \"if __name__ == '__main__ '\" STRG 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. + +Takes STRG +Avoid empty lines at the beginning." + ;; (when py-debug-p (message "py--fix-start:")) + (let (py--imenu-create-index-p + py-guess-py-install-directory-p + py-autopair-mode + py-complete-function + py-load-pymacs-p + py-load-skeletons-p + erg) + (with-temp-buffer + (python-mode) + (insert strg) + (goto-char (point-min)) + (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 (py-empty-line-p) + (newline 1)) + (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. + +Optional SHELL +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))) + (if file + (let ((proc (or + (ignore-errors (get-process (file-name-directory shell))) + (get-buffer-process (py-shell nil 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 py-switch-buffers-on-execute-p (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 FILE and 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* ((buffer 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* ((buffer 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 output-buffer) + "Highlight exceptions found in BUF. + +Optional ORIGLINE EXCEPTION-BUFFER +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" + (save-excursion + (with-current-buffer output-buffer + (let* (estring ecode erg) + ;; (switch-to-buffer (current-buffer)) + (goto-char (point-max)) + (sit-for 0.1) + (save-excursion + (unless (looking-back py-pdbtrack-input-prompt (line-beginning-position)) + (forward-line -1) + (end-of-line) + (when (re-search-backward py-shell-prompt-regexp t 1) + ;; (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 + 1py-shell-prompt-regexp) + (goto-char (match-end 0))))) + + (progn (skip-chars-forward " \t\r\n\f" (line-end-position))(point))) + (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) + "According to DIRECTION and START setup exception regexps. + +Depends 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) +(defalias 'py-send-region 'py-execute-region) + +;; python-components-send +(defun py-output-buffer-filter (&optional beg end) + "Clear output buffer from py-shell-input prompt etc. + +Optional BEG END" + (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 STRG from py-shell-input prompt." + (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)) + + +;; 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-no-output (format completion-code input) process))) + (if (and erg (> (length erg) 2)) + (setq erg (split-string erg "^'\\|^\"\\|;\\|'$\\|\"$" t)) + (and py-verbose-p (message "py--shell-completion-get-completions: %s" "Don't see a completion"))) + erg)) + +;; post-command-hook +;; caused insert-file-contents error lp:1293172 +(defun py--after-change-function (end) + "Restore window-confiuration after completion. + +Takes END" + (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) + ;; (jump-to-register py-windows-config-register) + (py-restore-window-configuration) + ) + + (goto-char end)) + +(defalias 'ipython-complete 'py-shell-complete) + +(defun py--try-completion-intern (input completion buffer) + (with-current-buffer buffer + (let (erg) + (and (setq erg (try-completion input completion)) + (sit-for 0.1) + (looking-back input (line-beginning-position)) + (not (string= input erg)) + (setq erg (completion-in-region (match-beginning 0) (match-end 0) completion))))) + ;; (set-window-configuration py-last-window-configuration) + ) + +(defun py--try-completion (input completion) + "Repeat `try-completion' as long as match are found. + +Interal used. Takes INPUT COMPLETION" + (let (erg newlist) + (unless (py--try-completion-intern input completion (current-buffer)) + (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)))))))) + +(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."))) + ((null completion) + (and py-verbose-p (message "py--shell-do-completion-at-point %s" "Don't see a completion"))) + ((and completion + (or (and (listp completion) + (string= input (car completion))) + (and (stringp completion) + (string= input completion))))) + ((and completion (stringp completion)(or (string= input completion) (string= "''" completion)))) + ((and completion (stringp completion)) + (progn (delete-char (- (length input))) + (insert completion))) + (t (py--try-completion input completion))) + ) + +(defun py--shell-do-completion-at-point (process imports input exception-buffer code) + "Do completion at point for PROCESS. + +Takes PROCESS IMPORTS INPUT EXCEPTION-BUFFER CODE" + (when imports + (py-send-string imports process nil t)) + (sit-for 0.1 t) + (let* ((completion + (py--shell-completion-get-completions + input process code))) + (set-buffer exception-buffer) + (when completion + (py--shell-insert-completion-maybe completion input)))) + +(defun py--complete-base (shell word imports buffer) + (let* ((proc (or + ;; completing inside a shell + (get-buffer-process buffer) + (and (comint-check-proc shell) + (get-process shell)) + (prog1 + (get-buffer-process (py-shell nil nil nil shell)) + (sit-for py-new-shell-delay t)))) + ;; (buffer (process-buffer proc)) + (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 buffer code))) + +(defun py-shell-complete (&optional shell beg end word fast) + (interactive) + (let* ((exception-buffer (current-buffer)) + (pps (parse-partial-sexp + (or + (ignore-errors (cdr-safe comint-last-prompt)) + (ignore-errors comint-last-prompt) + (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 (py--fast-complete-base shell word imports)) + ((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-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 "*") + (window-configuration-to-register py-windows-config-register) + ;; (setq py-last-window-configuration + ;; (current-window-configuration)) + (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]*$"))) + (py-indent-line)) + ((comint-check-proc (current-buffer)) + ;; (let* ((shell (process-name (get-buffer-process (current-buffer))))) + (ignore-errors (completion-at-point))) + (t + ;; (py-fast-complete) + (completion-at-point)))) + + ;; (substring (process-name (get-buffer-process (current-buffer))) 0 (string-match "<" (process-name (get-buffer-process (current-buffer))))) +;; python-components-pdb + +(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) + "Takes region between BEG END." + (interactive "r") + (let ((py-python-command-args "-i -m pdb"))) + (py-execute-region beg end)) + +(defun py-pdb-execute-statement () + "Execute statement running pdb." + (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()")) + +;; https://stackoverflow.com/questions/6980749/simpler-way-to-put-pdb-breakpoints-in-python-code +;; breakpoint at line 3 +;; avoid inserting pdb.set_trace() + +;; python -m pdb -c "b 3" -c c your_script.py + +(defun py-pdb-break-at-current-line (&optional line) + "Set breakpoint at current line. + +Optional LINE FILE CONDITION" + (interactive "p") + (let ((line (or line (py-count-lines)))) + (py-execute-string (concat "import pdb;pdb.break('" line "')")))) + +(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 required pdb version should be detected by `py--pdb-version' +at Windows configure `py-python-ms-pdb-command' + +lp:963253 +Argument COMMAND-LINE TBD." + (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)) )))) + +;; tbreak [ ([filename:]lineno | function) [, condition] ] +;; Same arguments as break, but sets a temporary breakpoint: it +;; is automatically deleted when first hit. + +;; python -m pdb -c "b 3" -c c your_script.py + +(defun py-pdb-tbreak () + "Insert a temporary break." + (interactive) + (let ( + (py-python-command-args '("-i -c \"b 30\" -c c \"eyp.py\"")) + (py-python3-command-args '("-i -c \"b 30\" -c c \"eyp.py\"")) + ) + (py-execute-buffer))) + + + +(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)) + ) + (prog1 + "Traceback cue not found" + (message "Block: %s" block)) + (let* ((remote-prefix (or (file-remote-p default-directory) "")) + (filename (concat remote-prefix + (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 ((string= filename "") + (format "(Skipping empty filename)")) + + ((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-set-tracked-buffer (file-name) + "Set the buffer for FILE-NAME as the tracked buffer. +Internally it uses the `py-pdbtrack-tracked-buffer' variable. +Returns the tracked buffer." + (let* ((file-name-prospect (concat (file-remote-p default-directory) + file-name)) + (file-buffer (get-file-buffer file-name-prospect))) + (if file-buffer + (setq py-pdbtrack-tracked-buffer file-buffer) + (cond + ((file-exists-p file-name-prospect) + (setq file-buffer (find-file-noselect file-name-prospect))) + ((and (not (equal file-name file-name-prospect)) + (file-exists-p file-name)) + ;; Fallback to a locally available copy of the file. + (setq file-buffer (find-file-noselect file-name-prospect)))) + (when (not (member file-buffer py-pdbtrack-buffers-to-kill)) + (add-to-list 'py-pdbtrack-buffers-to-kill file-buffer))) + file-buffer)) + +(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)) + + + +(if pdb-track-stack-from-shell-p + (add-hook 'comint-output-filter-functions 'py--pdbtrack-track-stack-file t) + (remove-hook 'comint-output-filter-functions 'py--pdbtrack-track-stack-file t)) + + +(defun py-pdbtrack-comint-output-filter-function (output) + "Move overlay arrow to current pdb line in tracked buffer. +Argument OUTPUT is a string with the output from the comint process." + (when (and pdb-track-stack-from-shell-p (not (string= output ""))) + (let* ((full-output (ansi-color-filter-apply + (buffer-substring comint-last-input-end (point-max)))) + (line-number) + (file-name + (with-temp-buffer + (insert full-output) + ;; When the debugger encounters a pdb.set_trace() + ;; command, it prints a single stack frame. Sometimes + ;; it prints a bit of extra information about the + ;; arguments of the present function. When ipdb + ;; encounters an exception, it prints the _entire_ stack + ;; trace. To handle all of these cases, we want to find + ;; the _last_ stack frame printed in the most recent + ;; batch of output, then jump to the corresponding + ;; file/line number. + (goto-char (point-max)) + (when (re-search-backward py-pdbtrack-stacktrace-info-regexp nil t) + (setq line-number (string-to-number + (match-string-no-properties 2))) + (match-string-no-properties 1))))) + (if (and file-name line-number) + (let* ((tracked-buffer + (py-pdbtrack-set-tracked-buffer file-name)) + (shell-buffer (current-buffer)) + (tracked-buffer-window (get-buffer-window tracked-buffer)) + (tracked-buffer-line-pos)) + (with-current-buffer tracked-buffer + (set (make-local-variable 'overlay-arrow-string) "=>") + (set (make-local-variable 'overlay-arrow-position) (make-marker)) + (setq tracked-buffer-line-pos (progn + (goto-char (point-min)) + (forward-line (1- line-number)) + (point-marker))) + (when tracked-buffer-window + (set-window-point + tracked-buffer-window tracked-buffer-line-pos)) + (set-marker overlay-arrow-position tracked-buffer-line-pos)) + (pop-to-buffer tracked-buffer) + (switch-to-buffer-other-window shell-buffer)) + (when py-pdbtrack-tracked-buffer + (with-current-buffer py-pdbtrack-tracked-buffer + (set-marker overlay-arrow-position nil)) + (mapc #'(lambda (buffer) + (ignore-errors (kill-buffer buffer))) + py-pdbtrack-buffers-to-kill) + (setq py-pdbtrack-tracked-buffer nil + py-pdbtrack-buffers-to-kill nil))))) + output) + +;; python-components-pdbtrack + + +;; 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.") + +;; Info-look functionality. +(require 'info-look) +(eval-when-compile (require 'info)) + +(defun py-info-lookup-symbol () + "Call ‘info-lookup-symbol’. + +Sends help if stuff is missing." + (interactive) + (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 (interactive-p) (switch-to-buffer (current-buffer))) + (insert erg))))))) + +(defun py-info-current-defun (&optional include-type) + "Return name of surrounding function. + +Use 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) +(defun py--help-at-point-intern (sym orig) + (let* ((origfile (py--buffer-filename-remote-maybe)) + ;; (temp (md5 (buffer-name))) + (buffer-name "*Python-Help*") + (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)) + (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")) + (ignore-errors (py-kill-buffer-unconditional buffer-name)) + (with-temp-buffer-window + (set-buffer (get-buffer-create buffer-name)) + (setq inhibit-read-only t) + (setq inhibit-point-motion-hooks t) + (erase-buffer) + (when py-debug-p (message "%s" (current-buffer))) + (py-send-string cmd nil t) + (insert py-result) + ))) + +(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* ((py-cleanup-p t) + (orig (point)) + (beg (and (use-region-p) (region-beginning))) + (end (and (use-region-p) (region-end))) + (symbol + (or (and beg end + (buffer-substring-no-properties beg end)) + ;; (thing-at-point 'symbol t) + (py-symbol-at-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 (eq (face-at-point) 'font-lock-string-face)(eq (face-at-point) 'font-lock-comment-face)) + (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")) + (not (string= "" symbol)) + (py--help-at-point-intern symbol 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 (concat "import inspect;inspect.isbuiltin(\"" symbol "\")")))) + (t (setq erg (py-send-string (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* (;; end + ;; (last-window-configuration + ;; (current-window-configuration)) + (orig (point)) + ;; (exception-buffer (current-buffer)) + (imports (py-find-imports)) + (symbol-raw (or symbol (with-syntax-table py-dotted-expression-syntax-table + (current-word)))) + ;; (enable-recursive-minibuffers t) + (symbol (if (interactive-p) + (read-string (format "Find location of (default %s): " symbol-raw) + symbol-raw nil symbol-raw) + symbol-raw)) + (local (progn (goto-char (point-min)) (re-search-forward (concat "^[ \t]*" "\\(def\\|class\\)" "[ \t]" symbol) orig t)))) + ;; ismethod(), isclass(), isfunction() or isbuiltin() + ;; ismethod isclass isfunction isbuiltin) + (if local + (progn + (goto-char orig) + (split-window-vertically) + (other-buffer) + (goto-char local) + (beginning-of-line) + (push-mark) + (message "%s" (current-buffer)) + (exchange-point-and-mark)) + (with-help-window (help-buffer) + (princ (py--find-definition-question-type symbol imports)))))) + +(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 () + "Return imports. + +Imports done are displayed in message buffer." + (interactive) + (save-excursion + (let ( + (orig (point)) + (erg (py-find-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 using COMMAND, 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 from COMMAND (default on the file currently visited). + +For help see \\[pylint-help] resp. \\[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 on COMMAND (default on the file currently visited). + +For help see \\[pyflakes-help] resp. \\[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 COMMAND 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 COMMAND 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 py-compilation-regexp-alist) + ;; (cons '("(\\([^,]+\\), line \\([0-9]+\\))" 1) + ;; compilation-error-regexp-alist) + ) + (compilation-start command))) + +;; flake8 +(defalias 'flake8 'py-flake8-run) +(defun py-flake8-run (command) + "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 + - no-warn lines that contain a `# noqa`` comment at the end. + - 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’ - PPS." + (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)) + +;; Flymake +(defun py-toggle-flymake-intern (name command) + "Clear flymake allowed file-name masks. + +Takes NAME COMMAND" + (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 ARG 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 py-display-state-of-variables () + "Read the state of ‘python-mode’ variables. + +Assumes vars are defined in current source buffer" + (interactive) + (save-restriction + (let (variableslist) + (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)) + (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 t)) + (sit-for 0.01 t)))) + +;; common typo +(defalias 'iypthon 'ipython) +(defalias 'pyhton 'python) + +;; 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 (py-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 1) + (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 (py-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 (py-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 (&optional arg) + "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 "*P") + (if (eq 4 (prefix-numeric-value arg)) + (insert "%") + (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 (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 (py-symbol-at-point)) + (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 (py-empty-line-p) + (delete-region (line-beginning-position) (line-end-position))) + (goto-char orig) + (insert "pdb.set_trace()"))) + +(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 (if numbered + (concat "print(\"" name ": %s \" % (" name "))") + (concat "print(\"" name ": %s \" % \"" name "\")")))) + (insert form))) + +(defun py-print-formatform-insert (&optional strg) + "Inserts a print statement out of current `(car kill-ring)' by default. + +print(\"\\nfoo: {}\"\.format(foo))" + (interactive "*") + (let ((name (py--string-strip (or strg (car kill-ring))))) + (insert (concat "print(\"" name ": {}\".format(" name "))")))) + +(defun py-line-to-printform-python2 () + "Transforms the item on current in a print statement. " + (interactive "*") + (let* ((name (py-symbol-at-point)) + (form (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"))))) + +;; 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-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.") + + +(defvar py-imenu-generic-regexp nil) +(defvar py-imenu-generic-parens nil) + + +(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." + (save-excursion + (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))) + ;; (switch-to-buffer (current-buffer)) + (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)) + +;; A modified slice from python.el +(defvar py-imenu-format-item-label-function + 'py-imenu-format-item-label + "Imenu function used to format an item label. +It must be a function with two arguments: TYPE and NAME.") + +(defvar py-imenu-format-parent-item-label-function + 'py-imenu-format-parent-item-label + "Imenu function used to format a parent item label. +It must be a function with two arguments: TYPE and NAME.") + +(defvar py-imenu-format-parent-item-jump-label-function + 'py-imenu-format-parent-item-jump-label + "Imenu function used to format a parent jump item label. +It must be a function with two arguments: TYPE and NAME.") + +(defun py-imenu-format-item-label (type name) + "Return Imenu label for single node using TYPE and NAME." + (format "%s (%s)" name type)) + +(defun py-imenu-format-parent-item-label (type name) + "Return Imenu label for parent node using TYPE and NAME." + (format "%s..." (py-imenu-format-item-label type name))) + +;; overengineering? +(defun py-imenu-format-parent-item-jump-label (type _name) + "Return Imenu label for parent node jump using TYPE and NAME." + (if (string= type "class") + "*class definition*" + "*function definition*")) + +(defun py-imenu--put-parent (type name pos tree) + "Add the parent with TYPE, NAME and POS to TREE." + (let* ((label + (funcall py-imenu-format-item-label-function type name)) + ;; (jump-label + ;; (funcall py-imenu-format-parent-item-jump-label-function type name)) + (jump-label label + ;; (funcall py-imenu-format-parent-item-jump-label-function type name) + ) + ) + (if (not tree) + (cons label pos) + (cons label (cons (cons jump-label pos) tree))))) + +(defun py-imenu--build-tree (&optional min-indent prev-indent tree) + "Recursively build the tree of nested definitions of a node. +Arguments MIN-INDENT, PREV-INDENT and TREE are internal and should +not be passed explicitly unless you know what you are doing." + (setq min-indent (or min-indent 0) + prev-indent (or prev-indent py-indent-offset)) + (save-restriction + (narrow-to-region (point-min) (point)) + (let* ((pos + (progn + ;; finds a top-level class + (py-backward-def-or-class) + ;; stops behind the indented form at EOL + (py-forward-def-or-class) + ;; may find an inner def-or-class + (py-backward-def-or-class))) + type + (name (when (and pos (looking-at py-def-or-class-re)) + (let ((split (split-string (match-string-no-properties 0)))) + (setq type (car split)) + (cadr split)))) + (label (when name + (funcall py-imenu-format-item-label-function type name))) + (indent (current-indentation)) + (children-indent-limit (+ py-indent-offset min-indent))) + (cond ((not pos) + ;; Nothing found, probably near to bobp. + nil) + ((<= indent min-indent) + ;; The current indentation points that this is a parent + ;; node, add it to the tree and stop recursing. + (py-imenu--put-parent type name pos tree)) + (t + (py-imenu--build-tree + min-indent + indent + (if (<= indent children-indent-limit) + (cons (cons label pos) tree) + (cons + (py-imenu--build-tree + prev-indent indent (list (cons label pos))) + tree)))))))) + +(defun py--imenu-index () + "Return tree Imenu alist for the current Python buffer. " + (save-excursion + (goto-char (point-max)) + (let ((index) + (tree)) + (while (setq tree (py-imenu--build-tree)) + (setq index (cons tree index))) + index))) + +;; 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) + "Return 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) + "Return 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) + "Return 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-partial-expression-p (&optional pps) + "Return 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) + "Return 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) + "Return 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-assignment-p (&optional pps) + "Return position, if cursor is at the beginning of a ‘assignment’, nil otherwise." + (let ((pps (or pps (parse-partial-sexp (point-min) (point))))) + (and (not (or (nth 8 pps)(nth 1 pps))) + (looking-at py-assignment-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (eq (current-column)(current-indentation)) + (point)))) + +(defun py--beginning-of-block-p (&optional pps) + "Return 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) + "Return 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) + "Return 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) + "Return 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) + "Return 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) + "Return 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) + "Return 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-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (eq (current-column)(current-indentation)) + (point)))) + +(defun py--beginning-of-else-block-p (&optional pps) + "Return 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-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (eq (current-column)(current-indentation)) + (point)))) + +(defun py--beginning-of-except-block-p (&optional pps) + "Return 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-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (eq (current-column)(current-indentation)) + (point)))) + +(defun py--beginning-of-for-block-p (&optional pps) + "Return 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-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (eq (current-column)(current-indentation)) + (point)))) + +(defun py--beginning-of-if-block-p (&optional pps) + "Return 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-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (eq (current-column)(current-indentation)) + (point)))) + +(defun py--beginning-of-indent-p (&optional pps) + "Return 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) + "Return 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) + "Return 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) + "Return 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-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (eq (current-column)(current-indentation)) + (point)))) + +(defun py--beginning-of-assignment-bol-p (&optional pps) + "Return position, if cursor is at the beginning of a ‘assignment’, 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-assignment-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (point)))) + +(defun py--beginning-of-block-bol-p (&optional pps) + "Return 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) + "Return 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) + "Return 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) + "Return 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) + "Return 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) + "Return 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) + "Return 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-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (point)))) + +(defun py--beginning-of-else-block-bol-p (&optional pps) + "Return 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-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (point)))) + +(defun py--beginning-of-except-block-bol-p (&optional pps) + "Return 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-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (point)))) + +(defun py--beginning-of-for-block-bol-p (&optional pps) + "Return 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-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (point)))) + +(defun py--beginning-of-if-block-bol-p (&optional pps) + "Return 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-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (point)))) + +(defun py--beginning-of-indent-bol-p (&optional pps) + "Return 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) + "Return 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) + "Return 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) + "Return 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-re) + (looking-back "[^ \t]*" (line-beginning-position)) + (point)))) + +;; python-components-booleans-end-forms + + +(defun py--end-of-comment-p () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return beginning of class position." + (save-excursion + (let ((erg (or (py--beginning-of-class-p) + (py-backward-class)))) + erg))) + +(defun py--beginning-of-clause-position () + "Return beginning of clause position." + (save-excursion + (let ((erg (or (py--beginning-of-clause-p) + (py-backward-clause)))) + erg))) + +(defun py--beginning-of-comment-position () + "Return beginning of comment position." + (save-excursion + (let ((erg (or (py--beginning-of-comment-p) + (py-backward-comment)))) + erg))) + +(defun py--beginning-of-def-position () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return beginning of indent position." + (save-excursion + (let ((erg (or (py--beginning-of-indent-p) + (py-backward-indent)))) + erg))) + +(defun py--beginning-of-line-position () + "Return 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 () + "Return 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 () + "Return 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 () + "Return beginning of paragraph position." + (save-excursion + (let ((erg (or (py--beginning-of-paragraph-p) + (py-backward-paragraph)))) + erg))) + +(defun py--beginning-of-section-position () + "Return beginning of section position." + (save-excursion + (let ((erg (or (py--beginning-of-section-p) + (py-backward-section)))) + erg))) + +(defun py--beginning-of-statement-position () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return 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 () + "Return end of block position." + (save-excursion (py-forward-block))) + +(defun py--end-of-block-or-clause-position () + "Return end of block-or-clause position." + (save-excursion (py-forward-block-or-clause))) + +(defun py--end-of-class-position () + "Return end of class position." + (save-excursion (py-forward-class))) + +(defun py--end-of-clause-position () + "Return end of clause position." + (save-excursion (py-forward-clause))) + +(defun py--end-of-comment-position () + "Return end of comment position." + (save-excursion (py-forward-comment))) + +(defun py--end-of-def-position () + "Return end of def position." + (save-excursion (py-forward-def))) + +(defun py--end-of-def-or-class-position () + "Return end of def-or-class position." + (save-excursion (py-forward-def-or-class))) + +(defun py--end-of-expression-position () + "Return end of expression position." + (save-excursion (py-forward-expression))) + +(defun py--end-of-except-block-position () + "Return end of except-block position." + (save-excursion (py-forward-except-block))) + +(defun py--end-of-if-block-position () + "Return end of if-block position." + (save-excursion (py-forward-if-block))) + +(defun py--end-of-indent-position () + "Return end of indent position." + (save-excursion (py-forward-indent))) + +(defun py--end-of-line-position () + "Return end of line position." + (save-excursion (py-forward-line))) + +(defun py--end-of-minor-block-position () + "Return end of minor-block position." + (save-excursion (py-forward-minor-block))) + +(defun py--end-of-partial-expression-position () + "Return end of partial-expression position." + (save-excursion (py-forward-partial-expression))) + +(defun py--end-of-paragraph-position () + "Return end of paragraph position." + (save-excursion (py-forward-paragraph))) + +(defun py--end-of-section-position () + "Return end of section position." + (save-excursion (py-forward-section))) + +(defun py--end-of-statement-position () + "Return end of statement position." + (save-excursion (py-forward-statement))) + +(defun py--end-of-top-level-position () + "Return end of top-level position." + (save-excursion (py-forward-top-level))) + +(defun py--end-of-try-block-position () + "Return end of try-block position." + (save-excursion (py-forward-try-block))) + +(defun py--end-of-block-position-bol () + "Return end of block position at ‘beginning-of-line’." + (save-excursion (py-forward-block-bol))) + +(defun py--end-of-block-or-clause-position-bol () + "Return end of block-or-clause position at ‘beginning-of-line’." + (save-excursion (py-forward-block-or-clause-bol))) + +(defun py--end-of-class-position-bol () + "Return end of class position at ‘beginning-of-line’." + (save-excursion (py-forward-class-bol))) + +(defun py--end-of-clause-position-bol () + "Return end of clause position at ‘beginning-of-line’." + (save-excursion (py-forward-clause-bol))) + +(defun py--end-of-def-position-bol () + "Return end of def position at ‘beginning-of-line’." + (save-excursion (py-forward-def-bol))) + +(defun py--end-of-def-or-class-position-bol () + "Return end of def-or-class position at ‘beginning-of-line’." + (save-excursion (py-forward-def-or-class-bol))) + +(defun py--end-of-elif-block-position-bol () + "Return end of elif-block position at ‘beginning-of-line’." + (save-excursion (py-forward-elif-block-bol))) + +(defun py--end-of-else-block-position-bol () + "Return end of else-block position at ‘beginning-of-line’." + (save-excursion (py-forward-else-block-bol))) + +(defun py--end-of-except-block-position-bol () + "Return end of except-block position at ‘beginning-of-line’." + (save-excursion (py-forward-except-block-bol))) + +(defun py--end-of-for-block-position-bol () + "Return end of for-block position at ‘beginning-of-line’." + (save-excursion (py-forward-for-block-bol))) + +(defun py--end-of-if-block-position-bol () + "Return end of if-block position at ‘beginning-of-line’." + (save-excursion (py-forward-if-block-bol))) + +(defun py--end-of-indent-position-bol () + "Return end of indent position at ‘beginning-of-line’." + (save-excursion (py-forward-indent-bol))) + +(defun py--end-of-minor-block-position-bol () + "Return end of minor-block position at ‘beginning-of-line’." + (save-excursion (py-forward-minor-block-bol))) + +(defun py--end-of-statement-position-bol () + "Return end of statement position at ‘beginning-of-line’." + (save-excursion (py-forward-statement-bol))) + +(defun py--end-of-try-block-position-bol () + "Return end of try-block position at ‘beginning-of-line’." + (save-excursion (py-forward-try-block-bol))) + +;; 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 'interactive)) (message "%s" erg)) + erg)) + +(defun py-down-statement () + "Go to the beginning of next statement downwards in buffer. + +Corresponds to backward-up-list in Elisp +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) + (< orig (point)) + (point)))) + ((ignore-errors (< orig (ignore-errors (and (py-forward-statement) (py-backward-statement))))) + (setq erg (point))) + (t (setq erg (ignore-errors (< orig (and (py-forward-statement) (py-forward-statement)(py-backward-statement))))))) + (when (and py-verbose-p (called-interactively-p 'interactive)) (message "%s" erg)) + erg)) + +(defalias 'py-block-up 'py-up-block) +(defun py-up-block (&optional indent) + "Go to the beginning of next block upwards in buffer according to INDENT. +Optional INDENT +Return position if block found, nil otherwise." + (interactive) + (py-up-base 'py-block-re indent)) + +(defalias 'py-class-up 'py-up-class) +(defun py-up-class (&optional indent) + "Go to the beginning of next class upwards in buffer according to INDENT. +Optional INDENT +Return position if class found, nil otherwise." + (interactive) + (py-up-base 'py-class-re indent)) + +(defalias 'py-clause-up 'py-up-clause) +(defun py-up-clause (&optional indent) + "Go to the beginning of next clause upwards in buffer according to INDENT. +Optional INDENT +Return position if clause found, nil otherwise." + (interactive) + (py-up-base 'py-clause-re indent)) + +(defalias 'py-block-or-clause-up 'py-up-block-or-clause) +(defun py-up-block-or-clause (&optional indent) + "Go to the beginning of next block-or-clause upwards in buffer according to INDENT. +Optional INDENT +Return position if block-or-clause found, nil otherwise." + (interactive) + (py-up-base 'py-block-or-clause-re indent)) + +(defalias 'py-def-up 'py-up-def) +(defun py-up-def (&optional indent) + "Go to the beginning of next def upwards in buffer according to INDENT. +Optional INDENT +Return position if def found, nil otherwise." + (interactive) + (py-up-base 'py-def-re indent)) + +(defalias 'py-def-or-class-up 'py-up-def-or-class) +(defun py-up-def-or-class (&optional indent) + "Go to the beginning of next def-or-class upwards in buffer according to INDENT. +Optional INDENT +Return position if def-or-class found, nil otherwise." + (interactive) + (py-up-base 'py-def-or-class-re indent)) + +(defalias 'py-minor-block-up 'py-up-minor-block) +(defun py-up-minor-block (&optional indent) + "Go to the beginning of next minor-block upwards in buffer according to INDENT. +Optional INDENT +Return position if minor-block found, nil otherwise." + (interactive) + (py-up-base 'py-minor-block-re indent)) + +(defalias 'py-block-down 'py-down-block) +(defun py-down-block (&optional indent) + "Go to the beginning of next block below in buffer according to INDENT. + +Optional INDENT: honor indentation +Return position if block found, nil otherwise." + (interactive) + (py-down-base 'py-block-re indent)) + +(defalias 'py-class-down 'py-down-class) +(defun py-down-class (&optional indent) + "Go to the beginning of next class below in buffer according to INDENT. + +Optional INDENT: honor indentation +Return position if class found, nil otherwise." + (interactive) + (py-down-base 'py-class-re indent)) + +(defalias 'py-clause-down 'py-down-clause) +(defun py-down-clause (&optional indent) + "Go to the beginning of next clause below in buffer according to INDENT. + +Optional INDENT: honor indentation +Return position if clause found, nil otherwise." + (interactive) + (py-down-base 'py-clause-re indent)) + +(defalias 'py-block-or-clause-down 'py-down-block-or-clause) +(defun py-down-block-or-clause (&optional indent) + "Go to the beginning of next block-or-clause below in buffer according to INDENT. + +Optional INDENT: honor indentation +Return position if block-or-clause found, nil otherwise." + (interactive) + (py-down-base 'py-block-or-clause-re indent)) + +(defalias 'py-def-down 'py-down-def) +(defun py-down-def (&optional indent) + "Go to the beginning of next def below in buffer according to INDENT. + +Optional INDENT: honor indentation +Return position if def found, nil otherwise." + (interactive) + (py-down-base 'py-def-re indent)) + +(defalias 'py-def-or-class-down 'py-down-def-or-class) +(defun py-down-def-or-class (&optional indent) + "Go to the beginning of next def-or-class below in buffer according to INDENT. + +Optional INDENT: honor indentation +Return position if def-or-class found, nil otherwise." + (interactive) + (py-down-base 'py-def-or-class-re indent)) + +(defalias 'py-minor-block-down 'py-down-minor-block) +(defun py-down-minor-block (&optional indent) + "Go to the beginning of next minor-block below in buffer according to INDENT. + +Optional INDENT: honor indentation +Return position if minor-block found, nil otherwise." + (interactive) + (py-down-base 'py-minor-block-re indent)) + +(defun py-up-block-bol (&optional indent) + "Go to the beginning of next block upwards in buffer according to INDENT. + +Go to beginning of line. +Return position if block found, nil otherwise." + (interactive) + (py-up-base 'py-block-re indent) + (progn (beginning-of-line)(point))) + +(defun py-up-class-bol (&optional indent) + "Go to the beginning of next class upwards in buffer according to INDENT. + +Go to beginning of line. +Return position if class found, nil otherwise." + (interactive) + (py-up-base 'py-class-re indent) + (progn (beginning-of-line)(point))) + +(defun py-up-clause-bol (&optional indent) + "Go to the beginning of next clause upwards in buffer according to INDENT. + +Go to beginning of line. +Return position if clause found, nil otherwise." + (interactive) + (py-up-base 'py-clause-re indent) + (progn (beginning-of-line)(point))) + +(defun py-up-block-or-clause-bol (&optional indent) + "Go to the beginning of next block-or-clause upwards in buffer according to INDENT. + +Go to beginning of line. +Return position if block-or-clause found, nil otherwise." + (interactive) + (py-up-base 'py-block-or-clause-re indent) + (progn (beginning-of-line)(point))) + +(defun py-up-def-bol (&optional indent) + "Go to the beginning of next def upwards in buffer according to INDENT. + +Go to beginning of line. +Return position if def found, nil otherwise." + (interactive) + (py-up-base 'py-def-re indent) + (progn (beginning-of-line)(point))) + +(defun py-up-def-or-class-bol (&optional indent) + "Go to the beginning of next def-or-class upwards in buffer according to INDENT. + +Go to beginning of line. +Return position if def-or-class found, nil otherwise." + (interactive) + (py-up-base 'py-def-or-class-re indent) + (progn (beginning-of-line)(point))) + +(defun py-up-minor-block-bol (&optional indent) + "Go to the beginning of next minor-block upwards in buffer according to INDENT. + +Go to beginning of line. +Return position if minor-block found, nil otherwise." + (interactive) + (py-up-base 'py-minor-block-re indent) + (progn (beginning-of-line)(point))) + +(defun py-down-block-bol (&optional indent) + "Go to the beginning of next block below in buffer according to INDENT. + +Go to beginning of line +Optional INDENT: honor indentation +Return position if block found, nil otherwise " + (interactive) + (py-down-base 'py-block-re indent t) + (progn (beginning-of-line)(point))) + +(defun py-down-class-bol (&optional indent) + "Go to the beginning of next class below in buffer according to INDENT. + +Go to beginning of line +Optional INDENT: honor indentation +Return position if class found, nil otherwise " + (interactive) + (py-down-base 'py-class-re indent t) + (progn (beginning-of-line)(point))) + +(defun py-down-clause-bol (&optional indent) + "Go to the beginning of next clause below in buffer according to INDENT. + +Go to beginning of line +Optional INDENT: honor indentation +Return position if clause found, nil otherwise " + (interactive) + (py-down-base 'py-clause-re indent t) + (progn (beginning-of-line)(point))) + +(defun py-down-block-or-clause-bol (&optional indent) + "Go to the beginning of next block-or-clause below in buffer according to INDENT. + +Go to beginning of line +Optional INDENT: honor indentation +Return position if block-or-clause found, nil otherwise " + (interactive) + (py-down-base 'py-block-or-clause-re indent t) + (progn (beginning-of-line)(point))) + +(defun py-down-def-bol (&optional indent) + "Go to the beginning of next def below in buffer according to INDENT. + +Go to beginning of line +Optional INDENT: honor indentation +Return position if def found, nil otherwise " + (interactive) + (py-down-base 'py-def-re indent t) + (progn (beginning-of-line)(point))) + +(defun py-down-def-or-class-bol (&optional indent) + "Go to the beginning of next def-or-class below in buffer according to INDENT. + +Go to beginning of line +Optional INDENT: honor indentation +Return position if def-or-class found, nil otherwise " + (interactive) + (py-down-base 'py-def-or-class-re indent t) + (progn (beginning-of-line)(point))) + +(defun py-down-minor-block-bol (&optional indent) + "Go to the beginning of next minor-block below in buffer according to INDENT. + +Go to beginning of line +Optional INDENT: honor indentation +Return position if minor-block found, nil otherwise " + (interactive) + (py-down-base 'py-minor-block-re indent t) + (progn (beginning-of-line)(point))) + +;; 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-components-extended-executes + + +(defun py-execute-block (&optional shell dedicated fast split switch proc) + "Send block at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-switch (&optional shell dedicated fast split proc) + "Send block at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-no-switch (&optional shell dedicated fast split proc) + "Send block at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-dedicated (&optional shell fast split switch proc) + "Send block at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-dedicated-switch (&optional shell fast split proc) + "Send block at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython (&optional dedicated fast split switch proc) + "Send block at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython-switch (&optional dedicated fast split proc) + "Send block at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython-no-switch (&optional dedicated fast split proc) + "Send block at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython-dedicated (&optional fast split switch proc) + "Send block at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython-dedicated-switch (&optional fast split proc) + "Send block at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython2.7 (&optional dedicated fast split switch proc) + "Send block at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython2.7-switch (&optional dedicated fast split proc) + "Send block at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send block at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython2.7-dedicated (&optional fast split switch proc) + "Send block at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython2.7-dedicated-switch (&optional fast split proc) + "Send block at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython3 (&optional dedicated fast split switch proc) + "Send block at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython3-switch (&optional dedicated fast split proc) + "Send block at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython3-no-switch (&optional dedicated fast split proc) + "Send block at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython3-dedicated (&optional fast split switch proc) + "Send block at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-ipython3-dedicated-switch (&optional fast split proc) + "Send block at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-jython (&optional dedicated fast split switch proc) + "Send block at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-jython-switch (&optional dedicated fast split proc) + "Send block at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-jython-no-switch (&optional dedicated fast split proc) + "Send block at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-jython-dedicated (&optional fast split switch proc) + "Send block at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-jython-dedicated-switch (&optional fast split proc) + "Send block at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python (&optional dedicated fast split switch proc) + "Send block at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'block 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'block 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python-dedicated (&optional fast split switch proc) + "Send block at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python-dedicated-switch (&optional fast split proc) + "Send block at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python2 (&optional dedicated fast split switch proc) + "Send block at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python2-switch (&optional dedicated fast split proc) + "Send block at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python2-no-switch (&optional dedicated fast split proc) + "Send block at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python2-dedicated (&optional fast split switch proc) + "Send block at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python2-dedicated-switch (&optional fast split proc) + "Send block at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python3 (&optional dedicated fast split switch proc) + "Send block at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python3-switch (&optional dedicated fast split proc) + "Send block at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python3-no-switch (&optional dedicated fast split proc) + "Send block at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python3-dedicated (&optional fast split switch proc) + "Send block at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-python3-dedicated-switch (&optional fast split proc) + "Send block at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause (&optional shell dedicated fast split switch proc) + "Send block-or-clause at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-switch (&optional shell dedicated fast split proc) + "Send block-or-clause at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-no-switch (&optional shell dedicated fast split proc) + "Send block-or-clause at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-dedicated (&optional shell fast split switch proc) + "Send block-or-clause at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-dedicated-switch (&optional shell fast split proc) + "Send block-or-clause at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython (&optional dedicated fast split switch proc) + "Send block-or-clause at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython-switch (&optional dedicated fast split proc) + "Send block-or-clause at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython-no-switch (&optional dedicated fast split proc) + "Send block-or-clause at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython-dedicated (&optional fast split switch proc) + "Send block-or-clause at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython-dedicated-switch (&optional fast split proc) + "Send block-or-clause at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython2.7 (&optional dedicated fast split switch proc) + "Send block-or-clause at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython2.7-switch (&optional dedicated fast split proc) + "Send block-or-clause at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send block-or-clause at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython2.7-dedicated (&optional fast split switch proc) + "Send block-or-clause at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython2.7-dedicated-switch (&optional fast split proc) + "Send block-or-clause at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython3 (&optional dedicated fast split switch proc) + "Send block-or-clause at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython3-switch (&optional dedicated fast split proc) + "Send block-or-clause at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython3-no-switch (&optional dedicated fast split proc) + "Send block-or-clause at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython3-dedicated (&optional fast split switch proc) + "Send block-or-clause at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-ipython3-dedicated-switch (&optional fast split proc) + "Send block-or-clause at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-jython (&optional dedicated fast split switch proc) + "Send block-or-clause at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-jython-switch (&optional dedicated fast split proc) + "Send block-or-clause at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-jython-no-switch (&optional dedicated fast split proc) + "Send block-or-clause at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-jython-dedicated (&optional fast split switch proc) + "Send block-or-clause at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-jython-dedicated-switch (&optional fast split proc) + "Send block-or-clause at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python (&optional dedicated fast split switch proc) + "Send block-or-clause at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python-dedicated (&optional fast split switch proc) + "Send block-or-clause at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python-dedicated-switch (&optional fast split proc) + "Send block-or-clause at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python2 (&optional dedicated fast split switch proc) + "Send block-or-clause at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python2-switch (&optional dedicated fast split proc) + "Send block-or-clause at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python2-no-switch (&optional dedicated fast split proc) + "Send block-or-clause at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python2-dedicated (&optional fast split switch proc) + "Send block-or-clause at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python2-dedicated-switch (&optional fast split proc) + "Send block-or-clause at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python3 (&optional dedicated fast split switch proc) + "Send block-or-clause at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python3-switch (&optional dedicated fast split proc) + "Send block-or-clause at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python3-no-switch (&optional dedicated fast split proc) + "Send block-or-clause at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python3-dedicated (&optional fast split switch proc) + "Send block-or-clause at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-block-or-clause-python3-dedicated-switch (&optional fast split proc) + "Send block-or-clause at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'block-or-clause 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-buffer (&optional shell dedicated fast split switch proc) + "Send buffer at point to interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + (shell (or shell (py-choose-shell))) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to unique interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to IPython interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to IPython unique interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to IPython interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to IPython unique interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to IPython interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to IPython unique interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to Jython interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to Jython unique interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to Python2 interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to Python2 unique interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to Python3 interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send buffer at point to Python3 unique interpreter." + (interactive) + (let ((py-master-file (or py-master-file (py-fetch-py-master-file))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "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))) + (wholebuf t) + filename buffer) + (when py-master-file + (setq 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) + "Send class at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-switch (&optional shell dedicated fast split proc) + "Send class at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-no-switch (&optional shell dedicated fast split proc) + "Send class at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'class shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-dedicated (&optional shell fast split switch proc) + "Send class at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-dedicated-switch (&optional shell fast split proc) + "Send class at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython (&optional dedicated fast split switch proc) + "Send class at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython-switch (&optional dedicated fast split proc) + "Send class at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython-no-switch (&optional dedicated fast split proc) + "Send class at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython-dedicated (&optional fast split switch proc) + "Send class at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython-dedicated-switch (&optional fast split proc) + "Send class at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython2.7 (&optional dedicated fast split switch proc) + "Send class at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython2.7-switch (&optional dedicated fast split proc) + "Send class at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send class at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython2.7-dedicated (&optional fast split switch proc) + "Send class at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython2.7-dedicated-switch (&optional fast split proc) + "Send class at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython3 (&optional dedicated fast split switch proc) + "Send class at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython3-switch (&optional dedicated fast split proc) + "Send class at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython3-no-switch (&optional dedicated fast split proc) + "Send class at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython3-dedicated (&optional fast split switch proc) + "Send class at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-ipython3-dedicated-switch (&optional fast split proc) + "Send class at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-jython (&optional dedicated fast split switch proc) + "Send class at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-jython-switch (&optional dedicated fast split proc) + "Send class at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-jython-no-switch (&optional dedicated fast split proc) + "Send class at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-jython-dedicated (&optional fast split switch proc) + "Send class at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-jython-dedicated-switch (&optional fast split proc) + "Send class at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python (&optional dedicated fast split switch proc) + "Send class at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'class 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'class 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python-dedicated (&optional fast split switch proc) + "Send class at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python-dedicated-switch (&optional fast split proc) + "Send class at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python2 (&optional dedicated fast split switch proc) + "Send class at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python2-switch (&optional dedicated fast split proc) + "Send class at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python2-no-switch (&optional dedicated fast split proc) + "Send class at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python2-dedicated (&optional fast split switch proc) + "Send class at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python2-dedicated-switch (&optional fast split proc) + "Send class at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python3 (&optional dedicated fast split switch proc) + "Send class at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python3-switch (&optional dedicated fast split proc) + "Send class at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python3-no-switch (&optional dedicated fast split proc) + "Send class at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python3-dedicated (&optional fast split switch proc) + "Send class at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-class-python3-dedicated-switch (&optional fast split proc) + "Send class at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'class 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause (&optional shell dedicated fast split switch proc) + "Send clause at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-switch (&optional shell dedicated fast split proc) + "Send clause at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-no-switch (&optional shell dedicated fast split proc) + "Send clause at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-dedicated (&optional shell fast split switch proc) + "Send clause at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-dedicated-switch (&optional shell fast split proc) + "Send clause at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython (&optional dedicated fast split switch proc) + "Send clause at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython-switch (&optional dedicated fast split proc) + "Send clause at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython-no-switch (&optional dedicated fast split proc) + "Send clause at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython-dedicated (&optional fast split switch proc) + "Send clause at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython-dedicated-switch (&optional fast split proc) + "Send clause at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython2.7 (&optional dedicated fast split switch proc) + "Send clause at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython2.7-switch (&optional dedicated fast split proc) + "Send clause at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send clause at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython2.7-dedicated (&optional fast split switch proc) + "Send clause at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython2.7-dedicated-switch (&optional fast split proc) + "Send clause at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython3 (&optional dedicated fast split switch proc) + "Send clause at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython3-switch (&optional dedicated fast split proc) + "Send clause at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython3-no-switch (&optional dedicated fast split proc) + "Send clause at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython3-dedicated (&optional fast split switch proc) + "Send clause at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-ipython3-dedicated-switch (&optional fast split proc) + "Send clause at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-jython (&optional dedicated fast split switch proc) + "Send clause at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-jython-switch (&optional dedicated fast split proc) + "Send clause at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-jython-no-switch (&optional dedicated fast split proc) + "Send clause at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-jython-dedicated (&optional fast split switch proc) + "Send clause at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-jython-dedicated-switch (&optional fast split proc) + "Send clause at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python (&optional dedicated fast split switch proc) + "Send clause at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'clause 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'clause 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python-dedicated (&optional fast split switch proc) + "Send clause at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python-dedicated-switch (&optional fast split proc) + "Send clause at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python2 (&optional dedicated fast split switch proc) + "Send clause at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python2-switch (&optional dedicated fast split proc) + "Send clause at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python2-no-switch (&optional dedicated fast split proc) + "Send clause at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python2-dedicated (&optional fast split switch proc) + "Send clause at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python2-dedicated-switch (&optional fast split proc) + "Send clause at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python3 (&optional dedicated fast split switch proc) + "Send clause at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python3-switch (&optional dedicated fast split proc) + "Send clause at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python3-no-switch (&optional dedicated fast split proc) + "Send clause at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python3-dedicated (&optional fast split switch proc) + "Send clause at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-clause-python3-dedicated-switch (&optional fast split proc) + "Send clause at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'clause 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def (&optional shell dedicated fast split switch proc) + "Send def at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-switch (&optional shell dedicated fast split proc) + "Send def at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-no-switch (&optional shell dedicated fast split proc) + "Send def at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-dedicated (&optional shell fast split switch proc) + "Send def at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-dedicated-switch (&optional shell fast split proc) + "Send def at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython (&optional dedicated fast split switch proc) + "Send def at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython-switch (&optional dedicated fast split proc) + "Send def at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython-no-switch (&optional dedicated fast split proc) + "Send def at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython-dedicated (&optional fast split switch proc) + "Send def at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython-dedicated-switch (&optional fast split proc) + "Send def at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython2.7 (&optional dedicated fast split switch proc) + "Send def at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython2.7-switch (&optional dedicated fast split proc) + "Send def at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send def at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython2.7-dedicated (&optional fast split switch proc) + "Send def at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython2.7-dedicated-switch (&optional fast split proc) + "Send def at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython3 (&optional dedicated fast split switch proc) + "Send def at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython3-switch (&optional dedicated fast split proc) + "Send def at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython3-no-switch (&optional dedicated fast split proc) + "Send def at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython3-dedicated (&optional fast split switch proc) + "Send def at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-ipython3-dedicated-switch (&optional fast split proc) + "Send def at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-jython (&optional dedicated fast split switch proc) + "Send def at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-jython-switch (&optional dedicated fast split proc) + "Send def at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-jython-no-switch (&optional dedicated fast split proc) + "Send def at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-jython-dedicated (&optional fast split switch proc) + "Send def at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-jython-dedicated-switch (&optional fast split proc) + "Send def at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python (&optional dedicated fast split switch proc) + "Send def at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'def 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'def 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python-dedicated (&optional fast split switch proc) + "Send def at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python-dedicated-switch (&optional fast split proc) + "Send def at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python2 (&optional dedicated fast split switch proc) + "Send def at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python2-switch (&optional dedicated fast split proc) + "Send def at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python2-no-switch (&optional dedicated fast split proc) + "Send def at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python2-dedicated (&optional fast split switch proc) + "Send def at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python2-dedicated-switch (&optional fast split proc) + "Send def at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python3 (&optional dedicated fast split switch proc) + "Send def at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python3-switch (&optional dedicated fast split proc) + "Send def at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python3-no-switch (&optional dedicated fast split proc) + "Send def at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python3-dedicated (&optional fast split switch proc) + "Send def at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-python3-dedicated-switch (&optional fast split proc) + "Send def at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class (&optional shell dedicated fast split switch proc) + "Send def-or-class at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-switch (&optional shell dedicated fast split proc) + "Send def-or-class at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-no-switch (&optional shell dedicated fast split proc) + "Send def-or-class at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-dedicated (&optional shell fast split switch proc) + "Send def-or-class at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-dedicated-switch (&optional shell fast split proc) + "Send def-or-class at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython (&optional dedicated fast split switch proc) + "Send def-or-class at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython-switch (&optional dedicated fast split proc) + "Send def-or-class at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython-no-switch (&optional dedicated fast split proc) + "Send def-or-class at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython-dedicated (&optional fast split switch proc) + "Send def-or-class at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython-dedicated-switch (&optional fast split proc) + "Send def-or-class at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython2.7 (&optional dedicated fast split switch proc) + "Send def-or-class at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython2.7-switch (&optional dedicated fast split proc) + "Send def-or-class at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send def-or-class at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython2.7-dedicated (&optional fast split switch proc) + "Send def-or-class at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython2.7-dedicated-switch (&optional fast split proc) + "Send def-or-class at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython3 (&optional dedicated fast split switch proc) + "Send def-or-class at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython3-switch (&optional dedicated fast split proc) + "Send def-or-class at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython3-no-switch (&optional dedicated fast split proc) + "Send def-or-class at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython3-dedicated (&optional fast split switch proc) + "Send def-or-class at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-ipython3-dedicated-switch (&optional fast split proc) + "Send def-or-class at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-jython (&optional dedicated fast split switch proc) + "Send def-or-class at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-jython-switch (&optional dedicated fast split proc) + "Send def-or-class at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-jython-no-switch (&optional dedicated fast split proc) + "Send def-or-class at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-jython-dedicated (&optional fast split switch proc) + "Send def-or-class at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-jython-dedicated-switch (&optional fast split proc) + "Send def-or-class at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python (&optional dedicated fast split switch proc) + "Send def-or-class at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python-dedicated (&optional fast split switch proc) + "Send def-or-class at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python-dedicated-switch (&optional fast split proc) + "Send def-or-class at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python2 (&optional dedicated fast split switch proc) + "Send def-or-class at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python2-switch (&optional dedicated fast split proc) + "Send def-or-class at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python2-no-switch (&optional dedicated fast split proc) + "Send def-or-class at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python2-dedicated (&optional fast split switch proc) + "Send def-or-class at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python2-dedicated-switch (&optional fast split proc) + "Send def-or-class at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python3 (&optional dedicated fast split switch proc) + "Send def-or-class at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python3-switch (&optional dedicated fast split proc) + "Send def-or-class at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python3-no-switch (&optional dedicated fast split proc) + "Send def-or-class at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python3-dedicated (&optional fast split switch proc) + "Send def-or-class at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-def-or-class-python3-dedicated-switch (&optional fast split proc) + "Send def-or-class at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'def-or-class 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression (&optional shell dedicated fast split switch proc) + "Send expression at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-switch (&optional shell dedicated fast split proc) + "Send expression at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-no-switch (&optional shell dedicated fast split proc) + "Send expression at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-dedicated (&optional shell fast split switch proc) + "Send expression at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-dedicated-switch (&optional shell fast split proc) + "Send expression at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython (&optional dedicated fast split switch proc) + "Send expression at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython-switch (&optional dedicated fast split proc) + "Send expression at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython-no-switch (&optional dedicated fast split proc) + "Send expression at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython-dedicated (&optional fast split switch proc) + "Send expression at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython-dedicated-switch (&optional fast split proc) + "Send expression at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython2.7 (&optional dedicated fast split switch proc) + "Send expression at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython2.7-switch (&optional dedicated fast split proc) + "Send expression at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send expression at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython2.7-dedicated (&optional fast split switch proc) + "Send expression at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython2.7-dedicated-switch (&optional fast split proc) + "Send expression at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython3 (&optional dedicated fast split switch proc) + "Send expression at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython3-switch (&optional dedicated fast split proc) + "Send expression at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython3-no-switch (&optional dedicated fast split proc) + "Send expression at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython3-dedicated (&optional fast split switch proc) + "Send expression at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-ipython3-dedicated-switch (&optional fast split proc) + "Send expression at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-jython (&optional dedicated fast split switch proc) + "Send expression at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-jython-switch (&optional dedicated fast split proc) + "Send expression at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-jython-no-switch (&optional dedicated fast split proc) + "Send expression at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-jython-dedicated (&optional fast split switch proc) + "Send expression at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-jython-dedicated-switch (&optional fast split proc) + "Send expression at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python (&optional dedicated fast split switch proc) + "Send expression at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'expression 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'expression 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python-dedicated (&optional fast split switch proc) + "Send expression at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python-dedicated-switch (&optional fast split proc) + "Send expression at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python2 (&optional dedicated fast split switch proc) + "Send expression at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python2-switch (&optional dedicated fast split proc) + "Send expression at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python2-no-switch (&optional dedicated fast split proc) + "Send expression at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python2-dedicated (&optional fast split switch proc) + "Send expression at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python2-dedicated-switch (&optional fast split proc) + "Send expression at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python3 (&optional dedicated fast split switch proc) + "Send expression at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python3-switch (&optional dedicated fast split proc) + "Send expression at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python3-no-switch (&optional dedicated fast split proc) + "Send expression at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python3-dedicated (&optional fast split switch proc) + "Send expression at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-expression-python3-dedicated-switch (&optional fast split proc) + "Send expression at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'expression 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent (&optional shell dedicated fast split switch proc) + "Send indent at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-switch (&optional shell dedicated fast split proc) + "Send indent at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-no-switch (&optional shell dedicated fast split proc) + "Send indent at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-dedicated (&optional shell fast split switch proc) + "Send indent at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-dedicated-switch (&optional shell fast split proc) + "Send indent at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython (&optional dedicated fast split switch proc) + "Send indent at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython-switch (&optional dedicated fast split proc) + "Send indent at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython-no-switch (&optional dedicated fast split proc) + "Send indent at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython-dedicated (&optional fast split switch proc) + "Send indent at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython-dedicated-switch (&optional fast split proc) + "Send indent at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython2.7 (&optional dedicated fast split switch proc) + "Send indent at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython2.7-switch (&optional dedicated fast split proc) + "Send indent at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send indent at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython2.7-dedicated (&optional fast split switch proc) + "Send indent at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython2.7-dedicated-switch (&optional fast split proc) + "Send indent at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython3 (&optional dedicated fast split switch proc) + "Send indent at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython3-switch (&optional dedicated fast split proc) + "Send indent at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython3-no-switch (&optional dedicated fast split proc) + "Send indent at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython3-dedicated (&optional fast split switch proc) + "Send indent at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-ipython3-dedicated-switch (&optional fast split proc) + "Send indent at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-jython (&optional dedicated fast split switch proc) + "Send indent at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-jython-switch (&optional dedicated fast split proc) + "Send indent at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-jython-no-switch (&optional dedicated fast split proc) + "Send indent at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-jython-dedicated (&optional fast split switch proc) + "Send indent at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-jython-dedicated-switch (&optional fast split proc) + "Send indent at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python (&optional dedicated fast split switch proc) + "Send indent at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'indent 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'indent 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python-dedicated (&optional fast split switch proc) + "Send indent at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python-dedicated-switch (&optional fast split proc) + "Send indent at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python2 (&optional dedicated fast split switch proc) + "Send indent at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python2-switch (&optional dedicated fast split proc) + "Send indent at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python2-no-switch (&optional dedicated fast split proc) + "Send indent at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python2-dedicated (&optional fast split switch proc) + "Send indent at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python2-dedicated-switch (&optional fast split proc) + "Send indent at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python3 (&optional dedicated fast split switch proc) + "Send indent at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python3-switch (&optional dedicated fast split proc) + "Send indent at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python3-no-switch (&optional dedicated fast split proc) + "Send indent at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python3-dedicated (&optional fast split switch proc) + "Send indent at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-indent-python3-dedicated-switch (&optional fast split proc) + "Send indent at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'indent 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line (&optional shell dedicated fast split switch proc) + "Send line at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-switch (&optional shell dedicated fast split proc) + "Send line at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-no-switch (&optional shell dedicated fast split proc) + "Send line at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'line shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-dedicated (&optional shell fast split switch proc) + "Send line at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-dedicated-switch (&optional shell fast split proc) + "Send line at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython (&optional dedicated fast split switch proc) + "Send line at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython-switch (&optional dedicated fast split proc) + "Send line at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython-no-switch (&optional dedicated fast split proc) + "Send line at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython-dedicated (&optional fast split switch proc) + "Send line at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython-dedicated-switch (&optional fast split proc) + "Send line at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython2.7 (&optional dedicated fast split switch proc) + "Send line at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython2.7-switch (&optional dedicated fast split proc) + "Send line at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send line at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython2.7-dedicated (&optional fast split switch proc) + "Send line at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython2.7-dedicated-switch (&optional fast split proc) + "Send line at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython3 (&optional dedicated fast split switch proc) + "Send line at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython3-switch (&optional dedicated fast split proc) + "Send line at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython3-no-switch (&optional dedicated fast split proc) + "Send line at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython3-dedicated (&optional fast split switch proc) + "Send line at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-ipython3-dedicated-switch (&optional fast split proc) + "Send line at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-jython (&optional dedicated fast split switch proc) + "Send line at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-jython-switch (&optional dedicated fast split proc) + "Send line at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-jython-no-switch (&optional dedicated fast split proc) + "Send line at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-jython-dedicated (&optional fast split switch proc) + "Send line at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-jython-dedicated-switch (&optional fast split proc) + "Send line at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python (&optional dedicated fast split switch proc) + "Send line at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'line 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'line 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python-dedicated (&optional fast split switch proc) + "Send line at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python-dedicated-switch (&optional fast split proc) + "Send line at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python2 (&optional dedicated fast split switch proc) + "Send line at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python2-switch (&optional dedicated fast split proc) + "Send line at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python2-no-switch (&optional dedicated fast split proc) + "Send line at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python2-dedicated (&optional fast split switch proc) + "Send line at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python2-dedicated-switch (&optional fast split proc) + "Send line at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python3 (&optional dedicated fast split switch proc) + "Send line at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python3-switch (&optional dedicated fast split proc) + "Send line at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python3-no-switch (&optional dedicated fast split proc) + "Send line at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python3-dedicated (&optional fast split switch proc) + "Send line at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-line-python3-dedicated-switch (&optional fast split proc) + "Send line at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'line 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block (&optional shell dedicated fast split switch proc) + "Send minor-block at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-switch (&optional shell dedicated fast split proc) + "Send minor-block at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-no-switch (&optional shell dedicated fast split proc) + "Send minor-block at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-dedicated (&optional shell fast split switch proc) + "Send minor-block at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-dedicated-switch (&optional shell fast split proc) + "Send minor-block at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython (&optional dedicated fast split switch proc) + "Send minor-block at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython-switch (&optional dedicated fast split proc) + "Send minor-block at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython-no-switch (&optional dedicated fast split proc) + "Send minor-block at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython-dedicated (&optional fast split switch proc) + "Send minor-block at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython-dedicated-switch (&optional fast split proc) + "Send minor-block at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython2.7 (&optional dedicated fast split switch proc) + "Send minor-block at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython2.7-switch (&optional dedicated fast split proc) + "Send minor-block at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send minor-block at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython2.7-dedicated (&optional fast split switch proc) + "Send minor-block at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython2.7-dedicated-switch (&optional fast split proc) + "Send minor-block at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython3 (&optional dedicated fast split switch proc) + "Send minor-block at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython3-switch (&optional dedicated fast split proc) + "Send minor-block at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython3-no-switch (&optional dedicated fast split proc) + "Send minor-block at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython3-dedicated (&optional fast split switch proc) + "Send minor-block at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-ipython3-dedicated-switch (&optional fast split proc) + "Send minor-block at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-jython (&optional dedicated fast split switch proc) + "Send minor-block at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-jython-switch (&optional dedicated fast split proc) + "Send minor-block at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-jython-no-switch (&optional dedicated fast split proc) + "Send minor-block at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-jython-dedicated (&optional fast split switch proc) + "Send minor-block at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-jython-dedicated-switch (&optional fast split proc) + "Send minor-block at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python (&optional dedicated fast split switch proc) + "Send minor-block at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python-dedicated (&optional fast split switch proc) + "Send minor-block at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python-dedicated-switch (&optional fast split proc) + "Send minor-block at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python2 (&optional dedicated fast split switch proc) + "Send minor-block at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python2-switch (&optional dedicated fast split proc) + "Send minor-block at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python2-no-switch (&optional dedicated fast split proc) + "Send minor-block at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python2-dedicated (&optional fast split switch proc) + "Send minor-block at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python2-dedicated-switch (&optional fast split proc) + "Send minor-block at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python3 (&optional dedicated fast split switch proc) + "Send minor-block at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python3-switch (&optional dedicated fast split proc) + "Send minor-block at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python3-no-switch (&optional dedicated fast split proc) + "Send minor-block at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python3-dedicated (&optional fast split switch proc) + "Send minor-block at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-minor-block-python3-dedicated-switch (&optional fast split proc) + "Send minor-block at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'minor-block 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph (&optional shell dedicated fast split switch proc) + "Send paragraph at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-switch (&optional shell dedicated fast split proc) + "Send paragraph at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-no-switch (&optional shell dedicated fast split proc) + "Send paragraph at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-dedicated (&optional shell fast split switch proc) + "Send paragraph at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-dedicated-switch (&optional shell fast split proc) + "Send paragraph at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython (&optional dedicated fast split switch proc) + "Send paragraph at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython-switch (&optional dedicated fast split proc) + "Send paragraph at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython-no-switch (&optional dedicated fast split proc) + "Send paragraph at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython-dedicated (&optional fast split switch proc) + "Send paragraph at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython-dedicated-switch (&optional fast split proc) + "Send paragraph at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython2.7 (&optional dedicated fast split switch proc) + "Send paragraph at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython2.7-switch (&optional dedicated fast split proc) + "Send paragraph at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send paragraph at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython2.7-dedicated (&optional fast split switch proc) + "Send paragraph at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython2.7-dedicated-switch (&optional fast split proc) + "Send paragraph at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython3 (&optional dedicated fast split switch proc) + "Send paragraph at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython3-switch (&optional dedicated fast split proc) + "Send paragraph at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython3-no-switch (&optional dedicated fast split proc) + "Send paragraph at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython3-dedicated (&optional fast split switch proc) + "Send paragraph at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-ipython3-dedicated-switch (&optional fast split proc) + "Send paragraph at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-jython (&optional dedicated fast split switch proc) + "Send paragraph at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-jython-switch (&optional dedicated fast split proc) + "Send paragraph at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-jython-no-switch (&optional dedicated fast split proc) + "Send paragraph at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-jython-dedicated (&optional fast split switch proc) + "Send paragraph at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-jython-dedicated-switch (&optional fast split proc) + "Send paragraph at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python (&optional dedicated fast split switch proc) + "Send paragraph at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python-dedicated (&optional fast split switch proc) + "Send paragraph at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python-dedicated-switch (&optional fast split proc) + "Send paragraph at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python2 (&optional dedicated fast split switch proc) + "Send paragraph at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python2-switch (&optional dedicated fast split proc) + "Send paragraph at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python2-no-switch (&optional dedicated fast split proc) + "Send paragraph at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python2-dedicated (&optional fast split switch proc) + "Send paragraph at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python2-dedicated-switch (&optional fast split proc) + "Send paragraph at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python3 (&optional dedicated fast split switch proc) + "Send paragraph at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python3-switch (&optional dedicated fast split proc) + "Send paragraph at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python3-no-switch (&optional dedicated fast split proc) + "Send paragraph at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python3-dedicated (&optional fast split switch proc) + "Send paragraph at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-paragraph-python3-dedicated-switch (&optional fast split proc) + "Send paragraph at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'paragraph 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression (&optional shell dedicated fast split switch proc) + "Send partial-expression at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-switch (&optional shell dedicated fast split proc) + "Send partial-expression at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-no-switch (&optional shell dedicated fast split proc) + "Send partial-expression at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-dedicated (&optional shell fast split switch proc) + "Send partial-expression at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-dedicated-switch (&optional shell fast split proc) + "Send partial-expression at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython (&optional dedicated fast split switch proc) + "Send partial-expression at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython-switch (&optional dedicated fast split proc) + "Send partial-expression at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython-no-switch (&optional dedicated fast split proc) + "Send partial-expression at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython-dedicated (&optional fast split switch proc) + "Send partial-expression at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython-dedicated-switch (&optional fast split proc) + "Send partial-expression at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython2.7 (&optional dedicated fast split switch proc) + "Send partial-expression at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython2.7-switch (&optional dedicated fast split proc) + "Send partial-expression at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send partial-expression at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython2.7-dedicated (&optional fast split switch proc) + "Send partial-expression at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython2.7-dedicated-switch (&optional fast split proc) + "Send partial-expression at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython3 (&optional dedicated fast split switch proc) + "Send partial-expression at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython3-switch (&optional dedicated fast split proc) + "Send partial-expression at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython3-no-switch (&optional dedicated fast split proc) + "Send partial-expression at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython3-dedicated (&optional fast split switch proc) + "Send partial-expression at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-ipython3-dedicated-switch (&optional fast split proc) + "Send partial-expression at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-jython (&optional dedicated fast split switch proc) + "Send partial-expression at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-jython-switch (&optional dedicated fast split proc) + "Send partial-expression at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-jython-no-switch (&optional dedicated fast split proc) + "Send partial-expression at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-jython-dedicated (&optional fast split switch proc) + "Send partial-expression at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-jython-dedicated-switch (&optional fast split proc) + "Send partial-expression at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python (&optional dedicated fast split switch proc) + "Send partial-expression at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python-dedicated (&optional fast split switch proc) + "Send partial-expression at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python-dedicated-switch (&optional fast split proc) + "Send partial-expression at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python2 (&optional dedicated fast split switch proc) + "Send partial-expression at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python2-switch (&optional dedicated fast split proc) + "Send partial-expression at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python2-no-switch (&optional dedicated fast split proc) + "Send partial-expression at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python2-dedicated (&optional fast split switch proc) + "Send partial-expression at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python2-dedicated-switch (&optional fast split proc) + "Send partial-expression at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python3 (&optional dedicated fast split switch proc) + "Send partial-expression at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python3-switch (&optional dedicated fast split proc) + "Send partial-expression at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python3-no-switch (&optional dedicated fast split proc) + "Send partial-expression at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python3-dedicated (&optional fast split switch proc) + "Send partial-expression at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-partial-expression-python3-dedicated-switch (&optional fast split proc) + "Send partial-expression at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'partial-expression 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-region (beg end &optional shell dedicated fast split switch proc) + "Send region at point to interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to unique interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to unique interpreter and switch to result." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython unique interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython unique interpreter and switch to result." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython unique interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython unique interpreter and switch to result." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython unique interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to IPython unique interpreter and switch to result." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Jython interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Jython unique interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Jython unique interpreter and switch to result." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive "r") + (let (wholebuf) + (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) + "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") + (let (wholebuf) + (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) + "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") + (let (wholebuf) + (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) + "Send region at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Python2 interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Python2 unique interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Python2 unique interpreter and switch to result." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Python3 interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Python3 unique interpreter." + (interactive "r") + (let (wholebuf) + (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) + "Send region at point to Python3 unique interpreter and switch to result." + (interactive "r") + (let (wholebuf) + (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) + "Send statement at point to interpreter." + (interactive) + (let (wholebuf) + ;; (macroexpand + (py--execute-prepare 'statement shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-switch (&optional shell dedicated fast split proc) + "Send statement at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-no-switch (&optional shell dedicated fast split proc) + "Send statement at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-dedicated (&optional shell fast split switch proc) + "Send statement at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-dedicated-switch (&optional shell fast split proc) + "Send statement at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython (&optional dedicated fast split switch proc) + "Send statement at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython-switch (&optional dedicated fast split proc) + "Send statement at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython-no-switch (&optional dedicated fast split proc) + "Send statement at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython-dedicated (&optional fast split switch proc) + "Send statement at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython-dedicated-switch (&optional fast split proc) + "Send statement at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython2.7 (&optional dedicated fast split switch proc) + "Send statement at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython2.7-switch (&optional dedicated fast split proc) + "Send statement at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send statement at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython2.7-dedicated (&optional fast split switch proc) + "Send statement at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython2.7-dedicated-switch (&optional fast split proc) + "Send statement at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython3 (&optional dedicated fast split switch proc) + "Send statement at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython3-switch (&optional dedicated fast split proc) + "Send statement at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython3-no-switch (&optional dedicated fast split proc) + "Send statement at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython3-dedicated (&optional fast split switch proc) + "Send statement at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-ipython3-dedicated-switch (&optional fast split proc) + "Send statement at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-jython (&optional dedicated fast split switch proc) + "Send statement at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-jython-switch (&optional dedicated fast split proc) + "Send statement at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-jython-no-switch (&optional dedicated fast split proc) + "Send statement at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-jython-dedicated (&optional fast split switch proc) + "Send statement at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-jython-dedicated-switch (&optional fast split proc) + "Send statement at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python (&optional dedicated fast split switch proc) + "Send statement at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'statement 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'statement 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python-dedicated (&optional fast split switch proc) + "Send statement at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python-dedicated-switch (&optional fast split proc) + "Send statement at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python2 (&optional dedicated fast split switch proc) + "Send statement at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python2-switch (&optional dedicated fast split proc) + "Send statement at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python2-no-switch (&optional dedicated fast split proc) + "Send statement at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python2-dedicated (&optional fast split switch proc) + "Send statement at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python2-dedicated-switch (&optional fast split proc) + "Send statement at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python3 (&optional dedicated fast split switch proc) + "Send statement at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python3-switch (&optional dedicated fast split proc) + "Send statement at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python3-no-switch (&optional dedicated fast split proc) + "Send statement at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python3-dedicated (&optional fast split switch proc) + "Send statement at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-statement-python3-dedicated-switch (&optional fast split proc) + "Send statement at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'statement 'python3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level (&optional shell dedicated fast split switch proc) + "Send top-level at point to interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level shell dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-switch (&optional shell dedicated fast split proc) + "Send top-level at point to interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level shell dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-no-switch (&optional shell dedicated fast split proc) + "Send top-level at point to interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level shell dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-dedicated (&optional shell fast split switch proc) + "Send top-level at point to unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level shell t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-dedicated-switch (&optional shell fast split proc) + "Send top-level at point to unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level shell t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython (&optional dedicated fast split switch proc) + "Send top-level at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython-switch (&optional dedicated fast split proc) + "Send top-level at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython-no-switch (&optional dedicated fast split proc) + "Send top-level at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython-dedicated (&optional fast split switch proc) + "Send top-level at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython-dedicated-switch (&optional fast split proc) + "Send top-level at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython2.7 (&optional dedicated fast split switch proc) + "Send top-level at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython2.7 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython2.7-switch (&optional dedicated fast split proc) + "Send top-level at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython2.7 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython2.7-no-switch (&optional dedicated fast split proc) + "Send top-level at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython2.7 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython2.7-dedicated (&optional fast split switch proc) + "Send top-level at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython2.7 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython2.7-dedicated-switch (&optional fast split proc) + "Send top-level at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython2.7 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython3 (&optional dedicated fast split switch proc) + "Send top-level at point to IPython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython3-switch (&optional dedicated fast split proc) + "Send top-level at point to IPython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython3-no-switch (&optional dedicated fast split proc) + "Send top-level at point to IPython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython3-dedicated (&optional fast split switch proc) + "Send top-level at point to IPython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-ipython3-dedicated-switch (&optional fast split proc) + "Send top-level at point to IPython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'ipython3 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-jython (&optional dedicated fast split switch proc) + "Send top-level at point to Jython interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'jython dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-jython-switch (&optional dedicated fast split proc) + "Send top-level at point to Jython interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'jython dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-jython-no-switch (&optional dedicated fast split proc) + "Send top-level at point to Jython interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'jython dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-jython-dedicated (&optional fast split switch proc) + "Send top-level at point to Jython unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'jython t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-jython-dedicated-switch (&optional fast split proc) + "Send top-level at point to Jython unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'jython t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python (&optional dedicated fast split switch proc) + "Send top-level at point to default interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'top-level 'python dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python-no-switch (&optional dedicated fast split proc) + "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) + (let (wholebuf) + (py--execute-prepare 'top-level 'python dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python-dedicated (&optional fast split switch proc) + "Send top-level at point to default unique interpreter. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python-dedicated-switch (&optional fast split proc) + "Send top-level at point to default unique interpreter and switch to result. + +For ‘default’ see value of ‘py-shell-name’" + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python2 (&optional dedicated fast split switch proc) + "Send top-level at point to Python2 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python2 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python2-switch (&optional dedicated fast split proc) + "Send top-level at point to Python2 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python2 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python2-no-switch (&optional dedicated fast split proc) + "Send top-level at point to Python2 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python2 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python2-dedicated (&optional fast split switch proc) + "Send top-level at point to Python2 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python2 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python2-dedicated-switch (&optional fast split proc) + "Send top-level at point to Python2 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python2 t 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python3 (&optional dedicated fast split switch proc) + "Send top-level at point to Python3 interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python3 dedicated switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python3-switch (&optional dedicated fast split proc) + "Send top-level at point to Python3 interpreter. + +Switch to output buffer. Ignores ‘py-switch-buffers-on-execute-p’." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python3 dedicated 'switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python3-no-switch (&optional dedicated fast split proc) + "Send top-level at point to Python3 interpreter. + +Keep current buffer. Ignores ‘py-switch-buffers-on-execute-p’ " + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python3 dedicated 'no-switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python3-dedicated (&optional fast split switch proc) + "Send top-level at point to Python3 unique interpreter." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python3 t switch nil nil nil fast proc wholebuf split))) + +(defun py-execute-top-level-python3-dedicated-switch (&optional fast split proc) + "Send top-level at point to Python3 unique interpreter and switch to result." + (interactive) + (let (wholebuf) + (py--execute-prepare 'top-level 'python3 t 'switch nil nil 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 (and beg 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 (pps) + (interactive "*") + (save-excursion + (let* ((strg-start-pos (when (nth 3 pps) (nth 8 pps))) + (n8pps (or strg-start-pos + (when + (equal (string-to-syntax "|") + (syntax-after (point))) + (and + (< 0 (skip-chars-forward "\"'")) + (nth 3 (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 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) 10) + (and + (cdr delimiters-style) + (or (newline (cdr delimiters-style)) t))) + (py-indent-line nil t) + (goto-char orig)) + +(defun py--fill-docstring-base (thisbeg thisend style multi-line-p beg end py-current-indent orig) + ;; (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 (py-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 (py-empty-line-p) (newline 1))) + (py--fill-fix-end thisend orig delimiters-style))) + +(defun py--fill-docstring-last-line (thisend beg end multi-line-p) + (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))) + +(defun py--fill-docstring-first-line (beg end) + "Refill first line after newline maybe. " + (fill-region-as-paragraph beg (line-end-position) nil t t) + (save-excursion + (end-of-line) + (unless (eobp) + (forward-line 1) + (back-to-indentation) + (unless (or (< end (point)) (py-empty-line-p)) + (newline 1) + ;;(fill-region (line-beginning-position) end) + )))) + +(defun py--fill-docstring (justify style docstring orig py-current-indent &optional beg end) + ;; Delete spaces after/before string fence + (py--string-fence-delete-spaces docstring) + (let* ((thisbeg (copy-marker (or beg docstring))) + (thisend (copy-marker + (or end + (progn + (goto-char thisbeg) + (py--skip-raw-string-front-fence) + (skip-syntax-forward "^\|") + (1+ (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 (<= (line-beginning-position) beg) + ;; (progn (goto-char beg) (member (char-after) (list ?\" ?\' ?u ?U ?r ?R))) + )) + (when (string-match (concat "^" py-labelled-re) (buffer-substring-no-properties beg end)) + (py-fill-labelled-string beg end)) + (when first-line-p + (py--fill-docstring-first-line beg end)) + (when (save-excursion (goto-char end) + (or (member (char-after) (list ?\" ?\')) + (member (char-before) (list ?\" ?\')))) + (py--fill-docstring-last-line thisend beg end multi-line-p)) + (fill-region beg end justify t t) + (py--fill-docstring-base thisbeg thisend style multi-line-p beg end py-current-indent orig))) + +(defun py-fill-string (&optional justify style docstring pps) + "String fill function for `py-fill-paragraph'. +JUSTIFY should be used (if applicable) as in `fill-paragraph'. + +Fill according to `py-docstring-style' " + (interactive "*") + (let* ((justify (or justify (if current-prefix-arg 'full t))) + (style (or style py-docstring-style)) + (pps (or pps (parse-partial-sexp (point-min) (point)))) + (indent + ;; set inside tqs + ;; (save-excursion (and (nth 3 pps) (goto-char (nth 8 pps)) (current-indentation))) + nil) + (orig (copy-marker (point))) + ;; (docstring (or docstring (py--in-or-behind-or-before-a-docstring pps))) + (docstring (cond (docstring + (if (not (number-or-marker-p docstring)) + (py--in-or-behind-or-before-a-docstring pps)) + docstring) + (t (py--in-or-behind-or-before-a-docstring pps)))) + (beg (and (nth 3 pps) (nth 8 pps))) + (tqs (progn (and beg (goto-char beg) (looking-at "\"\"\"\\|'''") (setq indent (current-column))))) + (end (copy-marker (if tqs + (or + (progn (ignore-errors (forward-sexp))(and (< orig (point)) (point))) + (goto-char orig) + (line-end-position)) + (or (progn (goto-char beg) (ignore-errors (forward-sexp))(and (< orig (point)) (point))) + (goto-char orig) + (line-end-position)))))) + (goto-char orig) + (when beg + (if docstring + (py--fill-docstring justify style docstring orig indent beg end) + (save-restriction + (if (not tqs) + (if (py-preceding-line-backslashed-p) + (progn + (setq end (copy-marker (line-end-position))) + (narrow-to-region (line-beginning-position) end) + (fill-region (line-beginning-position) end justify t) + (when (< 1 (py-count-lines)) + (py--continue-lines-region (point-min) end))) + (narrow-to-region beg end) + (fill-region beg end justify t) + (when + ;; counting in narrowed buffer + (< 1 (py-count-lines)) + (py--continue-lines-region beg end))) + (fill-region beg end justify))))))) + +(defun py--continue-lines-region (beg end) + (save-excursion + (goto-char beg) + (while (< (line-end-position) end) + (end-of-line) + (unless (py-escaped-p) (insert-and-inherit 32) (insert-and-inherit 92)) + (ignore-errors (forward-line 1))))) + +(defun py-fill-paragraph (&optional justify pps beg end tqs) + (interactive "*") + (save-excursion + (save-restriction + (window-configuration-to-register py-windows-config-register) + (let* ((tqs tqs) + (pps (or pps (parse-partial-sexp (point-min) (point)))) + (docstring (unless (not py-docstring-style) (py--in-or-behind-or-before-a-docstring pps))) + (fill-column py-comment-fill-column) + (in-string (nth 3 pps))) + (cond ((or (nth 4 pps) + (and (bolp) (looking-at "[ \t]*#[# \t]*"))) + (py-fill-comment)) + (docstring + (setq fill-column py-docstring-fill-column) + (py--fill-docstring justify py-docstring-style docstring (point) + ;; current indentation + (save-excursion (and (nth 3 pps) (goto-char (nth 8 pps)) (current-indentation))))) + (t + (let* ((beg (or beg (save-excursion + (if (looking-at paragraph-start) + (point) + (backward-paragraph) + (when (looking-at paragraph-start) + (point)))) + (and (nth 3 pps) (nth 8 pps)))) + (end (or end + (when beg + (save-excursion + (or + (and in-string + (progn + (goto-char (nth 8 pps)) + (setq tqs (looking-at "\"\"\"\\|'''")) + (forward-sexp) (point))) + (progn + (forward-paragraph) + (when (looking-at paragraph-separate) + (point))))))))) + (and beg end (fill-region beg end)) + (when (and in-string (not tqs)) + (py--continue-lines-region beg end)))))) + (jump-to-register py-windows-config-register)))) + +(defun py-fill-string-or-comment () + "Serve auto-fill-mode" + (unless (< (current-column) fill-column) + (let ((pps (parse-partial-sexp (point-min) (point)))) + (if (nth 3 pps) + (py-fill-string nil nil nil pps) + ;; (py-fill-comment pps) + (do-auto-fill) + )))) + +;; 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. +Return indentation reached +Optional COUNT: COUNT times ‘py-indent-offset’ +Optional START: region beginning +Optional END: region end" + (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. +Return indentation reached +Optional COUNT: COUNT times ‘py-indent-offset’ +Optional BEG: region beginning +Optional END: region end" + (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) + (save-excursion + (goto-char + (region-beginning)))) + (t (line-beginning-position)))) + (end (cond (end) + ((use-region-p) + (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 (intern-soft (concat "py-backward-" form))) + (endform (intern-soft (concat "py-forward-" form))) + (orig (copy-marker (point))) + (beg (cond (beg) + ((use-region-p) + (save-excursion + (goto-char (region-beginning)) + (line-beginning-position))) + (t (save-excursion + (funcall begform) + (line-beginning-position))))) + (end (cond (end) + ((use-region-p) + (region-end)) + (t (funcall 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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. + +Return 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 given + +(defun py-execute-file-ipython (filename) + "Send file to IPython interpreter" + (interactive "fFile: ") + (py--execute-prepare file "ipython" nil nil nil nil filename)) + +(defun py-execute-file-ipython2.7 (filename) + "Send file to IPython2.7 interpreter" + (interactive "fFile: ") + (py--execute-prepare file "ipython2.7" nil nil nil nil filename)) + +(defun py-execute-file-ipython3 (filename) + "Send file to IPython3 interpreter" + (interactive "fFile: ") + (py--execute-prepare file "ipython3" nil nil nil nil filename)) + +(defun py-execute-file-jython (filename) + "Send file to Jython interpreter" + (interactive "fFile: ") + (py--execute-prepare file "jython" nil nil nil nil filename)) + +(defun py-execute-file-python (filename) + "Send file to Python interpreter" + (interactive "fFile: ") + (py--execute-prepare file "python" nil nil nil nil filename)) + +(defun py-execute-file-python2 (filename) + "Send file to Python2 interpreter" + (interactive "fFile: ") + (py--execute-prepare file "python2" nil nil nil nil filename)) + +(defun py-execute-file-python3 (filename) + "Send file to Python3 interpreter" + (interactive "fFile: ") + (py--execute-prepare file "python3" nil nil nil nil filename)) + +(defun py-execute-file-pypy (filename) + "Send file to PyPy interpreter" + (interactive "fFile: ") + (py--execute-prepare file "pypy" nil nil nil nil filename)) + +(defun py-execute-file-ipython-dedicated (filename) + "Send file to a dedicatedIPython interpreter" + (interactive "fFile: ") + (py--execute-prepare file "ipython" t nil nil nil filename)) + +(defun py-execute-file-ipython2.7-dedicated (filename) + "Send file to a dedicatedIPython2.7 interpreter" + (interactive "fFile: ") + (py--execute-prepare file "ipython2.7" t nil nil nil filename)) + +(defun py-execute-file-ipython3-dedicated (filename) + "Send file to a dedicatedIPython3 interpreter" + (interactive "fFile: ") + (py--execute-prepare file "ipython3" t nil nil nil filename)) + +(defun py-execute-file-jython-dedicated (filename) + "Send file to a dedicatedJython interpreter" + (interactive "fFile: ") + (py--execute-prepare file "jython" t nil nil nil filename)) + +(defun py-execute-file-python-dedicated (filename) + "Send file to a dedicatedPython interpreter" + (interactive "fFile: ") + (py--execute-prepare file "python" t nil nil nil filename)) + +(defun py-execute-file-python2-dedicated (filename) + "Send file to a dedicatedPython2 interpreter" + (interactive "fFile: ") + (py--execute-prepare file "python2" t nil nil nil filename)) + +(defun py-execute-file-python3-dedicated (filename) + "Send file to a dedicatedPython3 interpreter" + (interactive "fFile: ") + (py--execute-prepare file "python3" t nil nil nil filename)) + +(defun py-execute-file-pypy-dedicated (filename) + "Send file to a dedicatedPyPy interpreter" + (interactive "fFile: ") + (py--execute-prepare file "pypy" t nil nil nil filename)) + +;; 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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +(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 'interactive)))) + +;; python-components-forms-code.el ends here +;; python-components-fast-forms + +;; Process forms fast + +(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-shell-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 (strg &optional proc output-buffer result no-output argprompt args dedicated shell exception-buffer) + (interactive + (list (read-string "Python command: "))) + (py-send-string strg proc result no-output nil output-buffer t argprompt args dedicated shell exception-buffer)) + +(defun py--fast-send-string-no-output-intern (strg proc limit output-buffer no-output) + (let (erg) + (with-current-buffer output-buffer + (when py-debug-p (switch-to-buffer (current-buffer))) + ;; (erase-buffer) + (process-send-string proc strg) + (or (string-match "\n$" strg) + (process-send-string proc "\n") + (goto-char (point-max)) + ) + (cond (no-output + ;; (erase-buffer) + (delete-region (point-min) (line-beginning-position)) + ) + (result + (if + (setq erg (py--fetch-result output-buffer limit strg)) + (setq py-result (py--filter-result erg)) + (dotimes (_ 3) (unless (setq erg (py--fetch-result output-buffer limit))(sit-for 1 t))) + (or (py--fetch-result output-buffer limit)) + (error "py-fast-send-string: py--fetch-result: no result"))))))) + +(defun py--fast-send-string-no-output (strg &optional proc output-buffer result) + (py-fast-send-string strg proc output-buffer result t)) + +(defun py--send-to-fast-process (strg proc output-buffer result) + "Called inside of ‘py--execute-base-intern’. + +Optional STRG PROC OUTPUT-BUFFER RETURN" + (let ((output-buffer (or output-buffer (process-buffer proc))) + (inhibit-read-only t)) + ;; (switch-to-buffer (current-buffer)) + (with-current-buffer output-buffer + ;; (erase-buffer) + (py-fast-send-string strg + proc + output-buffer result)))) + +(defun py-execute-buffer-fast (&optional shell dedicated split switch proc) + "Send accessible part of buffer to a Python interpreter. + +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SPLIT: split buffers after executing +Optional SWITCH: switch to output buffer after executing +Optional PROC: select an already running process for executing" + (interactive) + (py-execute-buffer shell dedicated t split switch proc)) + +(defalias 'py-process-region-fast 'py-execute-region-fast) +(defun py-execute-region-fast (beg end &optional shell dedicated split switch proc) + "Send region to a Python interpreter. + +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SPLIT: split buffers after executing +Optional SWITCH: switch to output buffer after executing +Optional PROC: select an already running process for executing" + (interactive "r") + (let ((py-fast-process-p t)) + (py-execute-region beg end shell dedicated t split switch proc))) + +(defun py-execute-block-fast (&optional shell dedicated switch beg end file) + "Process block at point by a Python interpreter. + +Output buffer not in comint-mode, displays \"Fast\" by default +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SWITCH: switch to output buffer after executing +Optional File: execute through running a temp-file" + (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. + +Output buffer not in comint-mode, displays \"Fast\" by default +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SWITCH: switch to output buffer after executing +Optional File: execute through running a temp-file" + (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. + +Output buffer not in comint-mode, displays \"Fast\" by default +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SWITCH: switch to output buffer after executing +Optional File: execute through running a temp-file" + (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. + +Output buffer not in comint-mode, displays \"Fast\" by default +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SWITCH: switch to output buffer after executing +Optional File: execute through running a temp-file" + (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. + +Output buffer not in comint-mode, displays \"Fast\" by default +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SWITCH: switch to output buffer after executing +Optional File: execute through running a temp-file" + (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. + +Output buffer not in comint-mode, displays \"Fast\" by default +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SWITCH: switch to output buffer after executing +Optional File: execute through running a temp-file" + (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. + +Output buffer not in comint-mode, displays \"Fast\" by default +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SWITCH: switch to output buffer after executing +Optional File: execute through running a temp-file" + (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. + +Output buffer not in comint-mode, displays \"Fast\" by default +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SWITCH: switch to output buffer after executing +Optional File: execute through running a temp-file" + (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. + +Output buffer not in comint-mode, displays \"Fast\" by default +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SWITCH: switch to output buffer after executing +Optional File: execute through running a temp-file" + (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. + +Output buffer not in comint-mode, displays \"Fast\" by default +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SWITCH: switch to output buffer after executing +Optional File: execute through running a temp-file" + (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. + +Output buffer not in comint-mode, displays \"Fast\" by default +Optional SHELL: Selecte a Python-shell(VERSION) as py-shell-name +Optional DEDICATED: run in a dedicated process +Optional SWITCH: switch to output buffer after executing +Optional File: execute through running a temp-file" + (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-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-show () + "Remove invisibility of existing form at point." + (interactive) + (with-silent-modifications + (save-excursion + (back-to-indentation) + (let ((end (next-overlay-change (point)))) + (hs-discard-overlays (point) end))))) + +(defun py-show-all () + "Remove invisibility of hidden forms in buffer." + (interactive) + (save-excursion + (goto-char (point-min)) + (let (end) + (while (and (not (eobp)) (setq end (next-overlay-change (point)))) + (hs-discard-overlays (point) end) + (goto-char end))))) + +(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-hide-block-or-clause () + "Hide block-or-clause at point." + (interactive) + (py-hide-base 'block-or-clause)) + +(defun py-hide-class () + "Hide class at point." + (interactive) + (py-hide-base 'class)) + +(defun py-hide-clause () + "Hide clause at point." + (interactive) + (py-hide-base 'clause)) + +(defun py-hide-comment () + "Hide comment at point." + (interactive) + (py-hide-base 'comment)) + +(defun py-hide-def () + "Hide def at point." + (interactive) + (py-hide-base 'def)) + +(defun py-hide-def-or-class () + "Hide def-or-class at point." + (interactive) + (py-hide-base 'def-or-class)) + +(defun py-hide-elif-block () + "Hide elif-block at point." + (interactive) + (py-hide-base 'elif-block)) + +(defun py-hide-else-block () + "Hide else-block at point." + (interactive) + (py-hide-base 'else-block)) + +(defun py-hide-except-block () + "Hide except-block at point." + (interactive) + (py-hide-base 'except-block)) + +(defun py-hide-expression () + "Hide expression at point." + (interactive) + (py-hide-base 'expression)) + +(defun py-hide-for-block () + "Hide for-block at point." + (interactive) + (py-hide-base 'for-block)) + +(defun py-hide-if-block () + "Hide if-block at point." + (interactive) + (py-hide-base 'if-block)) + +(defun py-hide-indent () + "Hide indent at point." + (interactive) + (py-hide-base 'indent)) + +(defun py-hide-line () + "Hide line at point." + (interactive) + (py-hide-base 'line)) + +(defun py-hide-minor-block () + "Hide minor-block at point." + (interactive) + (py-hide-base 'minor-block)) + +(defun py-hide-paragraph () + "Hide paragraph at point." + (interactive) + (py-hide-base 'paragraph)) + +(defun py-hide-partial-expression () + "Hide partial-expression at point." + (interactive) + (py-hide-base 'partial-expression)) + +(defun py-hide-section () + "Hide section at point." + (interactive) + (py-hide-base 'section)) + +(defun py-hide-statement () + "Hide statement at point." + (interactive) + (py-hide-base 'statement)) + +(defun py-hide-top-level () + "Hide top-level at point." + (interactive) + (py-hide-base 'top-level)) + +(defun py-dynamically-hide-indent () + (interactive) + (py-show) + (py-hide-indent)) + +(defun py-dynamically-hide-further-indent (&optional arg) + (interactive "P") + (if (eq 4 (prefix-numeric-value arg)) + (py-show) + (py-show) + (py-forward-indent) + (py-hide-indent))) + +;; python-components-hide-show.el ends here +;; python-components-fast-complete + +(defun py--fast-completion-get-completions (input process completion-code buffer) + "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 + (format completion-code input) process buffer t))) + (when (> (length completions) 2) + (split-string completions "^'\\|^\"\\|;\\|'$\\|\"$" t)))) + +(defun py--fast--do-completion-at-point (process imports input code buffer) + "Do completion at point for PROCESS." + ;; send setup-code + (let (py-store-result-p) + (when imports + ;; (message "%s" imports) + (py-fast-send-string imports process buffer nil t))) + (let* ((completion + (py--fast-completion-get-completions input process code buffer))) + (sit-for 0.1) + (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."))) + ((null completion) + (and py-verbose-p (message "py--fast--do-completion-at-point %s" "Don't see a completion")) + (set-window-configuration py-last-window-configuration)) + ((and completion + (or (and (listp completion) + (string= input (car completion))) + (and (stringp completion) + (string= input completion)))) + (set-window-configuration py-last-window-configuration)) + ((and completion (stringp completion) (not (string= input completion))) + (progn (delete-char (- (length input))) + (insert completion) + ;; (move-marker orig (point)) + ;; minibuffer.el expects a list + )) + (t (py--try-completion input completion))))) + +(defun py--fast-complete-base (shell word imports) + (let* (py-split-window-on-execute py-switch-buffers-on-execute-p + (shell (or shell "python")) + (buffer (py-shell nil nil nil shell nil t)) + (proc (get-buffer-process buffer)) + (code (if (string-match "[Ii][Pp]ython*" shell) + (py-set-ipython-completion-command-string shell) + py-shell-module-completion-code))) + (py--python-send-completion-setup-code buffer) + (py--fast--do-completion-at-point proc imports word code buffer))) + +(defun py-fast-complete (&optional shell beg end word) + "Complete word before point, if any. + +Use `py-fast-process' " + (interactive "*") + (window-configuration-to-register py-windows-config-register) + (setq py-last-window-configuration + (current-window-configuration)) + (py-shell-complete shell beg end word t) + ) + +;; python-components-intern + +;; Keymap + +(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--forward-string-maybe (&optional start) + "Go to the end of string. + +Expects START position of string +Return position of moved, nil otherwise." + (let ((orig (point))) + (when start (goto-char start) + (when (looking-at "\"\"\"\\|'''") + (goto-char (1- (match-end 0)))) + (forward-sexp) + ;; maybe at the inner fence + (when (looking-at "\"\"\\|''") + (goto-char (match-end 0))) + (and (< orig (point)) (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) + (let ((file-name (or file-name + (and + (ignore-errors (file-readable-p (buffer-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)) + file-name))) + +(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-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--update-lighter (shell) + "Select lighter for mode-line display" + (setq py-modeline-display + (cond + ;; ((eq 2 (prefix-numeric-value argprompt)) + ;; py-python2-command-args) + ((string-match "^[^-]+3" shell) + py-python3-modeline-display) + ((string-match "^[^-]+2" shell) + py-python2-modeline-display) + ((string-match "^.[Ii]" shell) + py-ipython-modeline-display) + ((string-match "^.[Jj]" shell) + py-jython-modeline-display) + (t + python-mode-modeline-display)))) + +(defun py--start-fast-process (shell buffer args) + (apply 'start-process shell buffer shell + args)) + + ;; (switch-to-buffer buffer) + ;; (setq py-output-buffer buffer)) + +(defun py-shell (&optional argprompt args dedicated shell buffer fast exception-buffer split switch internal) + "Connect process to BUFFER. + +Start an interpreter according to ‘py-shell-name’ or SHELL. + +Optional ARGPROMPT: with \\[universal-argument] start in a new +dedicated shell. + +Optional ARGS: Specify other than default command args. + +Optional DEDICATED: start in a new dedicated shell. +Optional string SHELL overrides default ‘py-shell-name’. +Optional string BUFFER allows a name, the Python process is connected to +Optional FAST: no fontification in process-buffer. +Optional EXCEPTION-BUFFER: point to error. +Optional SPLIT: see var ‘py-split-window-on-execute’ +Optional SWITCH: see var ‘py-switch-buffers-on-execute-p’ +Optional INTERNAL shell will be invisible for users + +Reusing existing processes: For a given buffer and same values, +if a process is already running for it, it will do nothing. + +Runs the hook `py-shell-mode-hook' after +`comint-mode-hook' is run. (Type \\[describe-mode] in the +process buffer for a list of commands.)" + (interactive "p") + (let* ((interactivep (and argprompt (eq 1 (prefix-numeric-value argprompt)))) + (fast (unless (eq major-mode 'org-mode) + (or fast py-fast-process-p))) + (dedicated (or (eq 4 (prefix-numeric-value argprompt)) dedicated py-dedicated-process-p)) + (shell (or shell (py-choose-shell))) + (args (or args (py--provide-command-args shell fast))) + (py-use-local-default (py--determine-local-default)) + (buffer-name + (or buffer + (py--choose-buffer-name shell dedicated fast))) + (proc (get-buffer-process buffer-name)) + (done nil) + (delay nil) + (buffer + (or + (and (ignore-errors (process-buffer proc)) + (save-excursion (with-current-buffer (process-buffer proc) + ;; point might not be left there + (goto-char (point-max)) + (push-mark) + (setq done t) + (process-buffer proc)))) + (save-excursion + (py-shell-with-environment + (if fast + (process-buffer (apply 'start-process shell buffer-name shell args)) + (apply #'make-comint-in-buffer shell buffer-name + shell nil args)))))) + ;; (py-shell-prompt-detect-p (or (string-match "^\*IP" buffer) py-shell-prompt-detect-p)) + ) + (setq py-output-buffer (buffer-name (if python-mode-v5-behavior-p py-output-buffer buffer))) + (unless done + (with-current-buffer buffer + (setq delay (py--which-delay-process-dependent buffer-name)) + (unless fast + (when interactivep + (cond ((string-match "^.I" buffer-name) + (message "Waiting according to ‘py-ipython-send-delay:’ %s" delay)) + ((string-match "^.+3" buffer-name) + (message "Waiting according to ‘py-python3-send-delay:’ %s" delay)))) + (setq py-modeline-display (py--update-lighter buffer-name)) + (sit-for delay t)))) + (if (setq proc (get-buffer-process buffer)) + (progn + (with-current-buffer buffer + (unless fast (py-shell-mode)) + (and internal (set-process-query-on-exit-flag proc nil))) + (when (or interactivep + (or switch py-switch-buffers-on-execute-p py-split-window-on-execute)) + (py--shell-manage-windows buffer exception-buffer split (or interactivep switch))) + buffer) + (error (concat "py-shell:" (py--fetch-error py-output-buffer)))))) + +(defun py-load-named-shells () + (interactive) + (dolist (ele py-known-shells) + (let ((erg (py-install-named-shells-fix-doc ele))) + (eval (fset (car (read-from-string ele)) (car + (read-from-string (concat "(lambda (&optional dedicated args) \"Start a ‘" erg "’ interpreter. +Optional DEDICATED: with \\\\[universal-argument] start in a new +dedicated shell. +Optional ARGS overriding ‘py-" ele "-command-args’. + +Calls ‘py-shell’ +\" + (interactive \"p\") (py-shell dedicated args nil \""ele"\"))"))))))) + (when (functionp (car (read-from-string (car-safe py-known-shells)))) + (when py-verbose-p (message "py-load-named-shells: %s" "installed named-shells")))) + +;; (py-load-named-shells) + +(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))) + +(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 + +(unless (member '(".pym'" . python-mode) auto-mode-alist) + (push (cons (purecopy "\\.pym\\'") 'python-mode) auto-mode-alist)) + +(unless (member '(".pyc'" . python-mode) auto-mode-alist) + (push (cons (purecopy "\\.pyc\\'") 'python-mode) auto-mode-alist)) + +;; Pyrex Source +(unless (member '(".pyx'" . python-mode) auto-mode-alist) + (push (cons (purecopy "\\.pyx\\'") 'python-mode) auto-mode-alist)) + +;; Python Optimized Code +(unless (member '(".pyo'" . python-mode) auto-mode-alist) + (push (cons (purecopy "\\.pyo\\'") 'python-mode) auto-mode-alist)) + +;; Pyrex Definition File +(unless (member '(".pxd'" . python-mode) auto-mode-alist) + (push (cons (purecopy "\\.pxd\\'") 'python-mode) auto-mode-alist)) + +;; Python Repository +(unless (member '(".pyr'" . python-mode) auto-mode-alist) + (push (cons (purecopy "\\.pyr\\'") 'python-mode) auto-mode-alist)) + +;; Python Stub file +;; https://www.python.org/dev/peps/pep-0484/#stub-files +(unless (member '(".pyi'" . python-mode) auto-mode-alist) + (push (cons (purecopy "\\.pyi\\'") 'python-mode) auto-mode-alist)) + +;; Python Path Configuration +(unless (member '(".pth'" . python-mode) auto-mode-alist) + (push (cons (purecopy "\\.pth\\'") 'python-mode) auto-mode-alist)) + +;; Python Wheels +(unless (member '(".whl'" . python-mode) auto-mode-alist) + (push (cons (purecopy "\\.whl\\'") 'python-mode) auto-mode-alist)) + +(unless (member '("!#[ ]*/.*[jp]ython[0-9.]*" . python-mode) magic-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--arglist-indent (nesting &optional 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) + (1+ (+ (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. + +When interactively called, copy and message it" + (interactive) + (let ((erg (with-syntax-table + py-dotted-expression-syntax-table + (current-word)))) + (when (interactive-p) (kill-new erg) + (message "%s" erg)) + erg)) + +(defun py-kill-buffer-unconditional (buffer) + "Kill buffer unconditional, kill buffer-process if existing. " + (interactive + (list (current-buffer))) + ;; (when (bufferp buffer) + (ignore-errors (with-current-buffer buffer + (let (kill-buffer-query-functions set-buffer-modified-p) + (ignore-errors (kill-process (get-buffer-process buffer))) + (ignore-errors (kill-buffer 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-*$"))) + +(defun py--computer-closing-inner-list () + "Compute indentation according to py-closing-list-dedents-bos." + (if py-closing-list-dedents-bos + (+ (current-indentation) py-indent-offset) + (1+ (current-column)))) + +(defun py--compute-closing-outer-list () + "Compute indentation according to py-closing-list-dedents-bos." + (if py-closing-list-dedents-bos + (current-indentation) + (+ (current-indentation) py-indent-offset))) + +(defun py-compute-indentation--according-to-list-style () + "See ‘py-indent-list-style’ + +Choices are: + +'line-up-with-first-element (default) +'one-level-to-beginning-of-statement +'one-level-from-opener" + (save-excursion + (pcase py-indent-list-style + (`line-up-with-first-element + (1+ (current-column))) + (`one-level-to-beginning-of-statement + (py-backward-statement) + (+ py-indent-offset (current-indentation))) + (`one-level-from-first-element + (+ 1 py-indent-offset (current-column)))))) + +(defun py-compute-indentation-closing-list (pps) + (cond + ((< 1 (nth 0 pps)) + (goto-char (nth 1 pps)) + ;; reach the outer list + (goto-char (nth 1 (parse-partial-sexp (point-min) (point)))) + (py--computer-closing-inner-list)) + ;; just close an maybe outer list + ((eq 1 (nth 0 pps)) + (goto-char (nth 1 pps)) + (py-compute-indentation--according-to-list-style)))) + +(defun py-compute-list-indent--according-to-circumstance (pps line origline) + (and (nth 1 pps) (goto-char (nth 1 pps))) + (if (looking-at "[({\\[][ \t]*$") + (+ (current-indentation) py-indent-offset) + (if (or line (< (py-count-lines) origline)) + (py-compute-indentation--according-to-list-style)))) + +(defun py-compute-indentation-in-list (pps line closing orig origline) + (if closing + (py-compute-indentation-closing-list pps) + (cond ((and (not line) (looking-back py-assignment-re (line-beginning-position))) + (py--fetch-indent-statement-above orig)) + ;; (py-compute-indentation--according-to-list-style pps iact orig origline line nesting repeat indent-offset liep) + (t (when (looking-back "[ \t]*\\(\\s(\\)" (line-beginning-position)) + (goto-char (match-beginning 1)) + (setq pps (parse-partial-sexp (point-min) (point)))) + (py-compute-list-indent--according-to-circumstance pps line origline))))) + +(defun py-compute-comment-indentation (pps iact orig origline closing line nesting repeat indent-offset liep) + (cond ((nth 8 pps) + (goto-char (nth 8 pps)) + (cond ((and line (eq (current-column) (current-indentation))) + (current-indentation)) + ((and (eq liep (line-end-position))py-indent-honors-inline-comment) + (current-column)) + ((py--line-backward-maybe) + (setq line t) + (skip-chars-backward " \t") + (py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep)) + (t (if py-indent-comments + (progn + (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 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)))) + +(defun py-close-according-to-style (pps) + (goto-char (nth 1 pps)) + (if py-closing-list-dedents-bos + (current-indentation) + (pcase py-indent-list-style + (`line-up-with-first-element + (1+ (current-column))) + (`one-level-to-beginning-of-statement + (+ (current-indentation) py-indent-offset)) + (`one-level-from-first-element + (+ 1 (current-column) py-indent-offset))))) + +(defun py-compute-indentation--at-closer-maybe (pps) + (save-excursion + (when (looking-back "^[ \t]*\\(\\s)\\)" (line-beginning-position)) + (forward-char -1) + (setq pps (parse-partial-sexp (point-min) (point)))) + (when (and (nth 1 pps) + (looking-at "[ \t]*\\(\\s)\\)")(nth 0 pps)) + (if + ;; beyond list start? + (< (progn (unless (bobp) (forward-line -1) (line-beginning-position))) (nth 1 pps)) + (py-close-according-to-style pps) + (if py-closing-list-dedents-bos + (- (current-indentation) py-indent-offset) + (current-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 + (let* ((orig (or orig (copy-marker (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 (or line (not (eq origline (py-count-lines (point-min) (point)))))) + ;; (line line) + (pps (progn + (unless (eq (current-indentation) (current-column))(skip-chars-backward " " (line-beginning-position))) + ;; (when (eq 5 (car (syntax-after (1- (point))))) + ;; (forward-char -1)) + (parse-partial-sexp (point-min) (point)))) + (closing + (or closing + ;; returns update pps + (py-compute-indentation--at-closer-maybe pps))) + ;; in a recursive call already + (repeat (if repeat + (setq repeat (1+ repeat)) + 0)) + ;; nesting: started nesting a list + (nesting nesting) + (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 + ;; (switch-to-buffer (current-buffer)) + (insert-buffer-substring cubuf (match-end 0) orig) + (python-mode) + (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 (closing) + ((bobp) + (cond ((eq liep (line-end-position)) + 0) + ;; - ((looking-at py-outdent-re) + ;; - (+ (or indent-offset (and py-smart-indentation (py-guess-indent-offset)) py-indent-offset) (current-indentation))) + ((and line (looking-at py-block-or-clause-re)) + py-indent-offset) + ((looking-at py-outdent-re) + (+ (or indent-offset (and py-smart-indentation (py-guess-indent-offset)) py-indent-offset) (current-indentation))) + (t + (current-indentation)))) + ;; (cond ((eq liep (line-end-position)) + ;; 0) + ;; ((looking-at py-outdent-re) + ;; (+ (or indent-offset (and py-smart-indentation (py-guess-indent-offset)) py-indent-offset) (current-indentation))) + ;; (t + ;; (current-indentation))) + ;; in string + ((and (nth 3 pps) (nth 8 pps)) + (cond + ((py--docstring-p (nth 8 pps)) + (save-excursion + ;; (goto-char (match-beginning 0)) + (back-to-indentation) + (if (looking-at "[uUrR]?\"\"\"\\|[uUrR]?'''") + (progn + (skip-chars-backward " \t\r\n\f") + (back-to-indentation) + (if (looking-at py-def-or-class-re) + (+ (current-column) py-indent-offset) + (current-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 + ((or + (nth 8 pps) + (and + (looking-at (concat "[ \t]*" comment-start)) + (looking-back "^[ \t]*" (line-beginning-position))(not line)) + (and (eq 11 (syntax-after (point))) line py-indent-honors-inline-comment)) + (py-compute-comment-indentation pps iact orig origline closing line nesting repeat indent-offset liep)) + ;; lists + ((nth 1 pps) + (if (< (nth 1 pps) (line-beginning-position)) + (py-compute-indentation-in-list pps line closing orig origline) + (back-to-indentation) + (py-compute-indentation iact orig origline closing line nesting repeat indent-offset liep))) + ((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-indent-line-above 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) + (or indent-offset (and py-smart-indentation (py-guess-indent-offset)) py-indent-offset) + (current-indentation))) + ((looking-at py-block-closing-keywords-re) + (- (current-indentation) (or indent-offset py-indent-offset))) + (t (current-column)))) + ((looking-at py-block-closing-keywords-re) + (if (< (line-end-position) orig) + ;; #80, Lines after return cannot be correctly indented + (if (looking-at "return[ \\t]*$") + (current-indentation) + (- (current-indentation) (or indent-offset py-indent-offset))) + (py-backward-block-or-clause) + (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-outdent-re) + ;; (and (py--backward-regexp 'py-block-or-clause-re) (current-indentation))) + (and (py--go-to-keyword 'py-block-or-clause-re nil nil t) (current-indentation))) + ((bobp) 0) + (t (save-excursion (skip-chars-backward " \t\r\n\f") + (if + (py--backward-regexp 'py-block-or-clause-re) + (+ py-indent-offset (current-indentation)) + 0))))) + ((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) (or indent-offset 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) + (+ (or indent-offset (and py-smart-indentation (py-guess-indent-offset)) py-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) (or indent-offset 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 (* py-indent-offset 99))) + (if (and (not indent-offset) 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-offset (py-guess-indent-offset)) + (or indent-offset py-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 py-verbose-p (message "%s" indent)) + indent)))))) + +(defun py-beginning-of-statement-p () + (interactive) + (save-restriction + (eq (point) + (save-excursion + (py-forward-statement) + (py-backward-statement))))) + +(defun py--fetch-indent-statement-above (orig) + "Report the preceding indent. " + (save-excursion + (goto-char orig) + (forward-line -1) + (end-of-line) + (skip-chars-backward " \t\r\n\f") + (back-to-indentation) + (if (or (looking-at comment-start)(py-beginning-of-statement-p)) + (current-indentation) + (py-backward-statement) + (current-indentation)))) + +(defun py--fetch-indent-line-above (&optional orig) + "Report the preceding indent. " + (save-excursion + (when orig (goto-char orig)) + (forward-line -1) + (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 (ignore-errors (looking-at (concat "[ \t]*" comment-start))) + (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))))) + 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--down-top-level (&optional regexp) + "Go to the end of a top-level form. + +When already at end, go to EOB." + (end-of-line) + (while (and (py--forward-regexp (or regexp "^[[:graph:]]")) + (save-excursion + (beginning-of-line) + (or + (looking-at py-clause-re) + (looking-at comment-start))))) + (beginning-of-line) + (and (looking-at regexp) (point))) + +(defun py--backward-empty-lines-or-comment () + "Travel backward" + (while + (or (< 0 (abs (skip-chars-backward " \t\r\n\f"))) + (py-backward-comment)))) + +(defun py--down-according-to-indent (regexp secondvalue &optional indent enforce-regexp) + "Return position if moved, nil otherwise. + +Optional ENFORCE-REGEXP: search for regexp only." + (unless (eobp) + (let* ((orig (point)) + (indent (or indent 0)) + done + (regexpvalue (if (member regexp (list 'py-def-re 'py-def-or-class-re 'py-class-re)) + (concat (symbol-value regexp) "\\|" (symbol-value 'py-decorator-re)) + (symbol-value regexp))) + (lastvalue (and secondvalue + (pcase regexp + (`py-try-re py-finally-re) + (`py-if-re py-else-re))))) + (while + (and + (not done) + (progn (end-of-line) + (cond (enforce-regexp + ;; using regexpvalue might stop behind global settings, missing the end of form + (re-search-forward (concat "^ \\{0,"(format "%s" indent) "\\}"regexpvalue) nil 'move 1)) + (t (re-search-forward (concat "^ \\{"(format "0,%s" indent) "\\}[[:alnum:]_@]+") nil 'move 1)))) + (or (progn (back-to-indentation) (py--forward-string-maybe (nth 8 (parse-partial-sexp orig (point))))) + (and secondvalue (looking-at secondvalue)) + (and lastvalue (looking-at lastvalue)) + (and (looking-at regexpvalue) (setq done t)) + (setq done t)))) + (and (< orig (point)) (point))))) + +(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--leave-backward-string-list-and-comment-maybe (pps) + (while (or (and (nth 8 pps) (goto-char (nth 8 pps))) + (and (nth 1 pps) (goto-char (nth 1 pps))) + (and (nth 4 pps) (goto-char (nth 4 pps)))) + ;; (back-to-indentation) + (when (or (looking-at comment-start)(member (char-after) (list ?\" ?'))) + (skip-chars-backward " \t\r\n\f")) + (setq pps (parse-partial-sexp (point-min) (point))))) + +(defun py--end-base-determine-secondvalue (regexp) + "Expects being at block-opener. + +REGEXP: a symbol" + (cond + ((eq regexp 'py-minor-block-re) + (cond ((looking-at py-else-re) + nil) + ((or (looking-at (concat py-try-re))) + (concat py-elif-re "\\|" py-else-re "\\|" py-except-re)) + ((or (looking-at (concat py-except-re "\\|" py-elif-re "\\|" py-if-re))) + (concat py-elif-re "\\|" py-else-re)))) + ((member regexp + (list + 'py-block-re + 'py-block-or-clause-re + 'py-clause-re + 'py-if-re + )) + (cond ((looking-at py-if-re) + (concat py-elif-re "\\|" py-else-re)) + ((looking-at py-elif-re) + (concat py-elif-re "\\|" py-else-re)) + ((looking-at py-else-re)) + ((looking-at py-try-re) + (concat py-except-re "\\|" py-else-re "\\|" py-finally-re)) + ((looking-at py-except-re) + (concat py-else-re "\\|" py-finally-re)) + ((looking-at py-finally-re) + nil))) + ((eq regexp 'py-for-re) nil) + ((eq regexp 'py-try-re) + (cond + ((looking-at py-try-re) + (concat py-except-re "\\|" py-else-re "\\|" py-finally-re)) + ((looking-at py-except-re) + (concat py-else-re "\\|" py-finally-re)) + ((looking-at py-finally-re)))))) + +(defun py--down-end-form () + "Return position." + (progn (py--backward-empty-lines-or-comment) + (point))) + +(defun py--refine-regexp-maybe (regexp) + "Use a more specific regexp if possible. " + (let ((regexpvalue (symbol-value regexp))) + (if (looking-at regexpvalue) + (setq regexp + (cond ((looking-at py-if-re) + 'py-if-re) + ((looking-at py-try-re) + 'py-try-re) + ((looking-at py-def-re) + 'py-def-re) + ((looking-at py-class-re) + 'py-class-re) + (t regexp))) + regexp))) + +(defun py--end-base (regexp &optional orig bol repeat) + "Used internal by functions going to the end FORM. + +Returns the indentation of FORM-start +Arg REGEXP, a symbol" + (unless (eobp) + (let ((orig (or orig (point)))) + (unless (eobp) + (unless (py-beginning-of-statement-p) + (py-beginning-of-statement)) + (let* (;; when at block-start, be specific + (regexp (py--refine-regexp-maybe regexp)) + (regexpvalue (symbol-value regexp)) + ;; (regexp (or regexp (symbol-value 'py-extended-block-or-clause-re))) + (repeat (or repeat 0)) + (indent (if + (looking-at regexpvalue) + (abs + (- (current-indentation) py-indent-offset)) + (current-indentation))) + ;; when at block-start, be specific + ;; return current-indentation, position and possibly needed clause-regexps (secondvalue) + (res + (cond + ((and (py-beginning-of-statement-p) + ;; (eq 0 (current-column)) + (or (looking-at regexpvalue) + (and (member regexp (list 'py-def-re 'py-def-or-class-re 'py-class-re)) + (looking-at py-decorator-re) + (py-down-def-or-class (current-indentation))) + (and (member regexp (list 'py-minor-block-re 'py-if-re 'py-for-re 'py-try-re)) + (looking-at py-minor-clause-re)))) + (list (current-indentation) (point) (py--end-base-determine-secondvalue regexp))) + ((looking-at regexpvalue) + (list (current-indentation) (point) (py--end-base-determine-secondvalue regexp))) + ((eq 0 (current-indentation)) + (py--down-according-to-indent regexp nil 0)) + ;; look upward + (t (py--go-to-keyword regexp)))) + (secondvalue (ignore-errors (nth 2 res))) + erg) + ;; (py-for-block-p (looking-at py-for-re)) + (setq indent (or (and res (car-safe res)) indent)) + (cond + (res (setq erg + (and + (py--down-according-to-indent regexp secondvalue (current-indentation)) + ;; (py--forward-regexp-keep-indent "^[ \t]*[[:alnum:]_]" (current-indentation)) + (py--down-end-form)))) + (t (unless (< 0 repeat) (goto-char orig)) + (py--forward-regexp (symbol-value regexp)) + (beginning-of-line) + (setq erg (and + (py--down-according-to-indent regexp secondvalue (current-indentation) t) + (py--down-end-form))))) + (cond ((< orig (point)) + (setq erg (point)) + (progn + (and erg bol (setq erg (py--beginning-of-line-form))) + (and erg (cons (current-indentation) erg)))) + ((eq (point) orig) + (unless (eobp) + (cond + ((and (< repeat 1) + (or + ;; looking next indent as part of body + (py--down-according-to-indent regexp secondvalue + indent + ;; if expected indent is 0, + ;; search for new start, + ;; search for regexp only + (eq 0 indent)) + (and + ;; next block-start downwards, reduce expected indent maybe + (setq indent (or (and (< 0 indent) (- indent py-indent-offset)) indent)) + (py--down-according-to-indent regexp secondvalue + indent t)))) + (py--end-base regexp orig bol (1+ repeat)))))) + ((< (point) orig) + (goto-char orig) + (when (py--down-according-to-indent regexp secondvalue nil t) + (py--end-base regexp (point) bol (1+ repeat)))))))))) + +(defun py--look-downward-for-beginning (regexp) + "When above any beginning of FORM, search downward. " + (let* ((orig (point)) + (erg orig) + pps) + (while (and (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) + (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 t)) + (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 lim (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-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)) + +(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--which-delay-process-dependent (buffer) + "Call a `py-ipython-send-delay' or `py-python-send-delay' according to process" + (if (string-match "^.[IJ]" buffer) + py-ipython-send-delay + py-python-send-delay)) + +(defun py-temp-file-name (strg) + (let* ((temporary-file-directory + (if (file-remote-p default-directory) + (concat (file-remote-p default-directory) "/tmp") + temporary-file-directory)) + (temp-file-name (make-temp-file "py"))) + + (with-temp-file temp-file-name + (insert strg) + (delete-trailing-whitespace)) + temp-file-name)) + +(defun py--report-end-marker (process) + ;; (message "py--report-end-marker in %s" (current-buffer)) + (if (derived-mode-p 'comint-mode) + (if (bound-and-true-p comint-last-prompt) + (car-safe comint-last-prompt) + (dotimes (_ 3) (when (not (bound-and-true-p comint-last-prompt)))(sit-for 1 t)) + (and (bound-and-true-p comint-last-prompt) + (car-safe comint-last-prompt))) + (if (markerp (process-mark process)) + (process-mark process) + (progn + (dotimes (_ 3) (when (not (markerp (process-mark process)))(sit-for 1 t))) + (process-mark process))))) + +(defun py--filter-result (strg) + "Set ‘py-result’ according to ‘py-fast-filter-re’. + +Remove trailing newline" + (string-trim + (replace-regexp-in-string + py-fast-filter-re + "" + (ansi-color-filter-apply strg)))) + +(defun py--cleanup-shell (orig buffer) + (with-current-buffer buffer + (with-silent-modifications + (sit-for py-python3-send-delay) + (when py-debug-p (switch-to-buffer (current-buffer))) + (delete-region orig (point-max))))) + +(defun py-shell--save-temp-file (strg) + (let* ((temporary-file-directory + (if (file-remote-p default-directory) + (concat (file-remote-p default-directory) "/tmp") + temporary-file-directory)) + (temp-file-name (make-temp-file "py")) + (coding-system-for-write (py-info-encoding))) + (with-temp-file temp-file-name + (insert strg) + (delete-trailing-whitespace)) + temp-file-name)) + +(defun py-shell-send-string (strg &optional process) + "Send STRING to Python PROCESS. + +Uses ‘comint-send-string’." + (interactive + (list (read-string "Python command: ") nil t)) + (let ((process (or process (py-shell-get-process)))) + (if (string-match ".\n+." strg) ;Multiline. + (let* ((temp-file-name (py-shell--save-temp-file strg)) + (file-name (or (buffer-file-name) temp-file-name))) + (py-shell-send-file file-name process temp-file-name t)) + (comint-send-string process strg) + (when (or (not (string-match "\n\\'" strg)) + (string-match "\n[ \t].*\n?\\'" strg)) + (comint-send-string process "\n"))))) + +(defun py-shell-output-filter (strg) + "Filter used in `py-shell-send-string-no-output' to grab output. +STRING is the output received to this point from the process. +This filter saves received output from the process in +`py-shell-output-filter-buffer' and stops receiving it after +detecting a prompt at the end of the buffer." + (let ((py-shell--prompt-calculated-output-regexp + (or py-shell--prompt-calculated-output-regexp (py-shell-prompt-set-calculated-regexps)))) + (setq + strg (ansi-color-filter-apply strg) + py-shell-output-filter-buffer + (concat py-shell-output-filter-buffer strg)) + (when (py-shell-comint-end-of-output-p + py-shell-output-filter-buffer) + ;; Output ends when `py-shell-output-filter-buffer' contains + ;; the prompt attached at the end of it. + (setq py-shell-output-filter-in-progress nil + py-shell-output-filter-buffer + (substring py-shell-output-filter-buffer + 0 (match-beginning 0))) + (when (string-match + py-shell--prompt-calculated-output-regexp + py-shell-output-filter-buffer) + ;; Some shells, like IPython might append a prompt before the + ;; output, clean that. + (setq py-shell-output-filter-buffer + (substring py-shell-output-filter-buffer (match-end 0))))) + "")) + +(defun py-send-string-no-output (strg &optional process buffer-name) + "Send STRING to PROCESS and inhibit output. + +Return the output." + (let* ((proc (or process (py-shell-get-process))) + (buffer (or buffer-name (if proc (buffer-name (process-buffer proc)) (py-shell)))) + (comint-preoutput-filter-functions + '(py-shell-output-filter)) + (py-shell-output-filter-in-progress t) + (inhibit-quit t) + (delay (py--which-delay-process-dependent buffer))) + (or + (with-local-quit + (if (and (string-match ".\n+." strg) (string-match "^\*[Ii]" buffer)) ;; IPython or multiline + (let* ((temp-file-name (py-temp-file-name strg)) + (file-name (or (buffer-file-name) temp-file-name))) + (py-send-file file-name proc)) + (py-shell-send-string strg proc)) + ;; (switch-to-buffer buffer) + ;; (accept-process-output proc 9) + (while py-shell-output-filter-in-progress + ;; `py-shell-output-filter' takes care of setting + ;; `py-shell-output-filter-in-progress' to NIL after it + ;; detects end of output. + (accept-process-output proc delay)) + (prog1 + py-shell-output-filter-buffer + (setq py-shell-output-filter-buffer nil))) + (with-current-buffer (process-buffer proc) + (comint-interrupt-subjob))))) + +(defun py-send-string (strg &optional process result no-output orig output-buffer fast argprompt args dedicated shell exception-buffer split switch internal) + "Evaluate STRG in Python PROCESS. + +With optional Arg PROCESS send to process. +With optional Arg RESULT store result in var ‘py-result’, also return it. +With optional Arg NO-OUTPUT don't display any output +With optional Arg ORIG deliver original position. +With optional Arg OUTPUT-BUFFER specify output-buffer" + (interactive "sPython command: ") + (save-excursion + (let* ((buffer (or output-buffer (or (and process (buffer-name (process-buffer process))) (buffer-name (py-shell argprompt args dedicated shell output-buffer fast exception-buffer split switch internal))))) + (proc (or process (get-buffer-process buffer))) + ;; nil nil nil nil (buffer-name buffer)))) + (orig (or orig (point))) + (limit (ignore-errors (marker-position (process-mark proc))))) + (cond ((and no-output fast) + (py--fast-send-string-no-output-intern strg proc limit buffer no-output)) + (no-output + (py-send-string-no-output strg proc)) + ((and (string-match ".\n+." strg) (string-match "^[Ii]" + ;; (buffer-name buffer) + buffer + )) ;; multiline + (let* ((temp-file-name (py-temp-file-name strg)) + (file-name (or (buffer-file-name) temp-file-name))) + (py-send-file file-name proc))) + (t (with-current-buffer buffer + (comint-send-string proc strg) + (when (or (not (string-match "\n\\'" strg)) + (string-match "\n[ \t].*\n?\\'" strg)) + (comint-send-string proc "\n")) + (sit-for py-python-send-delay) + (cond (result + (setq py-result + (py--fetch-result buffer limit strg))) + (no-output + (and orig (py--cleanup-shell orig buffer)))))))))) + +(defun py-send-file (file-name process) + "Send FILE-NAME to Python PROCESS." + (interactive "fFile to send: ") + (let* ((proc (or + process (get-buffer-process (py-shell)))) + (file-name (expand-file-name file-name))) + (py-send-string + (format + (concat "__pyfile = open('''%s''');" + "exec(compile(__pyfile.read(), '''%s''', 'exec'));" + "__pyfile.close()") + file-name file-name) + proc))) + +(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 py-def-or-class-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--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 `t' if point was moved" + (prog1 + (< 0 (abs (skip-chars-backward "^;" (or limit (line-beginning-position))))) + (skip-chars-forward " \t" (line-end-position)))) + +(defun py-forward-comment () + "Go to the end of comment at point." + (let ((orig (point)) + last) + (while (and (not (eobp)) (nth 4 (parse-partial-sexp (line-beginning-position) (point))) (setq last (line-end-position))) + (forward-line 1) + (end-of-line)) + (when + (< orig last) + (goto-char last)(point)))) + +(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 (string-to-char 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 done) + (unless (bobp) + (while (and (not done)(not (bobp)) + (setq erg (re-search-backward "^[[:alpha:]_'\"]" nil t 1))) + (if + (nth 8 (parse-partial-sexp (point-min) (point))) + (setq erg nil) + (setq done t))) + (when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg)) + erg))) + +;; might be slow due to repeated calls of ‘py-down-statement’ +(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) + (let* ((orig (point)) + erg + (indent (or + indent + (if + (py--beginning-of-statement-p) + (current-indentation) + (progn + (py-backward-statement) + (current-indentation)))))) + (while (and (py-forward-statement) (py-forward-statement) (py-backward-statement) (> (current-indentation) indent))) + (cond ((= indent (current-indentation)) + (setq erg (point))) + ((< (point) orig) + (goto-char orig)) + ((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 () + "Internal use: Go to beginning of line following end of form. + +Return position." + (if (eobp) + (point) + (forward-line 1) + (beginning-of-line) + (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 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 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-backward-same-level-intern (indent) + (while (and + (py-backward-statement) + (< indent (current-indentation) )))) + +(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))) + (erg (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-backward-same-level-intern (current-indentation)) + (back-to-indentation) + (py-backward-same-level)))))) + (when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg)) + erg)) + +(defun py-forward-same-level () + "Go form forward 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 (erg) + (unless (py-beginning-of-statement-p) + (py-backward-statement)) + (setq erg (py-down (current-indentation))) + (when (and py-verbose-p (called-interactively-p 'any)) (message "%s" erg)) + erg)) + +(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 (py-empty-line-p) (split-line)) + (beginning-of-line) + (insert py-section-start) + (goto-char end) + (unless (py-empty-line-p) (newline 1)) + (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-toggle-shell-fontification (msg) + "Toggles value of ‘py-shell-fontify-p’. " + (interactive "p") + + (if (setq py-shell-fontify-p (not py-shell-fontify-p)) + (progn + (py-shell-font-lock-turn-on)) + (py-shell-font-lock-turn-off)) + (when msg (message "py-shell-fontify-p set to: %s" py-shell-fontify-p))) + +(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 regexp)))) + (message "%s" cui) + (py--end-base regexp (point)) + (forward-line 1) + (if py-close-provides-newline + (unless (py-empty-line-p) (split-line)) + (fixup-whitespace)) + (indent-to-column cui) + cui)) + +(defun py-escaped-p (&optional pos) + "Return t if char at POS is preceded by an odd number of backslashes. " + (save-excursion + (when pos (goto-char pos)) + (< 0 (% (abs (skip-chars-backward "\\\\")) 2)))) + +(defun py--backward-regexp (regexp &optional indent condition orig regexpvalue) + "Search backward next regexp not in string or comment. + +Return and move to match-beginning if successful" + (save-match-data + (unless (py-beginning-of-statement-p) (skip-chars-backward " \t\r\n\f") + (py-backward-comment (point))) + (let* (pps + (regexpvalue (or regexpvalue (symbol-value regexp))) + (indent (or indent (current-indentation))) + (condition (or condition '<)) + (orig (or orig (point)))) + (if (eq (current-indentation) (current-column)) + (while (and + (not (bobp)) + ;; # class kugel(object) -> a[1:2]: + ;; class kugel(object): + ;; (re-search-backward regexpvalue nil 'move 1) + (re-search-backward (concat "^ \\{0,"(format "%s" indent) "\\}"regexpvalue) nil 'move 1) + ;; re-search-backward not greedy + (not (and (looking-back "async *" (line-beginning-position)) + (goto-char (match-beginning 0)))) + (or (and + (setq pps (nth 8 (parse-partial-sexp (point-min) (point)))) + (goto-char pps)) + ;; needed by py-backward-clause + (and indent + (funcall condition indent (current-indentation)))))) + (back-to-indentation) + (unless (and (< (point) orig) (looking-at regexpvalue)) + (py--backward-regexp regexp (current-indentation) condition orig))) + (unless (or (eq (point) orig)(bobp)) (back-to-indentation)) + (and (looking-at regexpvalue) (not (nth 8 (parse-partial-sexp (point-min) (point))))(point))))) + +(defun py--forward-regexp (regexp) + "Search forward next regexp not in string or comment. + +Return and move to match-beginning if successful" + (save-match-data + (let (erg) + (while (and + (setq erg (re-search-forward regexp nil 'move 1)) + (nth 8 (parse-partial-sexp (point-min) (point))))) + (unless + (nth 8 (parse-partial-sexp (point-min) (point))) + erg)))) + +(defun py--backward-regexp-fast (regexp) + "Search backward next regexp not in string or comment. + +Return and move to match-beginning if successful" + (save-match-data + (let (last) + (while (and + (re-search-backward regexp nil 'move 1) + (setq last (match-beginning 0)) + (nth 8 (parse-partial-sexp (point-min) (point))))) + (unless (nth 8 (parse-partial-sexp (point-min) (point))) + last)))) + +(defun py--forward-regexp-keep-indent (regexp &optional indent) + "Search forward next regexp not in string or comment. + +Return and move to match-beginning if successful" + (save-match-data + (let ((indent (or indent (current-indentation))) + (regexp (if (stringp regexp) + regexp + (symbol-value regexp))) + (orig (point)) + last done) + (forward-line 1) + (beginning-of-line) + (while (and + (not done) + (re-search-forward regexp nil 'move 1) + (or (nth 8 (parse-partial-sexp (point-min) (point))) + (or (< indent (current-indentation))(setq done t)) + (setq last (line-end-position))))) + (unless + (nth 8 (parse-partial-sexp (point-min) (point))) + (if last (goto-char last) + (back-to-indentation)) + (and (< orig (point)) (point)))))) + +(defun py-down-base (regexp &optional indent bol) + (let ((indent (or indent (current-indentation)))) + (and (py--forward-regexp-keep-indent regexp indent) + (progn + (if bol + (beginning-of-line) + (back-to-indentation)) + (point))))) + +(defun py-up-base (regexp &optional indent) + "Expects a symbol as REGEXP like ‘'py-clause-re’" + (unless (py-beginning-of-statement-p) (py-backward-statement)) + (unless (looking-at (symbol-value regexp)) + (py--go-to-keyword regexp (or indent (current-indentation)) '<)) + ;; now from beginning-of-block go one indent level upwards + (py--go-to-keyword regexp (- (or indent (current-indentation)) py-indent-offset) '<)) + +(defun py-comint-delete-output () + "Delete all output from interpreter since last input. +Does not delete the prompt." + (interactive) + (let ((proc (get-buffer-process (current-buffer))) + (replacement nil) + (inhibit-read-only t)) + (save-excursion + (let ((pmark (progn (goto-char (process-mark proc)) + (forward-line 0) + (point-marker)))) + (delete-region comint-last-input-end pmark) + (goto-char (process-mark proc)) + (setq replacement (concat "*** output flushed ***\n" + (buffer-substring pmark (point)))) + (delete-region pmark (point)))) + ;; Output message and put back prompt + (comint-output-filter proc replacement))) + +;; python-components-named-shells + +(defun ipython (&optional argprompt args buffer fast exception-buffer split) + "Start an IPython interpreter. + +With optional \\[universal-argument] get a new dedicated shell." + (interactive "p") + (py-shell argprompt args nil "ipython" buffer fast exception-buffer split (unless argprompt (eq 1 (prefix-numeric-value argprompt))))) + +(defun ipython2.7 (&optional argprompt args buffer fast exception-buffer split) + "Start an IPython2.7 interpreter. + +With optional \\[universal-argument] get a new dedicated shell." + (interactive "p") + (py-shell argprompt args nil "ipython2.7" buffer fast exception-buffer split (unless argprompt (eq 1 (prefix-numeric-value argprompt))))) + +(defun ipython3 (&optional argprompt args buffer fast exception-buffer split) + "Start an IPython3 interpreter. + +With optional \\[universal-argument] get a new dedicated shell." + (interactive "p") + (py-shell argprompt args nil "ipython3" buffer fast exception-buffer split (unless argprompt (eq 1 (prefix-numeric-value argprompt))))) + +(defun jython (&optional argprompt args buffer fast exception-buffer split) + "Start an Jython interpreter. + +With optional \\[universal-argument] get a new dedicated shell." + (interactive "p") + (py-shell argprompt args nil "jython" buffer fast exception-buffer split (unless argprompt (eq 1 (prefix-numeric-value argprompt))))) + +(defun python (&optional argprompt args buffer fast exception-buffer split) + "Start an Python interpreter. + +With optional \\[universal-argument] get a new dedicated shell." + (interactive "p") + (py-shell argprompt args nil "python" buffer fast exception-buffer split (unless argprompt (eq 1 (prefix-numeric-value argprompt))))) + +(defun python2 (&optional argprompt args buffer fast exception-buffer split) + "Start an Python2 interpreter. + +With optional \\[universal-argument] get a new dedicated shell." + (interactive "p") + (py-shell argprompt args nil "python2" buffer fast exception-buffer split (unless argprompt (eq 1 (prefix-numeric-value argprompt))))) + +(defun python3 (&optional argprompt args buffer fast exception-buffer split) + "Start an Python3 interpreter. + +With optional \\[universal-argument] get a new dedicated shell." + (interactive "p") + (py-shell argprompt args nil "python3" buffer fast exception-buffer split (unless argprompt (eq 1 (prefix-numeric-value argprompt))))) + +(defun pypy (&optional argprompt args buffer fast exception-buffer split) + "Start an Pypy interpreter. + +With optional \\[universal-argument] get a new dedicated shell." + (interactive "p") + (py-shell argprompt args nil "pypy" buffer fast exception-buffer split (unless argprompt (eq 1 (prefix-numeric-value argprompt))))) + +;; 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" py-show + :help " `py-show' +Un-hide at point."] + + ["Show all" py-show-all + :help " `py-show-all' +Un-hide all in buffer."] + )) + ("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" + ("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] + + ["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-indent-or-complete + :help " `py-indent-or-complete'"] + + ["Py shell complete" py-shell-complete + :help " `py-shell-complete'"] + + ["Py complete" py-complete + :help " `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))) + +(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-kill-minor-expression 'py-kill-partial-expression) +(defalias 'pyhotn 'python) +(defalias 'pyhton 'python) +(defalias 'pyt 'python) +(defalias 'py3 'python3) +(defalias 'py2 'python2) +(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) +(defalias 'py-count-indentation 'py-compute-indentation) + +;;;###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 'python-mode "python-mode" "Python Mode." t) + +(defun all-mode-setting () + (set (make-local-variable 'indent-tabs-mode) py-indent-tabs-mode) + (set (make-local-variable 'eldoc-message-function) 'py-help-at-point) + + ) + +;;;###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 + ;; load known shell listed in + ;; Local vars + (all-mode-setting) + (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 (>= emacs-major-version 25) + (global-eldoc-mode -1) + (eldoc-mode py-eldoc-mode-p)) + (when py-font-lock-defaults-p + (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:]]+:.+$"))) + (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) + ;; introduced to silence compiler warning, no real setting + ;; (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 'normal-auto-fill-function) 'py-fill-string-or-comment) + (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 (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-trailing-whitespace-smart-delete-p + (add-hook 'before-save-hook 'delete-trailing-whitespace nil 'local)) + ;; this should go into interactive modes + ;; (when py-pdbtrack-do-tracking-p + ;; (add-hook 'comint-output-filter-functions 'py--pdbtrack-track-stack-file)) + (py-shell-prompt-set-calculated-regexps) + (setq comint-prompt-regexp py-shell--prompt-calculated-input-regexp) + (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))) + ;; #'python-shell-completion-at-point 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 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)) + +(define-derived-mode py-shell-mode comint-mode py-modeline-display + "Major mode for Python shell process. + +Variables +`py-shell-prompt-regexp', +`py-shell-prompt-output-regexp', +`py-shell-input-prompt-2-regexp', +`py-shell-fontify-p', +`py-completion-setup-code', +`py-shell-completion-string-code', +`py-python-eldoc-setup-code', `py-python-eldoc-string-code', +`py-python-ffap-setup-code' and `py-python-ffap-string-code' can +customize this mode for different Python interpreters. + +This mode resets `comint-output-filter-functions' locally, so you +may want to re-add custom functions to it using the +`py-shell-mode-hook'. + +\(Type \\[describe-mode] in the process buffer for a list of commands.)" + (setq mode-line-process '(":%s")) + (all-mode-setting) + ;; (set (make-local-variable 'indent-tabs-mode) nil) + (set (make-local-variable 'py-shell--prompt-calculated-input-regexp) nil) + (set (make-local-variable 'py-shell--block-prompt) nil) + (set (make-local-variable 'py-shell--prompt-calculated-output-regexp) nil) + (py-shell-prompt-set-calculated-regexps) + (set (make-local-variable 'comint-prompt-read-only) t) + (set (make-local-variable 'comint-output-filter-functions) + '(ansi-color-process-output + py-comint-watch-for-first-prompt-output-filter + py-pdbtrack-comint-output-filter-function + py-comint-postoutput-scroll-to-bottom + comint-watch-for-password-prompt)) + (set (make-local-variable 'compilation-error-regexp-alist) + py-shell-compilation-regexp-alist) + (compilation-shell-minor-mode 1) + (add-hook 'completion-at-point-functions + #'py-shell-completion-at-point nil 'local) + (cond + ((string-match "^[Jj]" (process-name (get-buffer-process (current-buffer)))) + 'indent-for-tab-command) + (t + (define-key py-shell-mode-map "\t" + 'py-indent-or-complete))) + (make-local-variable 'py-pdbtrack-buffers-to-kill) + (make-local-variable 'py-shell-fast-last-output) + (set (make-local-variable 'py-shell--block-prompt) nil) + (set (make-local-variable 'py-shell--prompt-calculated-output-regexp) nil) + (py-shell-prompt-set-calculated-regexps) + (if py-shell-fontify-p + (progn + (py-shell-font-lock-turn-on)) + (py-shell-font-lock-turn-off))) + +;;; +(provide 'python-mode) +;;; python-mode.el ends here diff --git a/emacs.d/session.101d47009963c31ba1159569722019955500000022650061 b/emacs.d/session.101d47009963c31ba1159569722019955500000022650061 new file mode 100644 index 0000000..e69de29 diff --git a/emacs.d/session.101d47009963c31ba1159574583376392600000022650075 b/emacs.d/session.101d47009963c31ba1159574583376392600000022650075 new file mode 100644 index 0000000..e69de29 diff --git a/emacs.d/session.1025c13d2547b60a4159077433053076200000021570061 b/emacs.d/session.1025c13d2547b60a4159077433053076200000021570061 new file mode 100644 index 0000000..e69de29 diff --git a/emacs.d/session.1025c13d2547b60a4159092200566268200000021570110 b/emacs.d/session.1025c13d2547b60a4159092200566268200000021570110 new file mode 100644 index 0000000..e69de29 diff --git a/emacs.d/session.10b4081bb65a59085d159478824683153500000022890061 b/emacs.d/session.10b4081bb65a59085d159478824683153500000022890061 new file mode 100644 index 0000000..e69de29 diff --git a/emacs.d/session.10b4081bb65a59085d159479301240276200000022890072 b/emacs.d/session.10b4081bb65a59085d159479301240276200000022890072 new file mode 100644 index 0000000..e69de29 diff --git a/emacs.d/session.10f083cc2387800c9d158834765989283100000022650307 b/emacs.d/session.10f083cc2387800c9d158834765989283100000022650307 new file mode 100644 index 0000000..e69de29 diff --git a/emacs.d/session.10f083cc2387800c9d158844134055669800000022650348 b/emacs.d/session.10f083cc2387800c9d158844134055669800000022650348 new file mode 100644 index 0000000..e69de29 diff --git a/emacs.d/session.10f6902c8946b7fce3158895969791533300000019210061 b/emacs.d/session.10f6902c8946b7fce3158895969791533300000019210061 new file mode 100644 index 0000000..e69de29 diff --git a/emacs.d/session.10f6902c8946b7fce3158909298996168000000019210117 b/emacs.d/session.10f6902c8946b7fce3158909298996168000000019210117 new file mode 100644 index 0000000..e69de29 diff --git a/emacs.d/session.10f6902c8946b7fce3158912618062280700000019210154 b/emacs.d/session.10f6902c8946b7fce3158912618062280700000019210154 new file mode 100644 index 0000000..e69de29 diff --git a/emacs.d/tramp b/emacs.d/tramp new file mode 100644 index 0000000..90c6b1b --- /dev/null +++ b/emacs.d/tramp @@ -0,0 +1,82 @@ +;; -*- emacs-lisp -*- <20/08/10 15:20:56 /home/liw/.emacs.d/tramp> +;; Tramp connection history. Don't change this file. +;; You can delete it, forcing Tramp to reapply the checks. + +(((tramp-file-name "ssh" nil nil "pieni.net" nil nil nil) + ("uname" "Linux 4.19.0-8-amd64") + ("locale" "LC_ALL=en_US.utf8") + ("test" "test") + ("remote-path" + ("/bin" "/usr/bin" "/sbin" "/usr/sbin" "/usr/local/bin" "/usr/local/sbin")) + ("remote-shell" "/bin/sh") + ("~" "/home/liw") + ("file-exists" "test -e") + ("case-insensitive" nil) + ("readlink" "\\readlink") + ("stat" "env QUOTING_STYLE=locale \\stat") + ("perl-file-spec" t) + ("perl-cwd-realpath" t) + ("perl" "\\perl") + ("git" "\\git") + ("id" "/bin/id") + ("gid-string" "liw") + ("gid-integer" 1000) + ("uid-integer" 1000)) + ((tramp-file-name "ssh" "root" nil "letest-letest.vm.liw.fi" nil nil nil) + ("uname" "Linux 4.19.0-8-amd64") + ("locale" "LC_ALL=en_US.utf8") + ("test" "test") + ("remote-path" + ("/bin" "/usr/bin" "/sbin" "/usr/sbin" "/usr/local/bin" "/usr/local/sbin")) + ("remote-shell" "/bin/sh") + ("~" "/root") + ("file-exists" "test -e") + ("case-insensitive" nil) + ("readlink" "\\readlink") + ("stat" "env QUOTING_STYLE=locale \\stat") + ("perl-file-spec" t) + ("perl-cwd-realpath" t) + ("perl" "\\perl") + ("git" "\\git") + ("id" "/bin/id") + ("gid-string" "root") + ("gid-integer" 0) + ("uid-integer" 0)) + ((tramp-file-name "ssh" nil nil "exolobe2" nil nil nil) + ("uname" "Linux 4.19.0-9-amd64") + ("locale" "LC_ALL=en_US.utf8") + ("test" "test") + ("remote-path" + ("/bin" "/usr/bin" "/sbin" "/usr/sbin" "/usr/local/bin" "/usr/local/sbin")) + ("remote-shell" "/bin/sh") + ("~" "/home/liw") + ("file-exists" "test -e") + ("case-insensitive" nil) + ("readlink" "\\readlink") + ("stat" "env QUOTING_STYLE=locale \\stat") + ("perl-file-spec" t) + ("perl-cwd-realpath" t) + ("perl" "\\perl") + ("id" "/usr/bin/id") + ("gid-string" "liw") + ("uid-integer" 1000) + ("gid-integer" 1000)) + ((tramp-file-name "ssh" nil nil "exolobe5" nil nil nil) + ("uname" "Linux 4.19.0-10-amd64") + ("locale" "LC_ALL=en_US.utf8") + ("test" "test") + ("remote-path" + ("/bin" "/usr/bin" "/sbin" "/usr/sbin" "/usr/local/bin" "/usr/local/sbin")) + ("remote-shell" "/bin/sh") + ("file-exists" "test -e") + ("readlink" "\\readlink") + ("stat" "env QUOTING_STYLE=locale \\stat") + ("case-insensitive" nil) + ("perl-file-spec" t) + ("perl-cwd-realpath" t) + ("perl" "\\perl") + ("id" "/bin/id") + ("gid-string" "liw") + ("gid-integer" 1000) + ("uid-integer" 1000) + ("~" "/home/liw"))) -- cgit v1.2.1