Doom-emacs: [ERROR] ob-async con emacs-jupyter

Intente agregar esto a su 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))))

Gracias por la rápida respuesta. Desafortunadamente, no lo soluciona.

También probé con un bloque de código más simple:

#+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

Aquí está mi configuración actual ("nuevo usuario"):

;;; .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))))

Elimina la llamada org-babel-do-load-languages . Es redundante con el propio mecanismo de carga diferida de Doom para los complementos de babel. No estoy seguro de si solucionará el problema, pero podría hacerlo.

De lo contrario, intente cambiar del paquete jupyter a :lang (org +ipython) lugar. Es probable que el paquete jupyter emacs esté haciendo algo no estándar.

Además, intente agregar :async yes o :async no a sus bloques src y vea si hace una diferencia.

El problema con ob-ipython es que parece que no puedo usar un entorno activado con + conda. También ob-ipython parece estar perdiendo soporte.

Quería probar emacs-jupyter, ya que pudo recoger el entorno conda de forma predeterminada y también tiene potencial para usar R y kernels remotos.

¿Cómo debo agregar el jupyter a org babel si no es con org-babel-do-load-languages ?

emacs-jupyter no usa ob-async . Debe tener la siguiente configuración para que jupyter funcione correctamente.

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

Agregué una función +jupyter a :lang org que establece ob-async-no-async-languages-alist y +org-babel-load-functions . Avísame si eso resuelve tu problema.

Gracias @randomizedthinking y @hlissner por su ayuda.

Después de agregar +jupyter en la configuración org de .doom.d/init.el, it seems babel does not pick up that language: org-babel-execute-src-block: ¡No hay función org-babel-execute para jupyter-python!

Además, emacs-jupyter se puede utilizar como respuesta directa para archivos de Python. No es solo una integración con el modo org como lo es ob-ipython. Para decirte la verdad, soy nuevo en doom / emacs y apenas usé emacs-jupyter, pero pude ver que la respuesta proporcionada por emacs-jupyter es muy superior, brindando autocompletado poderoso, soporte para imágenes en búfer, etc. .

Todo esto para preguntar, ¿emacs-jupyter merece su configuración como parte del módulo de Python?

Aunque tengo un conocimiento muy limitado, estoy dispuesto a ayudar con esto de cualquier manera que pueda.

Mientras tanto, agregué esto a mi archivo de configuración:

(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 el momento, parece funcionar bien.

Solo la integración con orgmode parece estar rota.

@pmercatoris Para que jupyter funcione en org-babel, mi configuración actual es la siguiente. Según el documento emacs-jupyter, el idioma python (o cualquier otro idioma que planeemos usar con jupyter) debe incluirse antes del jupyter .

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

Segundo, sería genial si emacs-jupyter se integrara en el marco de Doom emacs.

También gracias por compartir las combinaciones de teclas. Para toda la función de evaluación, podemos usar el operador doom actual gr ; sería una respuesta cruzada consistente.

@pmercatoris Vea si 17d0833 resuelve su problema.

Si eso no funciona, vea si anular +org-babel-load-jupyter-h like so ayuda:

(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, inténtelo sin org-babel-do-load-languages . Se ha desactivado en 3b2a37d9a porque interfiere con el cargador lento de Doom, en cualquier caso.

@hlissner ni 17d0833 ni anular parecen funcionar.

Obtengo: org-babel-execute-src-block: No org-babel-execute function for jupyter-python! sin resaltar el bloque fuente

Ok, agregué esto a .doom.d / config.el, ¡y ahora 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))))

Lo único es que el resaltado del bloque de origen no se carga cuando se visita el archivo por primera vez. Necesito volver a visitar después de ejecutar un bloque fuente. ¿Es eso intencionado?

Genial, agregaré que el submódulo + jupyter después de que averigüemos su problema de resaltado de bloques (lo cual no está previsto, tenemos un cargador perezoso para resaltar bloques, pero jupyter es un complemento de babel estructurado muy inusualmente).

Vea si agregar esto a su config.el resuelve el 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)))))

Okay. Pero sigue teniendo el mismo comportamiento, como se muestra a continuación:

Cómo es en la primera visita de archivo

Ejecute una celda y vuelva a visitar el archivo:

¿Probaste el fragmento actualizado? Lo mejoré poco después de publicarlo.

Sí, con el fragmento actualizado. Aquí está mi 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
          )))

Con el código anterior, intente modificar +org-babel-load-jupyter-h a:

(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)))

Desafortunadamente, eso tampoco está funcionando.

En caso de que esté vinculado. El bloque fuente solo se ejecuta después de 2 x Cc, Cc
La primera vez que responde:

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

Y la segunda vez que funciona:

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

Aunque, podría ser el comportamiento correcto, pensé en mencionarlo.

Acabo de escribir algunas mejoras para jupyter en af948ca. Actualice y avíseme si soluciona el problema (y elimine las sugerencias +org-babel-load-functions y +org--src-lazy-load-library-a que le he dado hasta ahora).

Perfecto, por lo que la ejecución del bloque fuente ahora funciona sin ninguna modificación en config.el.

Sin embargo, persiste el problema con el resaltado.

Muchas gracias por tu trabajo.

Sé que tenemos que cargar _una_ de las bibliotecas de jupyter, pero no sé cuál ni cuándo. Esto sería mucho más rápido si tuviera un entorno jupyter para probar. Quizás cada módulo debería incluir un archivo nix para configurar un entorno viable mínimo para realizar pruebas.

De todos modos, ¿podrías probar esto?

(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 jaja no parece tener mucha comparación, ya que sigo teniendo el mismo comportamiento :-(

No sé nada sobre Nix, pero definitivamente suena como una buena característica.

¿Podría estar vinculado a este comentario?

Tenga en cuenta que jupyter debe agregarse como último elemento al cargar idiomas, ya que depende de los valores de variables como org-src-lang-modes y org-babel-tangle-lang-exts. Después de que se haya cargado ob-jupyter, estarán disponibles nuevos bloques de código fuente con nombres de la forma jupyter-LANG. LANG puede ser cualquiera de los idiomas del kernel que se encuentran en su sistema. Consulte jupyter-available-kernelspecs. (Https://github.com/dzop/emacs-jupyter#org-mode-source-blocks)

¿Podría estar vinculado a este comentario?

Lo es, pero le he prestado atención con +org-babel-load-jupyter-h , pero todavía se niega a funcionar. Así que intentémoslo una vez más:

(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))))

Si esto no funciona, entonces recurriremos a la solución tonta:

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

Sé que esto funcionará, pero tendré que depender de la gente para expandir esta lista a medida que jupyter introduzca más idiomas.

Entonces, aparentemente ni siquiera la solución tonta funciona para resaltar. Pero lo que es más importante, parece que org-edit-special no funcionará, ya que devuelve:
org-edit-src-code: No such language mode: jupyter-python-mode

Espero haber intentado todo correctamente, como dije, soy muy nuevo en Doom, pero me aseguré de hacer un doom refresh después de cualquier cambio.

Oh, vaya. ¿Podrías probar mi solución tonta de nuevo con (after! org-src ...) lugar de (after! ob-jupyter ...) ?

¡Todo trabajando por lo que puedo ver! :RE

Resaltado, ejecución de bloques y edición especial. Así que no estoy seguro de cómo te sientes con la solución, pero me alegro de que esté funcionando :)

¡¡Gracias!!

¡Hola! Creo que algo aquí puede haber roto el soporte de R en modo org usando el complemento Jupyter. La ejecución de bloques jupyter-python funciona bien:

Pero la ejecución de bloques jupyter-R no:

¿Algún consejo sobre cómo proceder?

@mbosley https://github.com/hlissner/doom-emacs/pull/2477 probablemente solucionará su problema.

Mientras tanto, cerraré este hilo ya que se resolvió el problema del OP.