~a-roehler/python-mode/components-python-mode

;; python-components-intern.el --- Part of python-components-mode -*- lexical-binding: t; -*-

;; Helper functions

;; Copyright (C) 2015-2016 Andreas Röhler

;; Author: Andreas Röhler <andreas.roehler@online.de>

;; Keywords: languages, processes

;; 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 <http://www.gnu.org/licenses/>.

;;; Commentary:

;;

;;; Code:

;;  Keymap

(defun ar--beginning-of-form-intern (regexp &optional iact indent orig lc)

  "Go to beginning of FORM.

With INDENT, go to beginning one level above.

Whit IACT, print result in message buffer.

Returns beginning of FORM if successful, nil otherwise"

  (interactive "P")

  (let (erg)

    (unless (bobp)

      (let* ((orig (or orig (point)))

             (indent (or indent (progn

                                  (back-to-indentation)

                                  (or (ar--beginning-of-statement-p)

                                      (ar-backward-statement))

                                  (current-indentation)))))

        (setq erg (cond ((and (< (point) orig) (looking-at (symbol-value regexp)))

                         (point))

                        ((and (eq 0 (current-column)) (numberp indent) (< 0 indent))

                         (when (< 0 (abs (skip-chars-backward " \t\r\n\f")))

                           (ar-backward-statement)

                           (unless (looking-at (symbol-value regexp))

                             (cdr (ar--go-to-keyword (symbol-value regexp) (current-indentation))))))

                        ((numberp indent)

			 (cdr (ar--go-to-keyword (symbol-value regexp) indent)))

                        (t (ignore-errors

                             (cdr (ar--go-to-keyword (symbol-value regexp)

                                                    (- (progn (if (ar--beginning-of-statement-p) (current-indentation) (save-excursion (ar-backward-statement) (current-indentation)))) py-indent-offset)))))))

        (when lc (beginning-of-line) (setq erg (point)))))

    ;; (when (and ar-verbose-p iact) (message "%s" erg))

    erg))

(defun py--indent-prepare (inter-re)

  (progn (back-to-indentation)

	 (or (ar--beginning-of-statement-p)

	     (ar-backward-statement))

	 (cond ((eq 0 (current-indentation))

		(current-indentation))

	       ((looking-at (symbol-value inter-re))

		(current-indentation))

	       (t

		(if (<= py-indent-offset (current-indentation))

		    (- (current-indentation) (if ar-smart-indentation (ar-guess-indent-offset) py-indent-offset))

		  py-indent-offset)))))

(defun ar--beginning-of-prepare (indent final-re &optional inter-re iact lc)

  (let ((orig (point))

        (indent (or indent (py--indent-prepare inter-re)))

        erg)

    (if (and (< (point) orig) (looking-at (symbol-value final-re)))

        (progn

          (and lc (beginning-of-line))

          (setq erg (point))

          ;; (when (and ar-verbose-p iact) (message "%s" erg))

          erg)

      (ar--beginning-of-form-intern final-re iact indent orig lc))))

(defun ar--end-of-prepare (indent final-re &optional inter-re iact lc)

  (let ((orig (point))

        (indent

         (or indent

             (progn (back-to-indentation)

                    (or (ar--beginning-of-statement-p)

                        (ar-backward-statement))

                    (cond ((eq 0 (current-indentation))

                           (current-indentation))

                          ((looking-at (symbol-value inter-re))

                           (current-indentation))

                          (t

                           (if (<= py-indent-offset (current-indentation))

                               (- (current-indentation) (if ar-smart-indentation (ar-guess-indent-offset) py-indent-offset))

                             py-indent-offset))))))

        erg)

    (if (and (< orig (point)) (looking-at (symbol-value final-re)))

        (progn

          (and lc (beginning-of-line))

          (setq erg (point))

          ;; (when (and ar-verbose-p iact) (message "%s" erg))

          erg)

      (ar--beginning-of-form-intern final-re iact indent orig lc))))

(defun py-separator-char ()

  "Return the file-path separator char from current machine.

When `py-separator-char' is customized, its taken.

Returns char found. "

  (let ((erg (cond ((characterp py-separator-char)

                    (char-to-string py-separator-char))

                   ;; epd hack

                   ((and

                     (string-match "[Ii][Pp]ython" py-shell-name)

                     (string-match "epd\\|EPD" py-shell-name))

                    (replace-regexp-in-string "\n" ""

                                              (shell-command-to-string (concat py-shell-name " -c \"import os; print(os.sep)\"")))))))

    (if (and erg (string-match "^$" erg))

        (setq erg (substring erg (string-match "^$" erg)))

      (setq erg (replace-regexp-in-string "\n" "" (shell-command-to-string (concat py-shell-name " -W ignore" " -c \"import os; print(os.sep)\"")))))

    erg))

(defun pps-emacs-version ()

  "Include the appropriate `parse-partial-sexp' "

  (if (featurep 'xemacs)

      '(parse-partial-sexp (point-min) (point))

    '(parse-partial-sexp (point-min) (point))))

(defun py-in-comment-p ()

  "Return the beginning of current line's comment, if inside. "

  (interactive)

  (let* ((pps (parse-partial-sexp (point-min) (point)))

	 (erg (and (nth 4 pps) (nth 8 pps))))

    erg))

;;

(defun py-in-string-or-comment-p ()

  "Returns beginning position if inside a string or comment, nil otherwise. "

  (or (nth 8 (parse-partial-sexp (point-min) (point)))

      (when (or (looking-at "\"")(looking-at "[ \t]*#[ \t]*"))

        (point))))

(when py-org-cycle-p

  (define-key python-mode-map (kbd "<backtab>") 'org-cycle))

(defun py--buffer-filename-remote-maybe (&optional file-name buffer)

  (let ((file-name (or file-name (ignore-errors (file-readable-p (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--execute-prepare (form &optional shell dedicated switch beg end file fast proc wholebuf split)

  "Used by python-extended-executes ."

  (save-excursion

    (let* ((form (prin1-to-string form))

	   (origline (py-count-lines))

	   (beg (unless file

                  (prog1

                      (or beg (funcall (intern-soft (concat "py--beginning-of-" form "-p")))

                          (funcall (intern-soft (concat "py-backward-" form)))

                          (push-mark)))))

           (end (unless file

                  (or end (funcall (intern-soft (concat "py-forward-" form))))))

           filename)

      (setq py-buffer-name nil)

      (if file

          (progn

            (setq filename (expand-file-name form))

            (if (file-readable-p filename)

                (py--execute-file-base nil filename nil nil origline)

              (message "%s not readable. %s" file "Do you have write permissions?")))

        (py--execute-base beg end shell filename proc file wholebuf fast dedicated split switch)))))

(defun py-load-skeletons ()

  "Load skeletons from extensions. "

  (interactive)

  (load (concat py-install-directory "/extensions/python-components-skeletons.el")))

(defun py--kill-emacs-hook ()

  "Delete files in `py-file-queue'.

These are Python temporary files awaiting execution."

  (mapc #'(lambda (filename)

            (ignore-errors (delete-file filename)))

        py-file-queue))

;;  Add a designator to the minor mode strings

(or (assq 'py-pdbtrack-is-tracking-p minor-mode-alist)

    (push '(py-pdbtrack-is-tracking-p py-pdbtrack-minor-mode-string)

          minor-mode-alist))

;;  bottle.py

;;  py   = sys.version_info

;;  py3k = py >= (3,0,0)

;;  py25 = py <  (2,6,0)

;;  py31 = (3,1,0) <= py < (3,2,0)

;;  sys.version_info[0]

(defun py-python-version (&optional executable verbose)

  "Returns versions number of a Python EXECUTABLE, string.

If no EXECUTABLE given, `py-shell-name' is used.

Interactively output of `--version' is displayed. "

  (interactive)

  (let* ((executable (or executable py-shell-name))

         (erg (py--string-strip (shell-command-to-string (concat executable " --version")))))

    (when (called-interactively-p 'any) (message "%s" erg))

    (unless verbose (setq erg (cadr (split-string erg))))

    erg))

(defun py-version ()

  "Echo the current version of `python-mode' in the minibuffer."

  (interactive)

  (message "Using `python-mode' version %s" py-version)

  (py-keep-region-active))

;;  Utility stuff

(declare-function compilation-shell-minor-mode "compile" (&optional arg))

;; dereived from shipped python.el

(defun py-history-input-filter (str)

  "`comint-input-filter' function for Python process.

Don't save anything for STR matching `py-history-filter-regexp'."

  (not (string-match py-history-filter-regexp str)))

(defun py-load-file (file-name)

  "Load a Python file FILE-NAME into the Python process.

If the file has extension `.py' import or reload it as a module.

Treating it as a module keeps the global namespace clean, provides

function location information for debugging, and supports users of

module-qualified names."

  (interactive "f")

  (py--execute-file-base (get-buffer-process (get-buffer (py-shell))) file-name))

(defun py-proc (&optional argprompt)

  "Return the current Python process.

Start a new process if necessary. "

  (interactive "P")

  (let ((erg

         (cond ((comint-check-proc (current-buffer))

		(get-buffer-process (buffer-name (current-buffer))))

	       (t (py-shell argprompt)))))

    ;; (when (called-interactively-p 'any) (message "%S" erg))

    erg))

;;  Miscellany.

(defun py--shell-simple-send (proc strg)

  (let* ((strg (substring-no-properties strg))

         (nln (string-match "\n$" strg)))

    ;; (or nln (setq strg (concat strg "\n")))

    ;; (comint-simple-send proc (substring-no-properties strg))

    (process-send-string proc strg)

    (or nln (process-send-string proc "\n"))))

(defalias

  'py-shell-redirect-send-command-to-process

  'comint-redirect-send-command-to-process)

(defalias

  'py-shell-dynamic-simple-complete

  'comint-dynamic-simple-complete)

;;  Hooks

;;  arrange to kill temp files when Emacs exists

(add-hook 'kill-emacs-hook 'py--kill-emacs-hook)

(when py--warn-tmp-files-left-p

  (add-hook 'python-mode-hook 'py--warn-tmp-files-left))

(defun py-guess-pdb-path ()

  "If py-pdb-path isn't set, find location of pdb.py. "

  (interactive)

  (let ((ele (split-string (shell-command-to-string "whereis python")))

        erg)

    (while (or (not erg)(string= "" erg))

      (when (and (string-match "^/" (car ele)) (not (string-match "/man" (car ele))))

        (setq erg (shell-command-to-string (concat "find " (car ele) " -type f -name \"pdb.py\""))))

      (setq ele (cdr ele)))

    (if erg

        (message "%s" erg)

      (message "%s" "pdb.py not found, please customize `py-pdb-path'"))

    erg))

(if py-mode-output-map

    nil

  (setq py-mode-output-map (make-sparse-keymap))

  (define-key py-mode-output-map [button2]  'py-mouseto-exception)

  (define-key py-mode-output-map "\C-c\C-c" 'py-goto-exception)

  ;; TBD: Disable all self-inserting keys.  This is bogus, we should

  ;; really implement this as *Python Output* buffer being read-only

  (mapc #' (lambda (key)

             (define-key py-mode-output-map key

               #'(lambda () (interactive) (beep))))

           (where-is-internal 'self-insert-command)))

;;  backward compatibility

(defalias 'py-switch-shells 'py-switch-shell)

(defalias 'py-toggle-shell 'py-switch-shell)

(defun py-switch-shell (&optional arg)

  "Toggles between the interpreter customized in `py-shell-toggle-1' resp. `py-shell-toggle-2'. Was hard-coded CPython and Jython in earlier versions, now starts with Python2 and Python3 by default.

ARG might be a python-version string to set to.

\\[universal-argument] `py-toggle-shell' prompts to specify a reachable Python command.

\\[universal-argument] followed by numerical arg 2 or 3, `py-toggle-shell' opens a respective Python shell.

\\[universal-argument] followed by numerical arg 5 opens a Jython shell.

Should you need more shells to select, extend this command by adding inside the first cond:

                    ((eq NUMBER (prefix-numeric-value arg))

                     \"MY-PATH-TO-SHELL\")"

  (interactive "P")

  (let ((name (cond ((eq 2 (prefix-numeric-value arg))

                     "python2")

                    ((eq 3 (prefix-numeric-value arg))

                     "python3")

                    ((eq 4 (prefix-numeric-value arg))

                     (py--string-strip

                      (read-from-minibuffer "Python Shell: " py-shell-name) "\" " "\" "

                      ))

                    ((eq 5 (prefix-numeric-value arg))

                     "jython")

                    (t (if (string-match py-shell-name

                                         py-shell-toggle-1)

                           py-shell-toggle-2

                         py-shell-toggle-1))))

        erg msg)

    (cond ((or (string= "ipython" name)

               (string= "IPython" name))

           (setq py-shell-name name

                 py-which-bufname "IPython"

                 msg "IPython"

                 mode-name "IPython"))

          ((string-match "python3" name)

           (setq py-shell-name name

                 py-which-bufname (py--choose-buffer-name)

                 msg "CPython"

                 mode-name (py--choose-buffer-name)))

          ((string-match "jython" name)

           (setq py-shell-name name

                 py-which-bufname (py--choose-buffer-name)

                 msg "Jython"

                 mode-name (py--choose-buffer-name)))

          ((string-match "python" name)

           (setq py-shell-name name

                 py-which-bufname (py--choose-buffer-name)

                 msg "CPython"

                 mode-name py-which-bufname))

          (t

           (setq py-shell-name name

                 py-which-bufname name

                 msg name

                 mode-name name)))

    ;; py-edit-only-p has no interpreter

    ;; (if py-edit-only-p

    ;; (setq erg py-shell-name)

    (setq erg (executable-find py-shell-name))

    ;;)

    (if erg

        (progn

          (force-mode-line-update)

          (when (called-interactively-p 'any)

            (message "Using the %s shell, %s" msg erg))

          (setq py-output-buffer (format "*%s Output*" py-which-bufname)))

      (error (concat "Could not detect " py-shell-name " on your sys

tem")))))

(defun py-toggle-local-default-use ()

  (interactive)

  "Toggle boolean value of `py-use-local-default'.

Returns `py-use-local-default'

See also `py-install-local-shells'

Installing named virualenv shells is the preffered way,

as it leaves your system default unchanged."

  (setq py-use-local-default (not py-use-local-default))

  (when (called-interactively-p 'any) (message "py-use-local-default set to %s" py-use-local-default))

  py-use-local-default)

(defalias 'py-hungry-delete-forward 'c-hungry-delete-forward)

(defalias 'py-hungry-delete-backwards 'c-hungry-delete-backwards)

;;  FixMe: for unknown reasons this is not done by mode

(if (file-readable-p abbrev-file-name)

    (add-hook 'python-mode-hook

              (lambda ()

                (setq py-this-abbrevs-changed abbrevs-changed)

                (load abbrev-file-name nil t)

                (setq abbrevs-changed py-this-abbrevs-changed)))

  (message "Warning: %s" "no abbrev-file found, customize `abbrev-file-name' in order to make mode-specific abbrevs work. "))

;; ;

(push (list

              'python-mode

              ;; start regex

              (concat (if py-hide-show-hide-docstrings

                          "^\\s-*\"\"\"\\|" "")

                      (mapconcat 'identity

                                 (mapcar #'(lambda (x) (concat "^\\s-*" x "\\_>"))

                                         py-hide-show-keywords)

                                 "\\|"))

              ;; end regex

              nil

              ;; comment-start regex

              "#"

              ;; forward-sexp function

              (lambda ()

                (py-forward-block-or-clause))

              nil) hs-special-modes-alist)

;; ;

(defun py--input-filter (str)

  "`comint-input-filter' function for Python.

Don't save anything for STR matching `py-input-filter-re' "

  (not (string-match py-input-filter-re str)))

(make-obsolete 'jpython-mode 'jython-mode nil)

(push (purecopy "*Python*")  same-window-buffer-names)

(push (purecopy "*IPython*")  same-window-buffer-names)

(push (cons (purecopy "\\.py\\'")  'python-mode)  auto-mode-alist)

;; Python Macro File

(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 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--empty-arglist-indent (nesting &optional indent-offset indent-offset)

  "Internally used by `py-compute-indentation'"

  (if

      (and (eq 1 nesting)

           (save-excursion

             (back-to-indentation)

             (looking-at py-extended-block-or-clause-re)))

      (progn

        (back-to-indentation)

        (+ (current-column) (* 2 (or indent-offset py-indent-offset))))

    (+ (current-indentation) (or indent-offset py-indent-offset))))

(defun py-symbol-at-point ()

  "Return the current Python symbol."

  (interactive)

  (let ((erg (with-syntax-table

                 py-dotted-expression-syntax-table

               (current-word))))

    ;; (when (called-interactively-p 'any) (message "%s" erg))

    erg))

(defun py-kill-buffer-unconditional (buffer)

  "Kill buffer unconditional, kill buffer-process if existing. "

  (interactive

   (list (current-buffer)))

  (let ((buffer (or (and (bufferp buffer) buffer)

		    (get-buffer buffer)))

	proc kill-buffer-query-functions)

    (ignore-errors

      (setq proc (get-buffer-process buffer))

      (and proc (kill-process proc))

      (set-buffer buffer)

      (set-buffer-modified-p 'nil)

      (kill-buffer (current-buffer)))))

(defun py--line-backward-maybe ()

  "Return result of (< 0 (abs (skip-chars-backward \" \\t\\r\\n\\f\"))) "

  (skip-chars-backward " \t\f" (line-beginning-position))

  (< 0 (abs (skip-chars-backward " \t\r\n\f"))))

(defun py--after-empty-line ()

  "Return `t' if line before contains only whitespace characters. "

  (save-excursion

    (beginning-of-line)

    (forward-line -1)

    (beginning-of-line)

    (looking-at "\\s-*$")))

(defalias 'py-count-indentation 'py-compute-indentation)

(defun py-compute-indentation (&optional iact orig origline closing line nesting repeat indent-offset liep)

  "Compute Python indentation.

When HONOR-BLOCK-CLOSE-P is non-nil, statements such as `return',

`raise', `break', `continue', and `pass' force one level of dedenting.

Optional arguments are flags resp. values set and used by `py-compute-indentation' internally:

ORIG keeps original position

ORIGLINE keeps line where compute started

CLOSING is t when started at a char delimiting a list as \"]})\"

LINE indicates being not at origline now

NESTING is currently ignored, if executing from inside a list

REPEAT counter enables checks against `py-max-specpdl-size'

INDENT-OFFSET allows calculation of block-local values

LIEP stores line-end-position at point-of-interest

"

  (interactive "p")

  (save-excursion

    (save-restriction

      (widen)

      ;; in shell, narrow from previous prompt

      ;; needed by closing

      (unless orig (unless (bobp) (back-to-indentation)))

      (let* ((orig (or orig (point)))

             (origline (or origline (py-count-lines (point-min) (point))))

             ;; closing indicates: when started, looked

             ;; at a single closing parenthesis

             ;; line: moved already a line backward

             (liep (or liep (line-end-position)))

             (line line)

	     (verbose py-verbose-p)

             (pps (parse-partial-sexp (point-min) (point)))

             (closing

              (or closing

                  (and (nth 1 pps)

                       (looking-at ".*\\(\\s)\\)")(nth 0 pps)

                       ;; char doesn't matter for now, maybe drop

                       (string-to-char (match-string-no-properties 1)))))

             ;; in a recursive call already

             (repeat (if repeat

			 (setq repeat (1+ repeat))

		       0))

             ;; nesting: started nesting a list

             (nesting nesting)

             (indent-offset (or indent-offset py-indent-offset))

             (cubuf (current-buffer))

             erg indent this-line)

        (if (and (< repeat 1)

                 (and (comint-check-proc (current-buffer))

                      (re-search-backward (concat py-shell-prompt-regexp "\\|" py-ipython-output-prompt-re "\\|" py-ipython-input-prompt-re) nil t 1)))

            ;; common recursion not suitable because of prompt

            (with-temp-buffer

              (insert-buffer-substring cubuf (match-end 0) orig)

              (setq indent (py-compute-indentation)))

	  (if (< py-max-specpdl-size repeat)

	      (error "`py-compute-indentation' reached loops max.")	(setq nesting (nth 0 pps))

	      (setq indent

		    (cond ((bobp)

			   (cond ((eq liep (line-end-position))

				  0)

				 ((looking-at py-outdent-re)

				  (+ (if py-smart-indentation (py-guess-indent-offset) indent-offset) (current-indentation)))

				 (t

				  (current-indentation))))

			  ;; in string

			  ((and (nth 3 pps)(nth 8 pps))

			   (cond

			    ((py--docstring-p)

			     (save-excursion

			       (back-to-indentation)

			       (skip-chars-backward " \t\r\n\f")

			       (back-to-indentation)

			       (current-indentation)))

			    (t 0)))

			  ((and (looking-at "\"\"\"\\|'''")(not (bobp)))

			   (py-backward-statement)