Running on a Shell Inferior Mode

[xmatos-so]

I run a python shell in an inferior mode and it would be cool to have eglot managing that. Is it possible to do something like that, to have eglot running on a shell inferior mode? When I try to start eglot on that buffer I get the following output on its events buffer:

[stderr] nil
[stderr] Process EGLOT (python-ts-mode python-mode) stderr finished

[joaotavora]

No, not possible, since a shell is not a source file. Not without some extremely creative hackery at least, where you take bits of the python shell's input (and output?), and you turn them into LSP documents momentarily, and then somehow you bring those results into the shell buffer. Hurts my brain just to think about it, sorry :-/

[QiangF]

In repl only the text before point on the same line need to be processed. lpy can do completion with lispy-python.el. https://github.com/abo-abo/lpy

    (add-to-list 'completion-at-point-functions 'lispy-python-completion-at-point)
    (defun lispy-python-completion-at-point ()
      (cond ((save-excursion
               (back-to-indentation)
               (looking-at "\\(import\\|from\\) .*"))
             (let* ((line (buffer-substring-no-properties
                           (line-beginning-position)
                           (point)))
                    (str
                     (format "lp.jedi_completions('%s')" line))
                    (cands
                     (lispy--python-array-to-elisp
                      (lispy--eval-python-plain str)))
                    (bnd (bounds-of-thing-at-point 'symbol))
                    (beg (if bnd (car bnd) (point)))
                    (end (if bnd (cdr bnd) (point))))
               (list beg end cands)))
            ((looking-back "\\(?:\\sw\\|\\s_\\|)\\|\\]\\)\\[\\(\\(?:'\\|\"\\)?\\)" (line-beginning-position))
             (let* ((quote_str (match-string-no-properties 1))
                    (bnd (save-excursion
                           (goto-char (1- (match-beginning 1)))
                           (cons (point)
                                 (lispy--python-beginning-of-object))))
                    (str (lispy--string-dwim bnd))
                    (keys (read (lispy--eval-python-plain
                                 (format "lp.print_elisp(%s.keys())" str)))))
               (list (point) (point)
                     (if (> (length quote_str) 0)
                         keys
                       (mapcar
                        (lambda (s)
                          (if (stringp s)
                              (concat "\"" s "\"")
                            (prin1-to-string s)))
                        keys)))))
            ((lispy-complete-fname-at-point))
            (t
             (let* ((bnd (lispy-python-symbol-bnd))
                    (str (buffer-substring-no-properties
                          (car bnd) (cdr bnd)))
                    (str-com str))
               (when (string-match "\\`\\(.*\\)\\.[^.]*\\'" str)
                 (let ((expr (format "__t__ = %s" (substring str 0 (match-end 1)))))
                   (setq str-com (concat "__t__" (substring str (match-end 1))))
                   (cl-incf (car bnd) (1+ (- (match-end 1) (match-beginning 0))))
                   (lispy--eval-python-plain expr)))
               (list (car bnd)
                     (cdr bnd)
                     (let ((out (lispy--eval-python-plain
                                 (format "lp.print_elisp(lp.get_completions('%s'))" str-com))))
                       (with-temp-buffer
                         (insert out)
                         (goto-char (point-min))
                         (when (re-search-forward "^(" nil t)
                           (goto-char (match-beginning 0)))
                         (read (current-buffer)))))))))

[QiangF]

A much simpler line completion might be feasible based on the last comment in this discussion:
#984