Doom-emacs: [BUG] ob-async com emacs-jupyter

Tente adicionar isto ao seu config.el privado:

(add-hook! '+org-babel-load-functions
  (defun +org-babel-load-jupyter-h (lang)
    (and (string-prefix-p "jupyter-" (symbol-name lang))
         (require lang nil t))))

Obrigado pela resposta rápida. Infelizmente, isso não corrige.

Também tentei com um bloco de código mais simples:

#+begin_src jupyter-python :session py :results raw drawer
print('test')
#+end_src

#+RESULTS:
: test

#+begin_src jupyter-python :session py :results raw drawer
print('test')
#+end_src

#+RESULTS:
: c172bf02f62c4210de534c8e3147198b

Aqui está minha configuração atual ("novo usuário"):

;;; .doom.d/config.el -*- lexical-binding: t; -*-

;; Place your private configuration here

(def-package! org
  :config
  ;; (setq python-shell-interpreter "/home/pim/anaconda3/bin/python3")
  ;; (setq org-babel-python-command "/home/pim/anaconda3/bin/python3")
  (setq python-shell-interpreter-args "-m IPython --simple-prompt -i")
  (org-babel-do-load-languages
   'org-babel-load-languages
   '((latex . t)
     (python . t)
     (shell . t)
     (sql . t)
     (jupyter . t))))

(add-hook! '+org-babel-load-functions
  (defun +org-babel-load-jupyter-h (lang)
    (and (string-prefix-p "jupyter-" (symbol-name lang))
         (require lang nil t))))

Remova a chamada org-babel-do-load-languages . É redundante com o próprio mecanismo de carregamento lento do Doom para plug-ins Babel. Não tenho certeza se isso resolverá seu problema, mas pode.

Caso contrário, tente alternar do pacote jupyter para :lang (org +ipython) . É provável que o pacote jupyter emacs esteja fazendo algo fora do padrão.

Além disso, tente adicionar :async yes ou :async no aos seus blocos src e veja se faz diferença.

O problema com ob-ipython, é que não consigo usar um ambiente ativado com + conda. Também ob-ipython parece estar perdendo suporte.

Eu estava querendo experimentar o emacs-jupyter, já que ele é capaz de pegar o ambiente conda por padrão e também tem potencial para usar R e kernels remotos.

Como devo adicionar o jupyter ao org babel se não com org-babel-do-load-languages ?

emacs-jupyter não usa ob-async . Você precisa ter a seguinte configuração para que o jupyter funcione corretamente.

(setq ob-async-no-async-languages-alist
      '("jupyter-python"))

Eu adicionei um recurso +jupyter a :lang org que define ob-async-no-async-languages-alist e +org-babel-load-functions . Deixe-me saber se isso resolve o seu problema.

Obrigado @randomizedthinking e @hlissner por sua ajuda.

Depois de adicionar +jupyter na configuração org de .doom.d/init.el, it seems babel does not pick up that language: org-babel-execute-src-block: Nenhuma função org-babel-execute para jupyter-python! `

Além disso, emacs-jupyter pode ser usado como uma réplica direta para arquivos python. Não é apenas uma integração com o modo org como o ob-ipython. Para dizer a verdade, sou novo no doom / emacs e quase não usei o emacs-jupyter, mas pude ver que o repl fornecido pelo emacs-jupyter é muito superior, fornecendo autocompletar poderoso, suporte para imagens in-buffer, etc. .

Tudo isso para perguntar, o emacs-jupyter merece sua configuração como parte do módulo python?

Embora eu tenha um conhecimento muito limitado, estou disposto a ajudar de qualquer maneira que puder.

Enquanto isso, adicionei isto ao meu arquivo de configuração:

(use-package! jupyter
  :defer t
  :init
  (map! :after python
        :map python-mode-map
        :localleader
        (:prefix ("j" . "jupyter")
          :desc "Run REPL"      "o" #'jupyter-run-repl
          :desc "Eval funciton"      "f" #'jupyter-eval-defun
          :desc "Eval buffer"      "b" #'jupyter-eval-buffer
          :desc "Eval region"      "r" #'jupyter-eval-region
          :desc "Restart REPL"      "R" #'jupyter-repl-restart-kernel
          :desc "Interrupt REPL"      "i" #'jupyter-repl-interrup-kernel
          :desc "Scratch buffer"      "s" #'jupyter-repl-scratch-buffer
          :desc "Remove overlays"      "O" #'jupyter-eval-remove-overlays
          :desc "Eval string"      "w" #'jupyter-eval-string
          :desc "Inspect at point"      "d" #'jupyter-inspect-at-point
          )))

Por enquanto, parece funcionar bem.

Apenas a integração com orgmode parece estar quebrada.

@pmercatoris Para que o jupyter funcione no org-babel, minha configuração atual é a seguinte. Por documento emacs-jupyter, a linguagem python (ou qualquer outra linguagem que planejamos usar com o jupyter) precisa ser incluída antes de jupyter .

(org-babel-do-load-languages
 'org-babel-load-languages
 '((shell . t)
   (emacs-lisp . t)
   (python . t)
   (jupyter . t)))

Em segundo lugar, seria ótimo se o emacs-jupyter fosse integrado ao framework doom emacs.

Obrigado também por compartilhar os atalhos de teclado. Para todas as funções de avaliação, podemos usar o atual operador doom gr - seria consistente cross doom repl.

@pmercatoris Veja se 17d0833 resolve seu problema.

Se isso não funcionar, veja se substituir +org-babel-load-jupyter-h assim ajuda:

(defun +org-babel-load-jupyter-h (lang)
  (and (string-prefix-p "jupyter-" (symbol-name lang))
       (require 'ob-python)
       (require lang nil t)))

@randomizedthinking Por favor, tente sem org-babel-do-load-languages . Ele foi desabilitado em 3b2a37d9a porque interfere no lazy loader do Doom, em qualquer caso.

@hlissner nem 17d0833 nem a substituição parecem funcionar.

Eu obtenho: org-babel-execute-src-block: No org-babel-execute function for jupyter-python! sem nenhum destaque para o bloco de origem

Ok, então eu adicionei isso ao .doom.d / config.el, e agora funciona! :)

(add-hook! '+org-babel-load-functions
    (defun +org-babel-load-jupyter-h (lang)
      (and (string-prefix-p "jupyter-" (symbol-name lang))
       (require 'ob-jupyter)
           (require lang nil t))))

A única coisa é que o realce do bloco de origem não carrega ao visitar o arquivo pela primeira vez. Preciso revisitar depois de executar um bloco de origem. Isso é intencional?

Ótimo, acrescentarei o submódulo + jupyter depois de descobrirmos seu problema de realce de bloco (o que não foi pretendido, temos um carregador lento para realce de bloco, mas o jupyter é um plugin babel muito incomumente estruturado).

Veja se adicionar isso ao seu config.el resolve o problema:

(after! org
  (defadvice! +org--src-lazy-load-library-a (lang)
    "Lazy load a babel package to ensure syntax highlighting."
    :before #'org-src--get-lang-mode
    (unless (cdr (assoc lang org-src-lang-modes))
      (or (run-hook-with-args-until-success '+org-babel-load-functions lang)
          (require (intern-soft (format "ob-%s" lang)) nil t)
          (require lang nil t)))))

Está bem. Mas continua tendo o mesmo comportamento, conforme mostrado a seguir:

Como fica na primeira visita do arquivo

Execute uma célula e revisite o arquivo:

Você tentou o snippet atualizado? Eu o melhorei logo após postá-lo.

Sim, com o trecho atualizado. Aqui está meu config.el:

;;; .doom.d/config.el -*- lexical-binding: t; -*-

;; Place your private configuration here
;;

(setq python-shell-interpreter "ipython"
      python-shell-interpreter-args "--simple-prompt -i")

(after! org
  (defadvice! +org--src-lazy-load-library-a (lang)
    "Lazy load a babel package to ensure syntax highlighting."
    :before #'org-src--get-lang-mode
    (unless (cdr (assoc lang org-src-lang-modes))
      (or (run-hook-with-args-until-success '+org-babel-load-functions lang)
          (require (intern-soft (format "ob-%s" lang)) nil t)
          (require lang nil t)))))

(add-hook! '+org-babel-load-functions
  (defun +org-babel-load-jupyter-h (lang)
    (and (string-prefix-p "jupyter-" (symbol-name lang))
         (require 'ob-jupyter)
         (require lang nil t))))

;; Select window between frames
(after! ace-window
  (setq aw-scope 'global))

;;;
;;; Keybinds

(setq doom-localleader-key ",")

(use-package! jupyter
  :defer t
  :init
  (map! :after python
        :map python-mode-map
        :localleader
        (:prefix ("j" . "jupyter")
          :desc "Run REPL"      "o" #'jupyter-run-repl
          :desc "Eval funciton"      "f" #'jupyter-eval-defun
          :desc "Eval buffer"      "b" #'jupyter-eval-buffer
          :desc "Eval region"      "r" #'jupyter-eval-region
          :desc "Restart REPL"      "R" #'jupyter-repl-restart-kernel
          :desc "Interrupt REPL"      "i" #'jupyter-repl-interrupt-kernel
          :desc "Scratch buffer"      "s" #'jupyter-repl-scratch-buffer
          :desc "Remove overlays"      "O" #'jupyter-eval-remove-overlays
          :desc "Eval string"      "w" #'jupyter-eval-string-command
          :desc "Inspect at point"      "d" #'jupyter-inspect-at-point
          :desc "Associate buffer REPL"      "B" #'jupyter-repl-associate-buffer
          )))

Com o código acima, tente modificar +org-babel-load-jupyter-h para:

(defun +org-babel-load-jupyter-h (lang)
  (and (string-prefix-p "jupyter-" (symbol-name lang))
       (require (intern
                 (format "ob-%s"
                         (string-remove-prefix "jupyter-" (symbol-name lang))))
                nil t)
       (require 'ob-jupyter nil t)
       (require lang nil t)))

Infelizmente, isso também não está funcionando.

No caso de estar vinculado. O bloco de origem só executa após 2 x Cc, Cc
Na primeira vez que responde:

executing Jupyter-Python code block...
org-babel-jupyter-session-key: Need a valid session and a kernel to form a key

E na segunda vez funciona:

executing Jupyter-Python code block...
Starting python3 kernel process...done
Requesting kernel info...done
Code block evaluation complete. [2 times]

Porém, pode ser o comportamento correto, pensei em mencioná-lo.

Acabei de escrever algumas melhorias para o jupyter em af948ca. Atualize e deixe-me saber se isso corrige o problema (e remova as sugestões +org-babel-load-functions e +org--src-lazy-load-library-a que dei até agora).

Perfeito, então a execução do bloco de origem agora funciona sem nenhuma modificação no config.el.

No entanto, o problema com o realce persiste.

Muito obrigado pelo seu trabalho.

Eu sei que temos que carregar _uma_ das bibliotecas do jupyter, mas não sei qual e quando. Isso seria muito mais rápido se eu tivesse um ambiente jupyter para testar. Talvez cada módulo deva incluir um arquivo nix para configurar um ambiente mínimo viável para teste.

De qualquer forma, você poderia tentar isso?

(defadvice! oh-god-please-fix-jupyter-please-oh-please (lang)
  :override #'+org-babel-load-jupyter-h
  (when (string-prefix-p "jupyter-" (symbol-name lang))
    (let ((lang (string-remove-prefix "jupyter-" (symbol-name lang))))
      (unless (assoc lang org-src-lang-modes)
        (require (intern (format "ob-%s" lang))
                 nil t)))
    (with-demoted-errors "Jupyter: %s"
      (require 'jupyter nil t)
      (require lang nil t)
      (require 'ob-jupyter nil t))))

oh-god-please-fix-jupyter-please-oh-please haha não parece ter muita compaixão, pois ainda obtenho o mesmo comportamento :-(

Não sei nada sobre o Nix, mas definitivamente parece um bom recurso.

Poderia estar vinculado a este comentário?

Observe que jupyter deve ser adicionado como o último elemento ao carregar idiomas, pois depende dos valores de variáveis ​​como org-src-lang-modes e org-babel-tangle-lang-exts. Depois que ob-jupyter for carregado, novos blocos de código-fonte com nomes no formato jupyter-LANG estarão disponíveis. LANG pode ser qualquer uma das linguagens do kernel encontradas em seu sistema. Consulte jupyter-available-kernelspecs. (Https://github.com/dzop/emacs-jupyter#org-mode-source-blocks)

Poderia estar vinculado a este comentário?

É, mas prestei atenção nisso com +org-babel-load-jupyter-h , mas ainda se recusa a funcionar. Então, vamos tentar mais uma vez:

(defadvice! oh-god-please-fix-jupyter-please-oh-please (lang)
  :override #'+org-babel-load-jupyter-h
  (when (string-prefix-p "jupyter-" (symbol-name lang))
    (let* ((lang-name (symbol-name lang))
           (lang-tail (string-remove-prefix "jupyter-" lang-name)))
      (and (not (assoc lang-tail org-src-lang-modes))
           (require (intern (format "ob-%s" lang-tail))
                    nil t)
           (add-to-list 'org-src-lang-modes (cons lang-name (intern lang-tail)))))
    (with-demoted-errors "Jupyter: %s"
      (require lang nil t)
      (require 'ob-jupyter nil t))))

Se isso não funcionar, então vamos apenas recorrer à solução idiota:

(after! ob-jupyter
  (dolist (lang '(python julia R))
    (cl-pushnew (cons (format "jupyter-%s" lang) lang)
                org-src-lang-modes :key #'car)))

Eu sei que isso vai funcionar, mas terei que depender de pessoas para expandir essa lista à medida que o jupyter introduz mais idiomas.

Então, aparentemente nem mesmo a solução idiota funciona para o realce. Mas o mais importante, parece que org-edit-special não funcionará, pois retorna:
org-edit-src-code: No such language mode: jupyter-python-mode

Espero ter tentado tudo corretamente, como disse, sou muito novo no Doom, mas certifique-se de fazer doom refresh após qualquer alteração.

Oh, opa. Você poderia tentar minha solução idiota novamente com (after! org-src ...) vez de (after! ob-jupyter ...) ?

Tudo funcionando pelo que posso ver !! : D

Realce, execução de bloco e edição especial. Não tenho certeza de como você se sente sobre a solução, mas fico feliz que esteja funcionando :)

Obrigado!!

Oi! Acho que algo aqui pode ter quebrado o suporte R no modo org usando o plugin Jupyter. A execução de blocos jupyter-python funciona bem:

Mas a execução de blocos jupyter-R não:

Algum conselho sobre como proceder?

@mbosley https://github.com/hlissner/doom-emacs/pull/2477 provavelmente resolverá seu problema.

Enquanto isso, fecharei este tópico, pois o problema do OP foi resolvido.