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

Essayez d'ajouter ceci à votre config.el privé:

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

Merci pour la réponse rapide. Malheureusement, cela ne résout pas le problème.

J'ai également essayé avec un bloc de code plus 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

Voici ma configuration actuelle ("nouvel utilisateur"):

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

Supprimez l'appel org-babel-do-load-languages . Il est redondant avec le mécanisme de chargement paresseux de Doom pour les plugins babel. Je ne sais pas si cela résoudra votre problème, mais c'est possible.

Sinon, essayez de passer du package jupyter à :lang (org +ipython) place. Il est probable que le paquet jupyter emacs fasse quelque chose de non standard.

Essayez également d'ajouter :async yes ou :async no à vos blocs src et voyez si cela fait une différence.

Le problème avec ob-ipython, c'est que je n'arrive pas à pouvoir utiliser un environnement activé avec + conda. De plus, ob-ipython semble perdre son support.

Je voulais essayer emacs-jupyter, car il était capable de récupérer l'environnement conda par défaut et avait également le potentiel d'utiliser R et des noyaux distants.

Comment puis-je ajouter le jupyter à org babel si ce n'est pas avec org-babel-do-load-languages ?

emacs-jupyter n'utilise pas ob-async . Vous devez disposer du paramètre suivant pour que jupyter fonctionne correctement.

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

J'ai ajouté une fonctionnalité +jupyter à :lang org qui définit ob-async-no-async-languages-alist et +org-babel-load-functions . Faites-moi savoir si cela résout votre problème.

Merci @randomizedthinking et @hlissner pour votre aide.

Après avoir ajouté +jupyter dans la configuration org de .doom.d/init.el, it seems babel does not pick up that language: org-babel-execute-src-block: Pas de fonction org-babel-execute pour jupyter-python! `

De plus, emacs-jupyter peut être utilisé comme réplique directe pour les fichiers python. Ce n'est pas seulement une intégration avec le mode org comme l'est ob-ipython. Pour vous dire la vérité, je suis nouveau dans doom / emacs et j'ai à peine utilisé emacs-jupyter, mais je pouvais voir que le repl fourni par emacs-jupyter est largement supérieur, fournissant une auto-complétion puissante, un support pour les images en tampon, etc. .

Tout cela pour se demander, est-ce qu'emacs-jupyter mérite sa configuration dans le cadre du module python?

Bien que j'aie des connaissances très limitées, je suis prêt à vous aider de toutes les manières possibles.

En attendant, j'ai ajouté ceci à mon fichier de configuration:

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

Pour le moment, cela semble bien fonctionner.

Seule l'intégration avec orgmode semble être interrompue.

@pmercatoris Pour que jupyter fonctionne dans org-babel, mon paramètre actuel est le suivant. Par document emacs-jupyter, la langue python (ou toute autre langue que nous prévoyons d'utiliser avec jupyter) doit être incluse avant jupyter .

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

Je pense que ce serait formidable si emacs-jupyter était intégré dans le framework doom emacs.

Merci également d'avoir partagé les raccourcis clavier. Pour toute la fonction d'évaluation, nous pouvons utiliser l'opérateur doom gr - ce serait cohérent cross doom repl.

@pmercatoris Vérifiez si 17d0833 résout votre problème.

Si cela ne fonctionne pas, voyez si le remplacement de +org-babel-load-jupyter-h comme ça aide:

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

@randomizedthinking Essayez-le sans org-babel-do-load-languages . Il a été désactivé dans 3b2a37d9a car il interfère dans tous les cas avec le chargeur paresseux de Doom.

@hlissner ni 17d0833 ni le dépassement ne semblent fonctionner.

J'obtiens: org-babel-execute-src-block: No org-babel-execute function for jupyter-python! sans mise en évidence pour le bloc source

Ok, donc j'ai ajouté ceci au .doom.d / config.el, et maintenant ça marche! :)

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

La seule chose est que la mise en évidence du bloc source ne se charge pas lors de la première visite du fichier. Je dois revoir après avoir exécuté un bloc source. Est-ce que c'est prévu?

Génial, j'ajouterai que le sous-module + jupyter après avoir résolu votre problème de mise en évidence de bloc (ce qui n'est pas prévu, nous avons un chargeur paresseux pour la mise en évidence de bloc, mais jupyter est un plugin babel très inhabituellement structuré).

Voyez si l'ajout de ceci à votre config.el résout le problème:

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

D'accord. Mais il continue d'avoir le même comportement, comme indiqué ci-dessous:

Comment ça se passe lors de la première visite du fichier

Exécutez une cellule et revisitez le fichier:

Avez-vous essayé l'extrait de code mis à jour? Je l'ai amélioré peu de temps après l'avoir publié.

Oui, avec l'extrait de code mis à jour. Voici mon 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
          )))

Avec le code ci-dessus, essayez de modifier +org-babel-load-jupyter-h en:

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

Malheureusement, cela ne fonctionne pas non plus.

Au cas où il pourrait être lié. Le bloc source ne s'exécute qu'après 2 x Cc, Cc
La première fois qu'il répond:

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

Et la deuxième fois que cela fonctionne:

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

Bien que ce soit peut-être le bon comportement, j'ai pensé que je le mentionnerais.

Je viens d'écrire quelques améliorations pour jupyter dans af948ca. Veuillez mettre à jour et laissez-moi savoir si cela résout le problème (et supprimez les suggestions +org-babel-load-functions et +org--src-lazy-load-library-a que je vous ai données jusqu'à présent).

Parfait, donc l'exécution du bloc source fonctionne désormais sans aucune modification du config.el.

Cependant, le problème avec la mise en évidence persiste.

Merci beaucoup pour votre travail.

Je sais que nous devons charger _une_ bibliothèques de jupyter, mais je ne sais pas laquelle et quand. Ce serait beaucoup plus rapide si j'avais un environnement jupyter à tester. Peut-être que chaque module devrait inclure un fichier nix pour configurer un environnement minimum viable pour les tests.

Quoi qu'il en soit, pouvez-vous essayer ça?

(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 ne semble pas avoir beaucoup de compation, car j'ai toujours le même comportement :-(

Je ne sais rien sur Nix, mais ça sonne vraiment comme une fonctionnalité intéressante.

Pourrait-il être lié à ce commentaire?

Notez que jupyter doit être ajouté comme dernier élément lors du chargement des langues car il dépend des valeurs de variables telles que org-src-lang-modes et org-babel-tangle-lang-exts. Une fois ob-jupyter chargé, de nouveaux blocs de code source avec des noms de la forme jupyter-LANG seront disponibles. LANG peut être l'une des langues du noyau présentes sur votre système. Voir jupyter-available-kernelspecs. (Https://github.com/dzop/emacs-jupyter#org-mode-source-blocks)

Pourrait-il être lié à ce commentaire?

C'est vrai, mais j'ai prêté attention à cela avec +org-babel-load-jupyter-h , mais cela refuse toujours de fonctionner. Alors essayons encore une fois:

(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 cela ne fonctionne pas, nous allons simplement recourir à la solution stupide:

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

Je sais que cela fonctionnera, mais je vais devoir dépendre des gens pour élargir cette liste à mesure que jupyter introduit plus de langues.

Donc, apparemment, même la solution stupide ne fonctionne pas pour la mise en évidence. Mais plus important encore, il semble que le org-edit-special ne fonctionnera pas, car il renvoie:
org-edit-src-code: No such language mode: jupyter-python-mode

J'espère avoir tout essayé correctement, comme je l'ai dit, je suis très nouveau à doom, mais je me suis assuré de faire un doom refresh après tout changement.

Oh, oups. Pourriez-vous réessayer ma solution stupide avec (after! org-src ...) au lieu de (after! ob-jupyter ...) ?

Tout fonctionne de ce que je peux voir !! :RÉ

Mise en évidence, exécution de bloc et édition spéciale. Je ne suis donc pas sûr de ce que vous pensez de la solution, mais je suis plutôt content que cela fonctionne :)

Je vous remercie!!

Salut! Je pense que quelque chose ici peut avoir cassé le support R en mode org en utilisant le plugin Jupyter. L'exécution de blocs jupyter-python fonctionne bien:

Mais l'exécution de blocs jupyter-R ne permet pas:

Des conseils sur la façon de procéder?

@mbosley https://github.com/hlissner/doom-emacs/pull/2477 résoudra probablement votre problème.

En attendant, je fermerai ce fil puisque le problème de l'OP a été résolu.