djavu-asus/elpa/elpy-20230803.1455/elpy-shell.el

   1 ;;; elpy-shell.el --- Interactive Python support for elpy -*- lexical-binding: t -*-
   2 ;;
   3 ;; Copyright (C) 2012-2019  Jorgen Schaefer
   4 ;;
   5 ;; Author: Jorgen Schaefer <contact@jorgenschaefer.de>, Rainer Gemulla <rgemulla@gmx.de>, Gaby Launay <gaby.launay@protonmail.com>
   6 ;; URL: https://github.com/jorgenschaefer/elpy
   7 ;;
   8 ;; This program is free software; you can redistribute it and/or
   9 ;; modify it under the terms of the GNU General Public License
  10 ;; as published by the Free Software Foundation; either version 3
  11 ;; of the License, or (at your option) any later version.
  12 ;;
  13 ;; This program is distributed in the hope that it will be useful,
  14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 ;; GNU General Public License for more details.
  17 ;;
  18 ;; You should have received a copy of the GNU General Public License
  19 ;; along with this program. If not, see <http://www.gnu.org/licenses/>.
  20 ;;
  21 ;;; Commentary:
  22 ;;
  23 ;; Adds support for interactive Python to elpy
  24 ;;
  25 ;;; Code:
  26
  27 (eval-when-compile (require 'subr-x))
  28 (require 'python)
  29
  30 ;;;;;;;;;;;;;;;;;;;;;;
  31 ;;; User customization
  32
  33 (defcustom elpy-dedicated-shells nil
  34   "Non-nil if Elpy should use dedicated shells.
  35
  36 Elpy can use a unique Python shell for all buffers and support
  37 manually started dedicated shells. Setting this option to non-nil
  38 force the creation of dedicated shells for each buffers."
  39   :type 'boolean
  40   :group 'elpy)
  41 (make-obsolete-variable 'elpy-dedicated-shells
  42                         "Dedicated shells are no longer supported by Elpy.
  43 You can use `(add-hook 'elpy-mode-hook (lambda () (elpy-shell-toggle-dedicated-shell 1)))' to achieve the same result."
  44                         "1.17.0")
  45
  46 (defcustom elpy-shell-display-buffer-after-send nil ;
  47   "Whether to display the Python shell after sending something to it."
  48   :type 'boolean
  49   :group 'elpy)
  50
  51 (defcustom elpy-shell-echo-output 'when-shell-not-visible
  52   "Whether to echo the Python shell output in the echo area after input has been sent to the shell.
  53
  54   Possible choices are nil (=never), `when-shell-not-visible', or
  55   t (=always)."
  56   :type '(choice (const :tag "Never" nil)
  57                  (const :tag "When shell not visible" when-shell-not-visible)
  58                  (const :tag "Always" t))
  59   :group 'elpy)
  60
  61 (defcustom elpy-shell-capture-last-multiline-output t
  62   "Whether to capture the output of the last Python statement when sending multiple statements to the Python shell.
  63
  64   If nil, no output is captured (nor echoed in the shell) when
  65   sending multiple statements. This is the default behavior of
  66   python.el. If non-nil and the last statement is an expression,
  67   captures its output so that it is echoed in the shell."
  68   :type 'boolean
  69   :group 'elpy)
  70 (make-obsolete-variable 'elpy-shell-capture-last-multiline-output
  71                         "The last multiline output is now always captured."
  72                         "February 2019")
  73
  74 (defcustom elpy-shell-echo-input t
  75   "Whether to echo input sent to the Python shell as input in the
  76 shell buffer.
  77
  78 Truncation of long inputs can be controlled via
  79 `elpy-shell-echo-input-lines-head' and
  80 `elpy-shell-echo-input-lines-tail'."
  81   :type 'boolean
  82   :group 'elpy)
  83
  84 (defcustom elpy-shell-echo-input-cont-prompt t
  85   "Whether to show a continuation prompt when echoing multi-line
  86 input to the Python shell."
  87   :type 'boolean
  88   :group 'elpy)
  89
  90 (defcustom elpy-shell-echo-input-lines-head 10
  91   "Maximum number of lines to show before truncating input echoed
  92 in the Python shell."
  93   :type 'integer
  94   :group 'elpy)
  95
  96 (defcustom elpy-shell-echo-input-lines-tail 10
  97   "Maximum number of lines to show after truncating input echoed
  98 in the Python shell."
  99   :type 'integer
 100   :group 'elpy)
 101
 102 (defcustom elpy-shell-starting-directory 'project-root
 103   "Directory in which Python shells will be started.
 104
 105 Can be `project-root' (default) to use the current project root,
 106 `current-directory' to use the buffer current directory, or a
 107 string indicating a specific path.
 108
 109 \\<elpy-mode-map>
 110 Running python interpeters need to be restarted (with
 111 \\[elpy-shell-kill] followed by \\[elpy-shell-switch-to-shell]) for
 112 this option to be taken into account."
 113   :type '(choice (const :tag "Project root" project-root)
 114                  (const :tag "Current directory" current-directory)
 115                  (string :tag "Specific directory"))
 116   :group 'elpy)
 117
 118 (defcustom elpy-shell-use-project-root t
 119   "Whether to use project root as default directory when starting a Python shells.
 120
 121 The project root is determined using `elpy-project-root`. If this
 122 variable is set to nil, the current directory is used instead."
 123   :type 'boolean
 124   :group 'elpy)
 125 (make-obsolete-variable 'elpy-shell-use-project-root
 126                         'elpy-shell-starting-directory
 127                         "1.32.0")
 128
 129 (defcustom elpy-shell-cell-boundary-regexp
 130   (concat "^\\(?:"
 131           "##.*" "\\|"
 132           "#\\s-*<.+>" "\\|"
 133           "#\\s-*\\(?:In\\|Out\\)\\[.*\\]:"
 134           "\\)\\s-*$")
 135   "Regular expression for matching a line indicating the boundary
 136 of a cell (beginning or ending). By default, lines starting with
 137 ``##`` are treated as a cell boundaries, as are the boundaries in
 138 Python files exported from IPython or Jupyter notebooks (e.g.,
 139 ``# <markdowncell>``, ``# In[1]:'', or ``# Out[1]:``).
 140
 141 Note that `elpy-shell-cell-beginning-regexp' must also match
 142 the first boundary of the code cell."
 143
 144   :type 'string
 145   :group 'elpy)
 146
 147 (defcustom elpy-shell-codecell-beginning-regexp
 148   (concat "^\\(?:"
 149           "##.*" "\\|"
 150           "#\\s-*<codecell>" "\\|"
 151           "#\\s-*In\\[.*\\]:"
 152           "\\)\\s-*$")
 153   "Regular expression for matching a line indicating the
 154 beginning of a code cell. By default, lines starting with ``##``
 155 are treated as beginnings of a code cell, as are the code cell
 156 beginnings (and only the code cell beginnings) in Python files
 157 exported from IPython or Jupyter notebooks (e.g., ``#
 158 <codecell>`` or ``# In[1]:``).
 159
 160 Note that `elpy-shell-cell-boundary-regexp' must also match
 161 the code cell beginnings defined here."
 162   :type 'string
 163   :group 'elpy)
 164
 165 (defcustom elpy-shell-add-to-shell-history nil
 166   "If Elpy should make the code sent to the shell available in the
 167 shell history. This allows to use `comint-previous-input' in the
 168 python shell to get back the pieces of code sent by Elpy. This affects
 169 the following functions:
 170 - `elpy-shell-send-statement'
 171 - `elpy-shell-send-top-statement'
 172 - `elpy-shell-send-group'
 173 - `elpy-shell-send-codecell'
 174 - `elpy-shell-send-region-or-buffer'."
 175   :type 'boolean
 176   :group 'elpy)
 177
 178 (defcustom elpy-shell-darwin-use-pty nil
 179   "Whether to connect to the Python shell through pty on MacOS.
 180
 181 If nil, Elpy will connect to Python through a pipe. Any non-nil
 182 value will cause Elpy use a pseudo-terminal (pty) instead. This
 183 value should be set to nil when using a Python interpreter that
 184 uses the libedit version of Readline, such as the default MacOS
 185 Python interpreters. This value can be safely be set to true when
 186 using a version of Python that uses GNU Readline.
 187
 188 This value is only used when `elpy-shell-get-or-create-process'
 189 creates a new Python process."
 190   :type 'boolean
 191   :group 'elpy)
 192
 193
 194 ;;;;;;;;;;;;;;;;;;
 195 ;;; Shell commands
 196
 197 (defvar elpy--shell-last-py-buffer nil
 198   "Help keep track of python buffer when changing to pyshell.")
 199
 200 (defun elpy-shell-display-buffer ()
 201   "Display inferior Python process buffer."
 202   (display-buffer (process-buffer (elpy-shell-get-or-create-process))
 203                   nil
 204                   'visible))
 205
 206 ;; better name would be pop-to-shell
 207 (defun elpy-shell-switch-to-shell ()
 208   "Switch to inferior Python process buffer."
 209   (interactive)
 210   (setq elpy--shell-last-py-buffer (buffer-name))
 211   (pop-to-buffer (process-buffer (elpy-shell-get-or-create-process))))
 212
 213 (defun elpy-shell-switch-to-buffer ()
 214   "Switch from inferior Python process buffer to recent Python buffer."
 215   (interactive)
 216   (pop-to-buffer elpy--shell-last-py-buffer))
 217
 218 (defun elpy-shell-switch-to-shell-in-current-window ()
 219   (interactive)
 220   (setq elpy--shell-last-py-buffer (buffer-name))
 221   (switch-to-buffer (process-buffer (elpy-shell-get-or-create-process))))
 222
 223 (defun elpy-shell-switch-to-buffer-in-current-window ()
 224   (interactive)
 225   (switch-to-buffer elpy--shell-last-py-buffer))
 226
 227 (defun elpy-shell-kill (&optional kill-buff)
 228   "Kill the current python shell.
 229
 230 If KILL-BUFF is non-nil, also kill the associated buffer."
 231   (interactive)
 232   (let ((shell-buffer (python-shell-get-buffer)))
 233     (cond
 234      (shell-buffer
 235       (delete-process shell-buffer)
 236       (when kill-buff
 237         (kill-buffer shell-buffer))
 238       (message "Killed %s shell" shell-buffer))
 239      (t
 240       (message "No python shell to kill")))))
 241
 242 (defun elpy-shell-kill-all (&optional kill-buffers ask-for-each-one)
 243   "Kill all active python shells.
 244
 245 If KILL-BUFFERS is non-nil, also kill the associated buffers.
 246 If ASK-FOR-EACH-ONE is non-nil, ask before killing each python process."
 247   (interactive)
 248   (let ((python-buffer-list ()))
 249     ;; Get active python shell buffers and kill inactive ones (if asked)
 250     (cl-loop for buffer being the buffers do
 251           (when (and (buffer-name buffer)
 252                      (string-match (rx bol "*Python" (opt "[" (* (not (any "]"))) "]") "*" eol)
 253                                    (buffer-name buffer)))
 254             (if (get-buffer-process buffer)
 255                 (push buffer python-buffer-list)
 256               (when kill-buffers
 257                 (kill-buffer buffer)))))
 258     (cond
 259      ;; Ask for each buffers and kill
 260      ((and python-buffer-list ask-for-each-one)
 261       (cl-loop for buffer in python-buffer-list do
 262             (when (y-or-n-p (format "Kill %s ? " buffer))
 263                 (delete-process buffer)
 264                 (when kill-buffers
 265                   (kill-buffer buffer)))))
 266      ;; Ask and kill every buffers
 267      (python-buffer-list
 268       (if (y-or-n-p (format "Kill %s python shells ? " (length python-buffer-list)))
 269           (cl-loop for buffer in python-buffer-list do
 270                 (delete-process buffer)
 271                 (when kill-buffers
 272                   (kill-buffer buffer)))))
 273      ;; No shell to close
 274      (t
 275       (message "No python shell to close")))))
 276
 277 (defun elpy-executable-find-remote (command)
 278   "Emulate 'executable-find' REMOTE.
 279 Since Emacs 27, 'executable-find' accepts the 2nd argument.
 280 REMOVE THIS when Elpy no longer supports Emacs 26."
 281   (if (cdr (help-function-arglist 'executable-find)) ; 27+
 282       (executable-find command t)
 283     (if (file-remote-p default-directory)
 284         (let ((res (locate-file ; code from files.el
 285                     command
 286                     (mapcar
 287                      (lambda (x) (concat (file-remote-p default-directory) x))
 288                      (exec-path))
 289                     exec-suffixes 'file-executable-p)))
 290           (when (stringp res) (file-local-name res)))
 291       (executable-find command)))) ; local search
 292
 293 (defun elpy-shell-get-or-create-process (&optional sit)
 294   "Get or create an inferior Python process for current buffer and return it.
 295
 296 If SIT is non-nil, sit for that many seconds after creating a
 297 Python process. This allows the process to start up."
 298   (let* ((process-connection-type
 299           (if (string-equal system-type "darwin") elpy-shell-darwin-use-pty t))  ;; see https://github.com/jorgenschaefer/elpy/pull/1671
 300          (bufname (format "*%s*" (python-shell-get-process-name nil)))
 301          (proc (get-buffer-process bufname)))
 302     (if proc
 303         proc
 304       (unless (elpy-executable-find-remote python-shell-interpreter)
 305         (error "Python shell interpreter `%s' cannot be found. Please set `python-shell-interpreter' to a valid python binary."
 306                python-shell-interpreter))
 307       (let ((default-directory
 308               (cond ((eq elpy-shell-starting-directory 'project-root)
 309                      (or (elpy-project-root)
 310                          default-directory))
 311                     ((eq elpy-shell-starting-directory 'current-directory)
 312                      default-directory)
 313                     ((stringp elpy-shell-starting-directory)
 314                      (file-name-as-directory
 315                       (expand-file-name elpy-shell-starting-directory)))
 316                     (t
 317                      (error "Wrong value for `elpy-shell-starting-directory', please check this variable documentation and set it to a proper value")))))
 318         ;; We cannot use `run-python` directly, as it selects the new shell
 319         ;; buffer. See https://github.com/jorgenschaefer/elpy/issues/1848
 320         (python-shell-make-comint
 321          (python-shell-parse-command)
 322          (python-shell-get-process-name nil)
 323          t))
 324       (when sit (sit-for sit))
 325       (get-buffer-process bufname))))
 326
 327 (defun elpy-shell--send-setup-code ()
 328   "Send setup code for the shell."
 329   (let ((process (python-shell-get-process)))
 330     (when (elpy-project-root)
 331       (python-shell-send-string-no-output
 332        (format "import sys;sys.path.append('%s');del sys"
 333                (elpy-project-root))
 334        process))))
 335
 336 (defun elpy-shell-toggle-dedicated-shell (&optional arg)
 337   "Toggle the use of a dedicated python shell for the current buffer.
 338
 339 if ARG is positive, enable the use of a dedicated shell.
 340 if ARG is negative or 0, disable the use of a dedicated shell."
 341   (interactive)
 342   (let ((arg (or arg
 343                  (if (local-variable-p 'python-shell-buffer-name) 0 1))))
 344     (if (<= arg 0)
 345         (kill-local-variable 'python-shell-buffer-name)
 346       (setq-local python-shell-buffer-name
 347                   (format "Python[%s]" (buffer-name))))))
 348
 349 (defun elpy-shell-set-local-shell (&optional shell-name)
 350   "Associate the current buffer to a specific shell.
 351
 352 Meaning that the code from the current buffer will be sent to this shell.
 353
 354 If SHELL-NAME is not specified, ask with completion for a shell name.
 355
 356 If SHELL-NAME is \"Global\", associate the current buffer to the main python
 357 shell (often \"*Python*\" shell)."
 358   (interactive)
 359   (let* ((current-shell-name (if (local-variable-p 'python-shell-buffer-name)
 360                                  (progn
 361                                    (string-match "Python\\[\\(.*?\\)\\]"
 362                                                  python-shell-buffer-name)
 363                                    (match-string 1 python-shell-buffer-name))
 364                                "Global"))
 365          (shell-names (cl-loop
 366                 for buffer in (buffer-list)
 367                 for buffer-name = (substring-no-properties (buffer-name buffer))
 368                 if (string-match "\\*Python\\[\\(.*?\\)\\]\\*" buffer-name)
 369                 collect (match-string 1 buffer-name)))
 370          (candidates (remove current-shell-name
 371                            (delete-dups
 372                             (append (list (buffer-name) "Global")
 373                                     shell-names))))
 374          (prompt (format "Shell name (current: %s): " current-shell-name))
 375          (shell-name (or shell-name (completing-read prompt candidates))))
 376     (if (string= shell-name "Global")
 377        (kill-local-variable 'python-shell-buffer-name)
 378       (setq-local python-shell-buffer-name (format "Python[%s]" shell-name)))))
 379
 380 (defun elpy-shell--ensure-shell-running ()
 381   "Ensure that the Python shell for the current buffer is running.
 382
 383 If the shell is not running, waits until the first prompt is visible and
 384 commands can be sent to the shell."
 385   (with-current-buffer (process-buffer (elpy-shell-get-or-create-process))
 386     (let ((cumtime 0))
 387       (while (and (when (boundp 'python-shell--first-prompt-received)
 388                     (not python-shell--first-prompt-received))
 389                   (< cumtime 3))
 390         (sleep-for 0.1)
 391         (setq cumtime (+ cumtime 0.1)))))
 392   (elpy-shell-get-or-create-process))
 393
 394 (defun elpy-shell--string-without-indentation (string)
 395   "Return the current string, but without indentation."
 396   (if (string-empty-p string)
 397       string
 398     (let ((indent-level nil)
 399           (indent-tabs-mode nil))
 400       (with-temp-buffer
 401         (insert string)
 402         (goto-char (point-min))
 403         (while (< (point) (point-max))
 404           (cond
 405            ((or (elpy-shell--current-line-only-whitespace-p)
 406                 (python-info-current-line-comment-p)))
 407            ((not indent-level)
 408             (setq indent-level (current-indentation)))
 409            ((and indent-level
 410                  (< (current-indentation) indent-level))
 411             (error (message "X%sX" (thing-at-point 'line)))))
 412           ;; (error "Can't adjust indentation, consecutive lines indented less than starting line")))
 413           (forward-line))
 414         (indent-rigidly (point-min)
 415                         (point-max)
 416                         (- indent-level))
 417         ;; 'indent-rigidly' introduces tabs despite the fact that 'indent-tabs-mode' is nil
 418         ;; 'untabify' fix that
 419         (untabify (point-min) (point-max))
 420         (buffer-string)))))
 421
 422 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 423 ;; Flash input sent to shell
 424
 425 ;; functions for flashing a region; only flashes when package eval-sexp-fu is
 426 ;; loaded and its minor mode enabled
 427 (defun elpy-shell--flash-and-message-region (begin end)
 428   "Displays information about code fragments sent to the shell.
 429
 430 BEGIN and END refer to the region of the current buffer
 431 containing the code being sent. Displays a message with the code
 432 on the first line of that region. If `eval-sexp-fu-flash-mode' is
 433 active, additionally flashes that region briefly."
 434   (when (> end begin)
 435     (save-excursion
 436       (let* ((bounds
 437               (save-excursion
 438                 (goto-char begin)
 439                 (bounds-of-thing-at-point 'line)))
 440              (begin (max begin (car bounds)))
 441              (end (min end (cdr bounds)))
 442              (code-on-first-line (string-trim (buffer-substring begin end))))
 443         (goto-char begin)
 444         (end-of-line)
 445         (if (<= end (point))
 446             (message "Sent: %s" code-on-first-line)
 447           (message "Sent: %s..." code-on-first-line))
 448         (when (bound-and-true-p eval-sexp-fu-flash-mode)
 449           (cl-multiple-value-bind (_bounds hi unhi _eflash)
 450               (eval-sexp-fu-flash (cons begin end))
 451             (eval-sexp-fu-flash-doit (lambda () t) hi unhi)))))))
 452
 453 ;;;;;;;;;;;;;;;;;;;
 454 ;; Helper functions
 455
 456 (defun elpy-shell--current-line-else-or-elif-p ()
 457   (eq (string-match-p "\\s-*el\\(?:se:\\|if[^\w]\\)" (thing-at-point 'line)) 0))
 458
 459 (defun elpy-shell--current-line-decorator-p ()
 460   (eq (string-match-p "^\\s-*@[A-Za-z]" (thing-at-point 'line)) 0))
 461
 462 (defun elpy-shell--current-line-decorated-defun-p ()
 463   (save-excursion  (python-nav-backward-statement)
 464                    (elpy-shell--current-line-decorator-p)))
 465
 466 (defun elpy-shell--current-line-indented-p ()
 467   (eq (string-match-p "\\s-+[^\\s-]+" (thing-at-point 'line)) 0))
 468
 469 (defun elpy-shell--current-line-only-whitespace-p ()
 470   "Whether the current line contains only whitespace characters (or is empty)."
 471   (eq (string-match-p "\\s-*$" (thing-at-point 'line)) 0))
 472
 473 (defun elpy-shell--current-line-code-line-p ()
 474   (and (not (elpy-shell--current-line-only-whitespace-p))
 475        (not (python-info-current-line-comment-p))))
 476
 477 (defun elpy-shell--current-line-defun-p ()
 478   "Whether a function definition starts at the current line."
 479   (eq (string-match-p
 480        "\\s-*\\(?:def\\|async\\s-+def\\)\\s\-"
 481        (thing-at-point 'line))
 482       0))
 483
 484 (defun elpy-shell--current-line-defclass-p ()
 485   "Whether a class definition starts at the current line."
 486   (eq (string-match-p
 487        "\\s-*class\\s\-"
 488        (thing-at-point 'line))
 489       0))
 490
 491 (defun elpy-shell--skip-to-next-code-line (&optional backwards)
 492   "Move the point to the next line containing code.
 493
 494 If the current line has code, point is not moved. If BACKWARDS is
 495 non-nil, skips backwards."
 496   (if backwards
 497       (while (and (not (elpy-shell--current-line-code-line-p))
 498                   (not (eq (point) (point-min))))
 499         (forward-line -1))
 500     (while (and (not (elpy-shell--current-line-code-line-p))
 501                 (not (eq (point) (point-max))))
 502       (forward-line))))
 503
 504 (defun elpy-shell--check-if-shell-available ()
 505   "Check if the associated python shell is available.
 506
 507 Return non-nil is the shell is running and not busy, nil otherwise."
 508   (and (python-shell-get-process)
 509        (with-current-buffer (process-buffer (python-shell-get-process))
 510          (save-excursion
 511            (goto-char (point-max))
 512            (let ((inhibit-field-text-motion t))
 513              (python-shell-comint-end-of-output-p
 514               (buffer-substring (line-beginning-position)
 515                                 (line-end-position))))))))
 516 ;;;;;;;;;;
 517 ;; Echoing
 518
 519 (defmacro elpy-shell--with-maybe-echo (body)
 520   ;; Echoing is apparently buggy for emacs < 25...
 521   (if (<= 25 emacs-major-version)
 522       `(elpy-shell--with-maybe-echo-output
 523         (elpy-shell--with-maybe-echo-input
 524          ,body))
 525     body))
 526
 527
 528 (defmacro elpy-shell--with-maybe-echo-input (body)
 529   "Run BODY so that it adheres `elpy-shell-echo-input' and `elpy-shell-display-buffer'."
 530   `(progn
 531      (elpy-shell--enable-echo)
 532      (prog1
 533          (if elpy-shell-display-buffer-after-send
 534              (prog1 (progn ,body)
 535                (elpy-shell-display-buffer))
 536            (cl-flet ((elpy-shell-display-buffer () ()))
 537              (progn ,body)))
 538        (elpy-shell--disable-echo))))
 539
 540 (defvar-local elpy-shell--capture-output nil
 541   "Non-nil when the Python shell should capture output for display in the echo area.")
 542
 543 (defvar-local elpy-shell--captured-output nil
 544   "Current captured output of the Python shell.")
 545
 546 (defmacro elpy-shell--with-maybe-echo-output (body)
 547   "Run BODY and grab shell output according to `elpy-shell-echo-output'."
 548   `(cl-letf (((symbol-function 'python-shell-send-file)
 549               (if elpy-shell-echo-output
 550                   (symbol-function 'elpy-shell-send-file)
 551                 (symbol-function 'python-shell-send-file))))
 552      (let* ((process (elpy-shell--ensure-shell-running))
 553             (process-buf (process-buffer process))
 554             (shell-visible (or elpy-shell-display-buffer-after-send
 555                                (get-buffer-window process-buf))))
 556        (with-current-buffer process-buf
 557          (setq-local elpy-shell--capture-output
 558                      (and elpy-shell-echo-output
 559                           (or (not (eq elpy-shell-echo-output 'when-shell-not-visible))
 560                               (not shell-visible)))))
 561        (progn ,body))))
 562
 563 (defun elpy-shell--enable-output-filter ()
 564     (add-hook 'comint-output-filter-functions 'elpy-shell--output-filter nil t))
 565
 566 (defun elpy-shell--output-filter (string)
 567   "Filter used in `elpy-shell--with-maybe-echo-output' to grab output.
 568
 569 No actual filtering is performed. STRING is the output received
 570 to this point from the process. If `elpy-shell--capture-output'
 571 is set, captures and messages shell output in the echo area (once
 572 complete). Otherwise, does nothing."
 573   ;; capture the output and message it when complete
 574   (when elpy-shell--capture-output
 575     ;; remember the new output
 576     (setq-local elpy-shell--captured-output
 577                 (concat elpy-shell--captured-output (ansi-color-filter-apply string)))
 578
 579     ;; Output ends when `elpy-shell--captured-output' contains
 580     ;; the prompt attached at the end of it. If so, message it.
 581     (when (python-shell-comint-end-of-output-p elpy-shell--captured-output)
 582       (let ((output (substring
 583                      elpy-shell--captured-output
 584                      0 (match-beginning 0)))
 585             (message-log-max))
 586         (if (string-match-p "Traceback (most recent call last):" output)
 587             (message "Exception during evaluation.")
 588           (if (string-empty-p output)
 589               (message "No output was produced.")
 590             (message "%s" (replace-regexp-in-string "\n\\'" "" output))))
 591         (setq-local elpy-shell--captured-output nil))))
 592
 593   ;; return input unmodified
 594   string)
 595
 596 (defun elpy-shell--insert-and-font-lock (string face &optional no-font-lock)
 597   "Inject STRING into the Python shell buffer."
 598   (let ((from-point (point)))
 599     (insert string)
 600     (if (not no-font-lock)
 601         (add-text-properties from-point (point)
 602                              (list 'front-sticky t 'font-lock-face face)))))
 603
 604 (defun elpy-shell--append-to-shell-output (string &optional no-font-lock prepend-cont-prompt)
 605   "Append the given STRING to the output of the Python shell buffer.
 606
 607 Unless NO-FONT-LOCK is set, formats STRING as shell input.
 608 Prepends a continuation promt if PREPEND-CONT-PROMPT is set."
 609   (unless (string-empty-p string)
 610   (let* ((process (elpy-shell-get-or-create-process))
 611          (process-buf (process-buffer process))
 612          (mark-point (process-mark process)))
 613     (with-current-buffer process-buf
 614       (save-excursion
 615         (goto-char mark-point)
 616         (if prepend-cont-prompt
 617             (let* ((column (+ (- (point)
 618                                  (let ((inhibit-field-text-motion t))
 619                                    (forward-line -1)
 620                                    (end-of-line)
 621                                    (point)))
 622                               1))
 623                    (prompt (concat (make-string (max 0 (- column 6)) ? ) "... "))
 624                    (lines (split-string string "\n")))
 625               (goto-char mark-point)
 626               (elpy-shell--insert-and-font-lock
 627                (car lines) 'comint-highlight-input no-font-lock)
 628               (when (cdr lines)
 629                   ;; no additional newline at end for multiline
 630                   (dolist (line (cdr lines))
 631                     (insert "\n")
 632                     (let ((from-point (point)))
 633                       (elpy-shell--insert-and-font-lock
 634                        prompt 'comint-highlight-prompt no-font-lock)
 635                       (add-text-properties
 636                        from-point (point)
 637                        '(field output inhibit-line-move-field-capture t
 638                                rear-nonsticky t)))
 639                     (elpy-shell--insert-and-font-lock
 640                      line 'comint-highlight-input no-font-lock)))
 641                 ;; but put one for single line
 642                 (insert "\n"))
 643           (elpy-shell--insert-and-font-lock
 644            string 'comint-highlight-input no-font-lock))
 645         (set-marker (process-mark process) (point)))))))
 646
 647 (defun elpy-shell--string-head-lines (string n)
 648   "Extract the first N lines from STRING."
 649   (let* ((line "\\(?:\\(?:.*\n\\)\\|\\(?:.+\\'\\)\\)")
 650          (lines (concat line "\\{" (number-to-string n) "\\}"))
 651          (regexp (concat "\\`" "\\(" lines "\\)")))
 652     (if (string-match regexp string)
 653         (match-string 1 string)
 654       string)))
 655
 656 (defun elpy-shell--string-tail-lines (string n)
 657   "Extract the last N lines from STRING."
 658   (let* ((line "\\(?:\\(?:.*\n\\)\\|\\(?:.+\\'\\)\\)")
 659          (lines (concat line "\\{" (number-to-string n) "\\}"))
 660          (regexp (concat "\\(" lines "\\)" "\\'")))
 661     (if (string-match regexp string)
 662         (match-string 1 string)
 663       string)))
 664
 665 (defun elpy-shell--python-shell-send-string-echo-advice (string &optional _process _msg)
 666   "Advice to enable echoing of input in the Python shell."
 667   (interactive)
 668   (let* ((append-string ; strip setup code from Elpy
 669           (if (string-match "import sys, codecs, os, ast;__pyfile = codecs.open.*$" string)
 670               (replace-match "" nil nil string)
 671             string))
 672          (append-string ; strip setup code from python.el
 673           (if (string-match "import codecs, os;__pyfile = codecs.open(.*;exec(compile(__code, .*$" append-string)
 674               (replace-match "" nil nil append-string)
 675             append-string))
 676          (append-string ; here too
 677           (if (string-match "^# -\\*- coding: utf-8 -\\*-\n*$" append-string)
 678               (replace-match "" nil nil append-string)
 679             append-string))
 680          (append-string ; Strip "if True:", added when sending regions
 681           (if (string-match "^if True:$" append-string)
 682               (replace-match "" nil nil append-string)
 683             append-string))
 684          (append-string ; strip newlines from beginning and white space from end
 685           (string-trim-right
 686            (if (string-match "\\`\n+" append-string)
 687                (replace-match "" nil nil append-string)
 688              append-string)))
 689          (append-string ; Dedent region
 690           (elpy-shell--string-without-indentation append-string))
 691          (head (elpy-shell--string-head-lines append-string elpy-shell-echo-input-lines-head))
 692          (tail (elpy-shell--string-tail-lines append-string elpy-shell-echo-input-lines-tail))
 693          (append-string (if (> (length append-string) (+ (length head) (length tail)))
 694                             (concat head "...\n" tail)
 695                           append-string)))
 696
 697     ;; append the modified string to the shell output; prepend a newline for
 698     ;; multi-line strings
 699     (if elpy-shell-echo-input-cont-prompt
 700         (elpy-shell--append-to-shell-output append-string nil t)
 701       (elpy-shell--append-to-shell-output
 702        (concat (if (string-match "\n" append-string) "\n" "")
 703                append-string
 704                "\n")))))
 705
 706 (defun elpy-shell--enable-echo ()
 707   "Enable input echoing when `elpy-shell-echo-input' is set."
 708   (when elpy-shell-echo-input
 709     (advice-add 'python-shell-send-string
 710                 :before 'elpy-shell--python-shell-send-string-echo-advice)))
 711
 712 (defun elpy-shell--disable-echo ()
 713   "Disable input echoing."
 714   (advice-remove 'python-shell-send-string
 715                  'elpy-shell--python-shell-send-string-echo-advice))
 716
 717 (defun elpy-shell-send-file (file-name &optional process temp-file-name
 718                                          delete msg)
 719   "Like `python-shell-send-file' but evaluates last expression separately.
 720
 721 See `python-shell-send-file' for a description of the
 722 arguments. This function differs in that it breaks up the
 723 Python code in FILE-NAME into statements. If the last statement
 724 is a Python expression, it is evaluated separately in 'eval'
 725 mode. This way, the interactive python shell can capture (and
 726 print) the output of the last expression."
 727   (interactive
 728    (list
 729     (read-file-name "File to send: ")   ; file-name
 730     nil                                 ; process
 731     nil                                 ; temp-file-name
 732     nil                                 ; delete
 733     t))                                 ; msg
 734   (let* ((process (or process (python-shell-get-process-or-error msg)))
 735          (encoding (with-temp-buffer
 736                      (insert-file-contents
 737                       (or temp-file-name file-name))
 738                      (python-info-encoding)))
 739          (file-name (expand-file-name
 740                      (or (file-remote-p file-name 'localname)
 741                          file-name)))
 742          (temp-file-name (when temp-file-name
 743                            (expand-file-name
 744                             (or (file-remote-p temp-file-name 'localname)
 745                                 temp-file-name)))))
 746     (python-shell-send-string
 747      (format
 748       (concat
 749        "import sys, codecs, os, ast;"
 750        "__pyfile = codecs.open('''%s''', encoding='''%s''');"
 751        "__code = __pyfile.read().encode('''%s''');"
 752        "__pyfile.close();"
 753        (when (and delete temp-file-name)
 754          (format "os.remove('''%s''');" temp-file-name))
 755        "__block = ast.parse(__code, '''%s''', mode='exec');"
 756        ;; Has to ba a oneliner, which make conditionnal statements a bit complicated...
 757        " __block.body = (__block.body if not isinstance(__block.body[0], ast.If) else __block.body if not isinstance(__block.body[0].test, ast.Name) else __block.body if not __block.body[0].test.id == 'True' else __block.body[0].body) if sys.version_info[0] < 3 else (__block.body if not isinstance(__block.body[0], ast.If) else __block.body if not isinstance(__block.body[0].test, ast.NameConstant) else __block.body if not __block.body[0].test.value is True else __block.body[0].body);"
 758        "__last = __block.body[-1];" ;; the last statement
 759        "__isexpr = isinstance(__last,ast.Expr);" ;; is it an expression?
 760        "_ = __block.body.pop() if __isexpr else None;" ;; if so, remove it
 761        "exec(compile(__block, '''%s''', mode='exec'));" ;; execute everything else
 762        "eval(compile(ast.Expression(__last.value), '''%s''', mode='eval')) if __isexpr else None" ;; if it was an expression, it has been removed; now evaluate it
 763        )
 764       (or temp-file-name file-name) encoding encoding file-name file-name file-name)
 765      process)))
 766
 767 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 768 ;; Navigation commands for sending
 769
 770 (defun elpy-shell--nav-beginning-of-statement ()
 771   "Move the point to the beginning of the current or next Python statement.
 772
 773 If the current line starts with a statement, behaves exactly like
 774 `python-nav-beginning-of-statement'. If the line is part of a
 775 statement but not a statement itself, goes backwards to the
 776 beginning of the statement. If the current line is not a code
 777 line, skips forward to the next code line and navigates from
 778 there."
 779   (elpy-shell--skip-to-next-code-line)
 780   (python-nav-beginning-of-statement)
 781   (let ((p))
 782     (while (and (not (eq p (point)))
 783                 (or (elpy-shell--current-line-else-or-elif-p)
 784                     (elpy-shell--current-line-decorated-defun-p)))
 785       (elpy-nav-backward-block)
 786       (setq p (point)))))
 787
 788 (defun elpy-shell--nav-end-of-statement ()
 789   "Move the point to the end of the current Python statement.
 790
 791 Assumes that the point is precisely at the beginning of a
 792 statement (e.g., after calling
 793 `elpy-shell--nav-beginning-of-statement')."
 794   (let ((continue t)
 795         (p))
 796     (while (and (not (eq p (point)))
 797                 continue)
 798       ;; if on a decorator, move to the associated function
 799       (when (elpy-shell--current-line-decorator-p)
 800         (elpy-nav-forward-block))
 801
 802       ;; check if there is a another block at the same indentation level
 803       (setq p (point))
 804       (elpy-nav-forward-block)
 805
 806       ;; if not, go to the end of the block and done
 807       (if (eq p (point))
 808           (progn
 809             (python-nav-end-of-block)
 810             (setq continue nil))
 811         ;; otherwise check if its an else/elif clause
 812         (unless (elpy-shell--current-line-else-or-elif-p)
 813           (forward-line -1)
 814           (elpy-shell--skip-to-next-code-line t)
 815           (setq continue nil)))))
 816   (end-of-line))
 817
 818 (defun elpy-shell--nav-beginning-of-top-statement ()
 819   "Move the point to the beginning of the current or next top-level statement.
 820
 821 If the point is within a top-level statement, moves to its
 822 beginning. Otherwise, moves to the beginning of the next top-level
 823 statement."
 824   (interactive)
 825   (elpy-shell--nav-beginning-of-statement)
 826   (let ((p))
 827     (while (and (not (eq p (point)))
 828                 (elpy-shell--current-line-indented-p))
 829       (forward-line -1)
 830       (elpy-shell--skip-to-next-code-line t)
 831       (elpy-shell--nav-beginning-of-statement))))
 832
 833 (defun elpy-shell--nav-beginning-of-def (def-p)
 834   "Move point to the beginning of the current definition.
 835
 836 DEF-P is a predicate function that decides whether the current
 837 line starts a definition.
 838
 839 It the current line starts a definition, uses this definition. If
 840 the current line does not start a definition and is a code line,
 841 searches for the definition that contains the current line.
 842 Otherwise, searches for the definition that contains the next
 843 code line.
 844
 845 If a definition is found, moves point to the start of the
 846 definition and returns t. Otherwise, retains point position and
 847 returns nil."
 848   (if (funcall def-p)
 849       (progn
 850         (python-nav-beginning-of-statement)
 851         t)
 852     (let ((beg-ts (save-excursion
 853                     (elpy-shell--skip-to-next-code-line t)
 854                     (elpy-shell--nav-beginning-of-top-statement)
 855                     (point)))
 856           (orig-p (point))
 857           (max-indent (save-excursion
 858                         (elpy-shell--skip-to-next-code-line)
 859                         (- (current-indentation) 1)))
 860           (found))
 861       (while (and (not found)
 862                   (>= (point) beg-ts))
 863         (if (and (funcall def-p)
 864                  (<= (current-indentation) max-indent))
 865             (setq found t)
 866           (when (elpy-shell--current-line-code-line-p)
 867             (setq max-indent (min max-indent
 868                                   (- (current-indentation) 1))))
 869           (forward-line -1)))
 870       (if found
 871           (python-nav-beginning-of-statement)
 872         (goto-char orig-p))
 873       found)))
 874
 875 (defun elpy-shell--nav-beginning-of-defun ()
 876   "Move point to the beginning of the current function definition.
 877
 878 If a definition is found, moves point to the start of the
 879 definition and returns t. Otherwise, retains point position and
 880 returns nil.
 881
 882 See `elpy-shell--nav-beginning-of-def' for details."
 883   (when (or (elpy-shell--nav-beginning-of-def 'elpy-shell--current-line-defun-p)
 884             (elpy-shell--current-line-decorator-p))
 885     (when (elpy-shell--current-line-decorated-defun-p)
 886       (python-nav-backward-statement))
 887     t))
 888
 889 (defun elpy-shell--nav-beginning-of-defclass ()
 890   "Move point to the beginning of the current class definition.
 891
 892 If a definition is found, moves point to the start of the
 893 definition and returns t. Otherwise, retains point position and
 894 returns nil.
 895
 896 See `elpy-shell--nav-beginning-of-def' for details."
 897   (elpy-shell--nav-beginning-of-def 'elpy-shell--current-line-defclass-p))
 898
 899 (defun elpy-shell--nav-beginning-of-group ()
 900   "Move point to the beginning of the current or next group of top-level statements.
 901
 902 A sequence of top-level statements is a group if they are not
 903 separated by empty lines. Empty lines within each top-level
 904 statement are ignored.
 905
 906 If the point is within a top-level statement, moves to the
 907 beginning of the group containing this statement. Otherwise, moves
 908 to the first top-level statement below point."
 909   (elpy-shell--nav-beginning-of-top-statement)
 910   (while (not (or (elpy-shell--current-line-only-whitespace-p)
 911                   (eq (point) (point-min))))
 912     (unless (python-info-current-line-comment-p)
 913       (elpy-shell--nav-beginning-of-top-statement))
 914     (forward-line -1)
 915     (beginning-of-line))
 916   (when (elpy-shell--current-line-only-whitespace-p)
 917     (forward-line 1)
 918     (beginning-of-line)))
 919
 920 ;;;;;;;;;;;;;;;;;
 921 ;;; Send commands
 922
 923 (defun elpy-shell-send-statement-and-step ()
 924   "Send current or next statement to Python shell and step.
 925
 926 If the current line is part of a statement, sends this statement.
 927 Otherwise, skips forward to the next code line and sends the
 928 corresponding statement."
 929   (interactive)
 930   (elpy-shell--ensure-shell-running)
 931   (elpy-shell--nav-beginning-of-statement)
 932   ;; Make sure there is a statement to send
 933   (unless (looking-at "[[:space:]]*$")
 934     (unless elpy-shell-echo-input (elpy-shell--append-to-shell-output "\n"))
 935     (let ((beg (save-excursion (beginning-of-line) (point)))
 936           (end (progn (elpy-shell--nav-end-of-statement) (point))))
 937       (unless (eq beg end)
 938         (elpy-shell--flash-and-message-region beg end)
 939         (elpy-shell--add-to-shell-history (buffer-substring beg end))
 940         (elpy-shell--with-maybe-echo
 941          (python-shell-send-string
 942           (python-shell-buffer-substring beg end)))))
 943     (python-nav-forward-statement)))
 944
 945 (defun elpy-shell-send-top-statement-and-step ()
 946   "Send the current or next top-level statement to the Python shell and step.
 947
 948 If the current line is part of a top-level statement, sends this
 949 top-level statement. Otherwise, skips forward to the next code
 950 line and sends the corresponding top-level statement."
 951   (interactive)
 952   (elpy-shell--ensure-shell-running)
 953   (let* ((beg (progn (elpy-shell--nav-beginning-of-top-statement) (point)))
 954          (end (progn (elpy-shell--nav-end-of-statement) (point))))
 955     (elpy-shell--flash-and-message-region beg end)
 956     (if (string-match-p "\\`[^\n]*\\'" (buffer-substring beg end))
 957         ;; single line
 958         (elpy-shell-send-statement-and-step)
 959       ;; multiple lines
 960       (elpy-shell--add-to-shell-history (buffer-substring beg end))
 961       (elpy-shell--with-maybe-echo
 962        (python-shell-send-string (python-shell-buffer-substring beg end)))
 963       (setq mark-active nil)
 964       (python-nav-forward-statement))))
 965
 966 (defun elpy-shell-send-defun-and-step ()
 967   "Send the function definition that contains the current line
 968 to the Python shell and steps.
 969
 970 See `elpy-shell--nav-beginning-of-def' for details."
 971   (interactive)
 972   (if (elpy-shell--nav-beginning-of-defun)
 973       (elpy-shell-send-statement-and-step)
 974     (message "There is no function definition that includes the current line.")))
 975
 976 (defun elpy-shell-send-defclass-and-step ()
 977   "Send the class definition that contains the current line to
 978 the Python shell and steps.
 979
 980 See `elpy-shell--nav-beginning-of-def' for details."
 981   (interactive)
 982   (if (elpy-shell--nav-beginning-of-defclass)
 983       (elpy-shell-send-statement-and-step)
 984     (message "There is no class definition that includes the current line.")))
 985
 986 (defun elpy-shell-send-group-and-step ()
 987   "Send the current or next group of top-level statements to the Python shell and step.
 988
 989 A sequence of top-level statements is a group if they are not
 990 separated by empty lines. Empty lines within each top-level
 991 statement are ignored.
 992
 993 If the point is within a top-level statement, send the group
 994 around this statement. Otherwise, go to the top-level statement
 995 below point and send the group around this statement."
 996   (interactive)
 997   (elpy-shell--ensure-shell-running)
 998   (let* ((beg (progn (elpy-shell--nav-beginning-of-group) (point)))
 999          (end (progn
1000                 ;; go forward to end of group
1001                 (unless (python-info-current-line-comment-p)
1002                   (elpy-shell--nav-end-of-statement))
1003                 (let ((p))
1004                   (while (not (eq p (point)))
1005                     (setq p (point))
1006                     (forward-line)
1007                     (if (elpy-shell--current-line-only-whitespace-p)
1008                         (goto-char p) ;; done
1009                       (unless (python-info-current-line-comment-p)
1010                         (elpy-shell--nav-end-of-statement)))))
1011                 (point))))
1012     (if (> end beg)
1013         (progn
1014           (elpy-shell--flash-and-message-region beg end)
1015           ;; send the region and jump to next statement
1016           (if (string-match-p "\\`[^\n]*\\'" (buffer-substring beg end))
1017               ;; single line
1018               (elpy-shell-send-statement-and-step)
1019             ;; multiple lines
1020             (unless elpy-shell-echo-input
1021               (elpy-shell--append-to-shell-output "\n"))
1022             (elpy-shell--add-to-shell-history (buffer-substring beg end))
1023             (elpy-shell--with-maybe-echo
1024              (python-shell-send-string
1025               (python-shell-buffer-substring beg end)))
1026             (python-nav-forward-statement)))
1027       (goto-char (point-max)))
1028     (setq mark-active nil)))
1029
1030 (defun elpy-shell-send-codecell-and-step ()
1031   "Send the current code cell to the Python shell and step.
1032
1033 Signals an error if the point is not inside a code cell.
1034
1035 Cell beginnings and cell boundaries can be customized via the
1036 variables `elpy-shell-cell-boundary-regexp' and
1037 `elpy-shell-codecell-beginning-regexp', which see."
1038   (interactive)
1039   (let ((beg (save-excursion
1040                (end-of-line)
1041                (re-search-backward elpy-shell-cell-boundary-regexp nil t)
1042                (beginning-of-line)
1043                (and (string-match-p elpy-shell-codecell-beginning-regexp
1044                                     (thing-at-point 'line))
1045                     (point))))
1046         (end (save-excursion
1047                (forward-line)
1048                (if (re-search-forward elpy-shell-cell-boundary-regexp nil t)
1049                    (forward-line -1)
1050                  (goto-char (point-max)))
1051                (end-of-line)
1052                (point))))
1053     (if beg
1054         (progn
1055           (elpy-shell--flash-and-message-region beg end)
1056           (unless elpy-shell-echo-input
1057             (elpy-shell--append-to-shell-output "\n"))
1058           (elpy-shell--add-to-shell-history (buffer-substring beg end))
1059           (elpy-shell--with-maybe-echo
1060            (python-shell-send-string (python-shell-buffer-substring beg end)))
1061           (goto-char end)
1062           (python-nav-forward-statement))
1063       (message "Not in a codecell."))))
1064
1065 (defun elpy-shell-send-region-or-buffer-and-step (&optional arg)
1066   "Send the active region or the buffer to the Python shell and step.
1067
1068 If there is an active region, send that. Otherwise, send the
1069 whole buffer.
1070
1071 In Emacs 24.3 and later, without prefix argument and when there
1072 is no active region, this will escape the Python idiom of if
1073 __name__ == '__main__' to be false to avoid accidental execution
1074 of code. With prefix argument, this code is executed."
1075   (interactive "P")
1076   (if (use-region-p)
1077       (elpy-shell--flash-and-message-region (region-beginning) (region-end))
1078     (elpy-shell--flash-and-message-region (point-min) (point-max)))
1079   (elpy-shell--with-maybe-echo
1080    (elpy-shell--send-region-or-buffer-internal arg))
1081   (if (use-region-p)
1082       (goto-char (region-end))
1083     (goto-char (point-max))))
1084
1085 (defun elpy-shell--send-region-or-buffer-internal (&optional arg)
1086   "Send the active region or the buffer to the Python shell and step.
1087
1088 If there is an active region, send that. Otherwise, send the
1089 whole buffer.
1090
1091 In Emacs 24.3 and later, without prefix argument and when there
1092 is no active region, this will escape the Python idiom of if
1093 __name__ == '__main__' to be false to avoid accidental execution
1094 of code. With prefix argument, this code is executed."
1095   (interactive "P")
1096   (elpy-shell--ensure-shell-running)
1097   (unless elpy-shell-echo-input (elpy-shell--append-to-shell-output "\n"))
1098   (let ((if-main-regex "^if +__name__ +== +[\"']__main__[\"'] *:")
1099         (has-if-main-and-removed nil))
1100     (if (use-region-p)
1101         (let ((region (python-shell-buffer-substring
1102                        (region-beginning) (region-end)))
1103               (region-original (buffer-substring
1104                                 (region-beginning) (region-end))))
1105           (when (string-match "\t" region)
1106             (message "Region contained tabs, this might cause weird errors"))
1107           ;; python-shell-buffer-substring (intentionally?) does not accurately
1108           ;; respect (region-beginning); it always start on the first character
1109           ;; of the respective line even if that's before the region beginning
1110           ;; Here we post-process the output to remove the characters before
1111           ;; (region-beginning) and the start of the line. The end of the region
1112           ;; is handled correctly and needs no special treatment.
1113           (let* ((bounds (save-excursion
1114                            (goto-char (region-beginning))
1115                            (bounds-of-thing-at-point 'line)))
1116                  (used-part (string-trim
1117                              (buffer-substring-no-properties
1118                               (car bounds)
1119                               (min (cdr bounds) (region-end)))))
1120                  (relevant-part (string-trim
1121                                  (buffer-substring-no-properties
1122                                   (max (car bounds) (region-beginning))
1123                                   (min (cdr bounds) (region-end))))))
1124             (setq region
1125                   ;; replace just first match
1126                   (replace-regexp-in-string
1127                    (concat "\\(" (regexp-quote used-part) "\\)\\(?:.*\n?\\)*\\'")
1128                    relevant-part
1129                    region t t 1))
1130             (elpy-shell--add-to-shell-history region-original)
1131             (python-shell-send-string region)))
1132       (unless arg
1133         (save-excursion
1134           (goto-char (point-min))
1135           (setq has-if-main-and-removed (re-search-forward if-main-regex nil t))))
1136       (python-shell-send-buffer arg))
1137     (when has-if-main-and-removed
1138       (message (concat "Removed if __name__ == '__main__' construct, "
1139                        "use a prefix argument to evaluate.")))))
1140
1141 (defun elpy-shell-send-buffer-and-step (&optional arg)
1142   "Send entire buffer to Python shell.
1143
1144 In Emacs 24.3 and later, without prefix argument, this will
1145 escape the Python idiom of if __name__ == '__main__' to be false
1146 to avoid accidental execution of code. With prefix argument, this
1147 code is executed."
1148   (interactive "P")
1149   (let ((p))
1150     (save-mark-and-excursion
1151       (deactivate-mark)
1152       (elpy-shell-send-region-or-buffer-and-step arg)
1153       (setq p (point)))
1154     (goto-char p)))
1155
1156 (defun elpy-shell--add-to-shell-history (string)
1157   "Add STRING to the shell command history."
1158   (when elpy-shell-add-to-shell-history
1159     (with-current-buffer (process-buffer (elpy-shell-get-or-create-process))
1160       (comint-add-to-input-history (string-trim string)))))
1161
1162
1163 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1164 ;; Send command variations (with/without step; with/without go)
1165
1166 (defun elpy-shell--send-with-step-go (step-fun step go my-prefix-arg)
1167   "Run a function with STEP and/or GO.
1168
1169 STEP-FUN should be a function that sends something to the shell
1170 and moves point to code position right after what has been sent.
1171
1172 When STEP is nil, keeps point position. When GO is non-nil,
1173 switches focus to Python shell buffer."
1174   (let ((orig (point)))
1175     (setq current-prefix-arg my-prefix-arg)
1176     (call-interactively step-fun)
1177     (unless step
1178       (goto-char orig)))
1179   (when go
1180     (elpy-shell-switch-to-shell)))
1181
1182 (defmacro elpy-shell--defun-step-go (fun-and-step)
1183   "Defines fun, fun-and-go, fun-and-step-and-go for the given FUN-AND-STEP function."
1184   (let ((name (string-remove-suffix "-and-step" (symbol-name fun-and-step))))
1185     (list
1186      'progn
1187      (let ((fun (intern name)))
1188        `(defun ,fun (&optional arg)
1189           ,(concat "Run `" (symbol-name fun-and-step) "' but retain point position.")
1190           (interactive "P")
1191           (elpy-shell--send-with-step-go ',fun-and-step nil nil arg)))
1192      (let ((fun-and-go (intern (concat name "-and-go"))))
1193        `(defun ,fun-and-go (&optional arg)
1194           ,(concat "Run `" (symbol-name fun-and-step) "' but retain point position and switch to Python shell.")
1195           (interactive "P")
1196           (elpy-shell--send-with-step-go ',fun-and-step nil t arg)))
1197      (let ((fun-and-step-and-go (intern (concat name "-and-step-and-go"))))
1198        `(defun ,fun-and-step-and-go (&optional arg)
1199           ,(concat "Run `" (symbol-name fun-and-step) "' and switch to Python shell.")
1200           (interactive "P")
1201           (elpy-shell--send-with-step-go ',fun-and-step t t arg))))))
1202
1203 (elpy-shell--defun-step-go elpy-shell-send-statement-and-step)
1204 (elpy-shell--defun-step-go elpy-shell-send-top-statement-and-step)
1205 (elpy-shell--defun-step-go elpy-shell-send-defun-and-step)
1206 (elpy-shell--defun-step-go elpy-shell-send-defclass-and-step)
1207 (elpy-shell--defun-step-go elpy-shell-send-group-and-step)
1208 (elpy-shell--defun-step-go elpy-shell-send-codecell-and-step)
1209 (elpy-shell--defun-step-go elpy-shell-send-region-or-buffer-and-step)
1210 (elpy-shell--defun-step-go elpy-shell-send-buffer-and-step)
1211
1212
1213 ;;;;;;;;;;;;;;;;;;;;;;;
1214 ;; Debugging features
1215
1216 (when (version<= "25" emacs-version)
1217
1218   (defun elpy-pdb--refresh-breakpoints (lines)
1219     "Add new breakpoints at lines LINES of the current buffer."
1220     ;; Forget old breakpoints
1221     (python-shell-send-string-no-output "import bdb as __bdb; __bdb.Breakpoint.bplist={}; __bdb.Breakpoint.next=1;__bdb.Breakpoint.bpbynumber=[None]")
1222     (python-shell-send-string-no-output "import pdb; __pdbi = pdb.Pdb()")
1223     (dolist (line lines)
1224       (python-shell-send-string-no-output
1225        (format "__pdbi.set_break('''%s''', %s)" (buffer-file-name) line))))
1226
1227   (defun elpy-pdb--start-pdb (&optional output)
1228     "Start pdb on the current script.
1229
1230 if OUTPUT is non-nil, display the prompt after execution."
1231     (let ((string (format "__pdbi._runscript('''%s''')" (buffer-file-name))))
1232       (if output
1233           (python-shell-send-string string)
1234         (python-shell-send-string-no-output string))))
1235
1236   (defun elpy-pdb--get-breakpoint-positions ()
1237     "Return a list of lines with breakpoints."
1238     (let* ((overlays (overlay-lists))
1239            (overlays (append (car overlays) (cdr overlays)))
1240            (bp-lines '()))
1241       (dolist (ov overlays)
1242         (when (overlay-get ov 'elpy-breakpoint)
1243           (push (line-number-at-pos (overlay-start ov))
1244                 bp-lines)))
1245       bp-lines))
1246
1247   (defun elpy-pdb-debug-buffer (&optional arg)
1248     "Run pdb on the current buffer.
1249
1250 If breakpoints are set in the current buffer, jump to the first one.
1251 If no breakpoints are set, debug from the beginning of the script.
1252
1253 With a prefix argument, ignore the existing breakpoints."
1254     (interactive "P")
1255     (if (not (buffer-file-name))
1256         (error "Debugging only work for buffers visiting a file")
1257       (elpy-shell--ensure-shell-running)
1258       (save-buffer)
1259       (let ((bp-lines (elpy-pdb--get-breakpoint-positions)))
1260         (if (or arg (= 0 (length bp-lines)))
1261             (progn
1262               (elpy-pdb--refresh-breakpoints '())
1263               (elpy-pdb--start-pdb t))
1264           (elpy-pdb--refresh-breakpoints bp-lines)
1265           (elpy-pdb--start-pdb)
1266           (python-shell-send-string "continue")))
1267       (elpy-shell-display-buffer)))
1268
1269   (defun elpy-pdb-break-at-point ()
1270     "Run pdb on the current buffer and break at the current line.
1271
1272 Ignore the existing breakpoints.
1273 Pdb can directly exit if the current line is not a statement
1274 that is actually run (blank line, comment line, ...)."
1275     (interactive)
1276     (if (not (buffer-file-name))
1277         (error "Debugging only work for buffers visiting a file")
1278       (elpy-shell--ensure-shell-running)
1279       (save-buffer)
1280       (elpy-pdb--refresh-breakpoints (list (line-number-at-pos)))
1281       (elpy-pdb--start-pdb)
1282       (python-shell-send-string "continue")
1283       (elpy-shell-display-buffer)))
1284
1285   (defun elpy-pdb-debug-last-exception ()
1286     "Run post-mortem pdb on the last exception."
1287     (interactive)
1288     (elpy-shell--ensure-shell-running)
1289     ;; check if there is a last exception
1290     (if (not (with-current-buffer (format "*%s*"
1291                                           (python-shell-get-process-name nil))
1292                (save-excursion
1293                  (goto-char (point-max))
1294                  (search-backward "Traceback (most recent call last):"
1295                                   nil t))))
1296         (error "No traceback on the current shell")
1297       (python-shell-send-string
1298        "import pdb as __pdb;__pdb.pm()"))
1299     (elpy-shell-display-buffer))
1300
1301   ;; Fringe indicators
1302
1303   (when (fboundp 'define-fringe-bitmap)
1304     (define-fringe-bitmap 'elpy-breakpoint-fringe-marker
1305       (vector
1306        #b00000000
1307        #b00111100
1308        #b01111110
1309        #b01111110
1310        #b01111110
1311        #b01111110
1312        #b00111100
1313        #b00000000)))
1314
1315   (defcustom elpy-breakpoint-fringe-face 'elpy-breakpoint-fringe-face
1316     "Face for breakpoint bitmaps appearing on the fringe."
1317     :type 'face
1318     :group 'elpy)
1319
1320   (defface elpy-breakpoint-fringe-face
1321     '((t (:foreground "red"
1322           :box (:line-width 1 :color "red" :style released-button))))
1323     "Face for breakpoint bitmaps appearing on the fringe."
1324     :group 'elpy)
1325
1326   (defun elpy-pdb-toggle-breakpoint-at-point (&optional arg)
1327     "Add or remove a breakpoint at the current line.
1328
1329 With a prefix argument, remove all the breakpoints from the current
1330 region or buffer."
1331     (interactive "P")
1332     (if arg
1333         (elpy-pdb-clear-breakpoints)
1334       (let ((overlays (overlays-in (line-beginning-position)
1335                                    (line-end-position)))
1336             bp-at-line)
1337         ;; Check if already a breakpoint
1338         (while overlays
1339           (let ((overlay (pop overlays)))
1340             (when (overlay-get overlay 'elpy-breakpoint)
1341               (setq bp-at-line t))))
1342         (if bp-at-line
1343             ;; If so, remove it
1344             (remove-overlays (line-beginning-position)
1345                              (line-end-position)
1346                              'elpy-breakpoint t)
1347           ;; Check it the line is empty
1348           (if (not (save-excursion
1349                      (beginning-of-line)
1350                      (looking-at "[[:space:]]*$")))
1351               ;; Else add a new breakpoint
1352               (let* ((ov (make-overlay (line-beginning-position)
1353                                        (+ 1 (line-beginning-position))))
1354                      (marker-string "*fringe-dummy*")
1355                      (marker-length (length marker-string)))
1356                 (put-text-property 0 marker-length
1357                                    'display
1358                                    (list 'left-fringe
1359                                          'elpy-breakpoint-fringe-marker
1360                                          'elpy-breakpoint-fringe-face)
1361                                    marker-string)
1362                 (overlay-put ov 'before-string marker-string)
1363                 (overlay-put ov 'priority 200)
1364                 (overlay-put ov 'elpy-breakpoint t)))))))
1365
1366   (defun elpy-pdb-clear-breakpoints ()
1367     "Remove the breakpoints in the current region or buffer."
1368     (if (use-region-p)
1369         (remove-overlays (region-beginning) (region-end) 'elpy-breakpoint t)
1370       (remove-overlays (point-min) (point-max) 'elpy-breakpoint t))))
1371
1372
1373 ;;;;;;;;;;;;;;;;;;;;;;;
1374 ;; Deprecated functions
1375
1376 (defun elpy-use-ipython (&optional _ipython)
1377   "Deprecated; see https://elpy.readthedocs.io/en/latest/ide.html#interpreter-setup"
1378   (error "elpy-use-ipython is deprecated; see https://elpy.readthedocs.io/en/latest/ide.html#interpreter-setup"))
1379 (make-obsolete 'elpy-use-ipython nil "Jan 2017")
1380
1381 (defun elpy-use-cpython (&optional _cpython)
1382   "Deprecated; see https://elpy.readthedocs.io/en/latest/ide.html#interpreter-setup"
1383   (error "elpy-use-cpython is deprecated; see https://elpy.readthedocs.io/en/latest/ide.html#interpreter-setup"))
1384 (make-obsolete 'elpy-use-cpython nil "Jan 2017")
1385
1386 (provide 'elpy-shell)
1387 ;;; elpy-shell.el ends here