Doom-emacs: [BUG] ob-asynchron mit emacs-jupyter

Versuchen Sie, dies zu Ihrer privaten config.el hinzuzufügen:

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

Danke für die schnelle Antwort. Leider kann es nicht behoben werden.

Ich habe es auch mit einem einfacheren Codeblock versucht:

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

Hier ist meine aktuelle Konfiguration ("neuer Benutzer"):

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

Entfernen Sie den Aufruf org-babel-do-load-languages . Es ist redundant mit Dooms eigenem Lazy-Loading-Mechanismus für Babel-Plugins. Ich bin mir nicht sicher, ob es Ihr Problem beheben wird, aber es könnte sein.

Versuchen Sie andernfalls, stattdessen vom Jupyter-Paket zu :lang (org +ipython) wechseln. Es ist wahrscheinlich, dass das jupyter emacs-Paket etwas tut, das nicht dem Standard entspricht.

Versuchen Sie auch, :async yes oder :async no zu Ihren src-Blöcken hinzuzufügen, und prüfen Sie, ob dies einen Unterschied macht.

Das Problem mit ob-ipython ist, dass ich anscheinend keine mit + conda aktivierte Umgebung verwenden kann. Auch ob-ipython scheint die Unterstützung zu verlieren.

Ich wollte emacs-jupyter ausprobieren, da es standardmäßig die Conda-Umgebung übernehmen konnte und auch R- und Remote-Kernel verwenden kann.

Wie soll ich den Jupyter zu org babel hinzufügen, wenn nicht mit org-babel-do-load-languages ?

emacs-jupyter verwendet nicht ob-async . Sie benötigen die folgende Einstellung, damit Jupyter ordnungsgemäß funktioniert.

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

Ich habe hinzugefügt +jupyter Funktion :lang org , dass Sätze ob-async-no-async-languages-alist und +org-babel-load-functions . Lassen Sie mich wissen, ob dies Ihr Problem löst.

Vielen Dank an @randomizedthinking und @hlissner für Ihre Hilfe.

Nach dem Hinzufügen von +jupyter in der Organisationskonfiguration von .doom.d/init.el, it seems babel does not pick up that language: org-babel-execute-src-block: Keine org-babel-execute-Funktion für jupyter-python! `

Emacs-jupyter kann auch als direkte Replikation für Python-Dateien verwendet werden. Es ist nicht nur eine Integration in den org-Modus wie ob-ipython. Um die Wahrheit zu sagen, ich bin neu in Doom / Emacs und habe Emacs-Jupyter kaum benutzt, aber ich konnte sehen, dass die von Emacs-Jupyter bereitgestellte Antwort weit überlegen ist und leistungsstarke automatische Vervollständigung, Unterstützung für In-Buffer-Bilder usw. Bietet .

All dies zu fragen, verdient emacs-jupyter seine Einrichtung als Teil des Python-Moduls?

Obwohl ich nur sehr begrenzte Kenntnisse habe, bin ich bereit, dabei auf jede erdenkliche Weise zu helfen.

In der Zwischenzeit habe ich dies zu meiner Konfigurationsdatei hinzugefügt:

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

Im Moment scheint es gut zu funktionieren.

Nur die Integration mit orgmode scheint unterbrochen zu sein.

@pmercatoris Damit jupyter in org-babel arbeiten kann, ist meine aktuelle Einstellung wie folgt. Pro emacs-jupyter-Dokument muss die Sprache python (oder jede andere Sprache, die wir mit jupyter verwenden möchten) vor jupyter .

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

Ich bin der Meinung, dass es großartig wäre, wenn emacs-jupyter in das Doom-Emacs-Framework integriert würde.

Vielen Dank auch für das Teilen der Tastenkombinationen. Für alle Auswertungsfunktionen können wir den aktuellen Doom gr -Operator verwenden - dies wäre eine konsistente Cross-Doom-Repl.

@pmercatoris Überprüfen Sie, ob 17d0833 Ihr Problem behebt.

Wenn dies nicht funktioniert, prüfen Sie, ob das Überschreiben von +org-babel-load-jupyter-h wie folgt hilft:

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

@randomizedthinking Bitte versuchen Sie es ohne org-babel-do-load-languages . Es wurde in 3b2a37d9a deaktiviert, da es auf jeden Fall den Lazy Loader von Doom stört.

@hlissner weder 17d0833 noch Overriding scheinen zu funktionieren.

Ich erhalte: org-babel-execute-src-block: No org-babel-execute function for jupyter-python! ohne Hervorhebung für den Quellblock

Ok, also habe ich dies zur .doom.d / config.el hinzugefügt, und jetzt funktioniert es! :) :)

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

Das einzige ist, dass die Hervorhebung des Quellblocks beim ersten Besuch der Datei nicht geladen wird. Ich muss nach dem Ausführen eines Quellblocks erneut besuchen. Ist das beabsichtigt?

Großartig, ich werde hinzufügen, dass das + jupyter-Submodul, nachdem wir Ihr Problem mit der Blockhervorhebung herausgefunden haben (was nicht beabsichtigt ist, wir haben einen Lazy Loader für die Blockhervorhebung, aber jupyter's ist ein sehr ungewöhnlich strukturiertes Babel-Plugin).

Überprüfen Sie, ob das Problem durch Hinzufügen zu Ihrer config.el behoben wird:

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

In Ordnung. Aber es hat immer das gleiche Verhalten, wie unten gezeigt:

Wie ist es beim ersten Besuch der Datei

Führen Sie eine Zelle aus und besuchen Sie die Datei erneut:

Haben Sie das aktualisierte Snippet ausprobiert? Ich habe es kurz nach dem Posten verbessert.

Ja, mit dem aktualisierten Snippet. Hier ist meine 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
          )))

Versuchen Sie mit dem obigen Code, +org-babel-load-jupyter-h zu

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

Das funktioniert leider auch nicht.

Falls es verlinkt sein könnte. Der Quellblock wird erst nach 2 x Cc, Cc ausgeführt
Das erste Mal antwortet es:

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

Und das zweite Mal funktioniert es:

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

Obwohl es das richtige Verhalten sein könnte, dachte ich, ich würde es erwähnen.

Ich habe gerade einige Verbesserungen für jupyter in af948ca geschrieben. Bitte aktualisieren Sie und lassen Sie mich wissen, ob das Problem dadurch behoben wird (und entfernen Sie die Vorschläge, die ich Ihnen bisher gemacht habe) ( +org-babel-load-functions und +org--src-lazy-load-library-a ).

Perfekt, sodass die Ausführung des Quellblocks jetzt ohne Änderungen an der config.el funktioniert.

Das Problem mit der Hervorhebung bleibt jedoch bestehen.

Vielen Dank für Ihre Arbeit.

Ich weiß, dass wir eine von Jupyters Bibliotheken laden müssen, aber ich weiß nicht, welche und wann. Dies wäre viel schneller, wenn ich eine Jupyter-Umgebung zum Testen hätte. Vielleicht sollte jedes Modul eine Nix-Datei enthalten, um eine minimal realisierbare Umgebung zum Testen einzurichten.

Könnten Sie das trotzdem versuchen?

(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 scheint nicht viel Compation zu haben, da ich immer noch das gleiche Verhalten bekomme :-(

Ich weiß nichts über Nix, aber es klingt definitiv nach einer netten Funktion.

Könnte es mit diesem Kommentar verknüpft sein?

Beachten Sie, dass Jupyter beim Laden von Sprachen als letztes Element hinzugefügt werden sollte, da dies von den Werten von Variablen wie org-src-lang-mode und org-babel-tangle-lang-exts abhängt. Nach dem Laden von ob-jupyter stehen neue Quellcodeblöcke mit Namen der Form jupyter-LANG zur Verfügung. LANG kann eine der Kernelsprachen auf Ihrem System sein. Siehe jupyter-available-kernelspecs. (Https://github.com/dzop/emacs-jupyter#org-mode-source-blocks)

Könnte es mit diesem Kommentar verknüpft sein?

Es ist so, aber ich habe mit +org-babel-load-jupyter-h geachtet, aber es weigert sich immer noch zu arbeiten. Versuchen wir es noch einmal:

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

Wenn dies nicht funktioniert, greifen wir einfach auf die dumme Lösung zurück:

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

Ich weiß, dass dies funktionieren wird, aber ich muss mich auf Leute verlassen, um diese Liste zu erweitern, wenn jupyter mehr Sprachen einführt.

Anscheinend funktioniert also nicht einmal die blöde Lösung für die Hervorhebung. Aber was noch wichtiger ist, es scheint, dass org-edit-special nicht funktioniert, da es zurückkehrt:
org-edit-src-code: No such language mode: jupyter-python-mode

Ich hoffe, ich habe alles richtig versucht, wie ich sagte, ich bin sehr neu im Untergang, aber ich habe sichergestellt, dass ich nach jeder Änderung ein doom refresh mache.

Oh, hoppla. Könnten Sie meine blöde Lösung noch einmal mit (after! org-src ...) anstelle von (after! ob-jupyter ...) versuchen?

Alle arbeiten von dem, was ich sehen kann !! : D.

Hervorheben, Blockausführung und Spezialbearbeitung. Ich bin mir nicht sicher, wie Sie die Lösung finden, aber ich bin ziemlich froh, dass sie funktioniert :)

Vielen Dank!!

Hallo! Ich denke, etwas hier hat möglicherweise die R-Unterstützung im Organisationsmodus mit dem Jupyter-Plugin unterbrochen. Die Ausführung von Jupyter-Python-Blöcken funktioniert einwandfrei:

Die Ausführung von Jupyter-R-Blöcken funktioniert jedoch nicht:

Irgendwelche Ratschläge zum weiteren Vorgehen?

@mbosley https://github.com/hlissner/doom-emacs/pull/2477 wird wahrscheinlich Ihr Problem beheben.

In der Zwischenzeit werde ich diesen Thread schließen, da das Problem des OP behoben wurde.