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

Coba tambahkan ini ke config.el pribadi Anda:

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

Terima kasih atas balasan cepatnya. Sayangnya itu tidak memperbaikinya.

Saya juga mencoba dengan blok kode yang lebih sederhana:

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

Ini adalah konfigurasi saya saat ini ("pengguna baru"):

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

Hapus panggilan org-babel-do-load-languages . Ini redundan dengan mekanisme pemuatan lambat Doom sendiri untuk plugin babel. Tidak yakin apakah itu akan memperbaiki masalah Anda, tetapi itu mungkin.

Jika tidak, coba beralih dari paket jupyter ke :lang (org +ipython) sebagai gantinya. Sepertinya paket emacs jupyter melakukan sesuatu yang tidak standar.

Juga, coba tambahkan :async yes atau :async no ke blok src Anda dan lihat apakah itu membuat perbedaan.

Masalah dengan ob-ipython, adalah saya tidak bisa menggunakan lingkungan yang diaktifkan dengan + conda. Juga ob-ipython tampaknya kehilangan dukungan.

Saya ingin mencoba emacs-jupyter, karena dapat mengambil lingkungan conda secara default dan juga berpotensi untuk menggunakan R dan kernel jarak jauh.

Bagaimana cara menambahkan jupyter ke babel org jika tidak dengan org-babel-do-load-languages ?

emacs-jupyter tidak menggunakan ob-async . Anda harus memiliki pengaturan berikut agar jupyter berfungsi dengan benar.

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

Saya telah menambahkan fitur +jupyter ke :lang org yang menetapkan ob-async-no-async-languages-alist dan +org-babel-load-functions . Beri tahu saya jika itu menyelesaikan masalah Anda.

Terima kasih @randomizedthinking dan @hlissner atas bantuan Anda.

Setelah menambahkan +jupyter dalam konfigurasi org .doom.d/init.el, it seems babel does not pick up that language: org-babel-eksekusi-src-block: Tidak ada fungsi org-babel-eksekusi untuk jupyter-python! `

Selain itu, emacs-jupyter dapat digunakan sebagai replika langsung untuk file python. Ini bukan hanya integrasi dengan mode-org seperti ob-ipython. Sejujurnya, saya baru mengenal doom / emacs dan hampir tidak pernah menggunakan emacs-jupyter, tetapi saya dapat melihat repl yang disediakan oleh emacs-jupyter jauh lebih unggul, memberikan penyelesaian otomatis yang kuat, dukungan untuk gambar dalam buffer, dll. .

Semua ini untuk ditanyakan, apakah emacs-jupyter layak mendapatkan pengaturannya sebagai bagian dari modul python?

Meskipun pengetahuan saya sangat terbatas, saya bersedia membantu dengan cara apa pun yang saya bisa.

Sementara itu, saya menambahkan ini ke file konfigurasi saya:

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

Untuk saat ini, tampaknya berfungsi dengan baik.

Hanya integrasi dengan mode org yang tampaknya rusak.

@pmercatoris Agar jupyter bekerja di org-babel, pengaturan saya saat ini adalah sebagai berikut. Per dokumen emacs-jupyter, bahasa python (atau bahasa lain yang kami rencanakan untuk digunakan dengan jupyter) harus disertakan sebelum jupyter .

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

Saya setuju bahwa akan sangat bagus jika emacs-jupyter diintegrasikan ke dalam kerangka kerja doom emacs.

Juga terima kasih telah berbagi keybindings. Untuk semua fungsi evaluasi, kita dapat menggunakan operator malapetaka gr - ini akan menjadi replika doom yang konsisten.

@pmercatoris Lihat apakah 17d0833 menyelesaikan masalah Anda.

Jika itu tidak berhasil, lihat apakah mengganti +org-babel-load-jupyter-h like sangat membantu:

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

@randomizedthinking Silakan coba tanpa org-babel-do-load-languages . Ini telah dinonaktifkan di 3b2a37d9a karena mengganggu pemuat malas Doom, dalam hal apapun.

@hlissner baik 17d0833 maupun overriding sepertinya tidak bekerja.

Saya mendapatkan: org-babel-execute-src-block: No org-babel-execute function for jupyter-python! tanpa penyorotan untuk blok sumber

Ok, jadi saya menambahkan ini ke .doom.d / config.el, dan sekarang berhasil! :)

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

Satu-satunya hal adalah penyorotan blok sumber tidak dimuat saat pertama kali mengunjungi file. Saya perlu mengunjungi kembali setelah menjalankan blok sumber. Apakah itu dimaksudkan?

Bagus, saya akan menambahkan bahwa + jupyter submodule setelah kami mengetahui masalah penyorotan blok Anda (yang tidak dimaksudkan, kami memiliki pemuat malas untuk penyorotan blok, tetapi jupyter adalah plugin babel yang sangat terstruktur dengan luar biasa).

Lihat apakah menambahkan ini ke config.el Anda menyelesaikan masalah:

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

Baik. Tetapi tetap memiliki perilaku yang sama, seperti yang ditunjukkan di bawah ini:

Bagaimana saat pertama kali mengunjungi file

Jalankan sel dan kunjungi kembali file:

Apakah Anda mencoba cuplikan yang diperbarui? Saya memperbaikinya segera setelah mempostingnya.

Ya, dengan cuplikan yang diperbarui. Ini config.el saya:

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

Dengan kode di atas, coba ubah +org-babel-load-jupyter-h menjadi:

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

Sayangnya, itu juga tidak berhasil.

Dalam hal itu mungkin ditautkan. Blok sumber hanya dijalankan setelah 2 x Cc, Cc
Pertama kali merespons:

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

Dan kedua kalinya berhasil:

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

Meskipun, itu mungkin perilaku yang benar, saya pikir saya akan menyebutkannya.

Saya baru saja menulis beberapa perbaikan untuk jupyter di af948ca. Harap perbarui dan beri tahu saya jika itu memperbaiki masalah (dan hapus +org-babel-load-functions dan +org--src-lazy-load-library-a saran yang telah saya berikan sejauh ini).

Sempurna, jadi eksekusi blok sumber sekarang berfungsi tanpa modifikasi apa pun pada config.el.

Namun masalah dengan penyorotan tetap ada.

Terima kasih banyak atas pekerjaan Anda.

Saya tahu kita harus memuat _one_ dari perpustakaan jupyter, tapi saya tidak tahu yang mana dan kapan. Ini akan jauh lebih cepat jika saya memiliki lingkungan jupyter untuk diuji. Mungkin setiap modul harus menyertakan file nix untuk menyiapkan lingkungan minimum yang layak untuk pengujian.

Bagaimanapun, bisakah Anda mencoba ini?

(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 sepertinya tidak terlalu menyesal, karena saya masih mendapatkan perilaku yang sama :-(

Tidak tahu apa-apa tentang Nix, tapi jelas terdengar seperti fitur yang bagus.

Mungkinkah itu terkait dengan komentar ini?

Catatan, jupyter harus ditambahkan sebagai elemen terakhir saat memuat bahasa karena bergantung pada nilai variabel seperti org-src-lang-mode dan org-babel-tangle-lang-exts. Setelah ob-jupyter dimuat, blok kode sumber baru dengan nama dalam bentuk jupyter-LANG akan tersedia. LANG dapat berupa salah satu bahasa kernel yang ditemukan di sistem Anda. Lihat jupyter-available-kernelspecs. (Https://github.com/dzop/emacs-jupyter#org-mode-source-blocks)

Mungkinkah itu terkait dengan komentar ini?

Ya, tetapi saya telah memperhatikannya dengan +org-babel-load-jupyter-h , tetapi masih menolak untuk bekerja. Jadi mari kita coba sekali lagi:

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

Jika ini tidak berhasil, maka kami hanya akan menggunakan solusi bodoh:

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

Saya tahu ini akan berhasil, tetapi saya harus bergantung pada orang-orang untuk memperluas daftar ini karena jupyter memperkenalkan lebih banyak bahasa.

Jadi, tampaknya bahkan solusi bodoh tidak berfungsi untuk penyorotan. Tetapi yang lebih penting, tampaknya org-edit-special tidak akan berfungsi, karena mengembalikan:
org-edit-src-code: No such language mode: jupyter-python-mode

Saya berharap saya telah mencoba semuanya dengan benar, seperti yang saya katakan saya sangat baru dalam malapetaka, tetapi pastikan untuk melakukan doom refresh setelah ada perubahan.

Aduh. Bisakah Anda mencoba solusi bodoh saya lagi dengan (after! org-src ...) alih-alih (after! ob-jupyter ...) ?

Semua bekerja dari apa yang bisa saya lihat !! : D

Menyoroti, memblokir eksekusi, dan pengeditan khusus. Jadi saya tidak yakin bagaimana perasaan Anda tentang solusinya, tetapi cukup senang itu berhasil :)

Terima kasih!!

Hai! Saya pikir sesuatu di sini mungkin telah merusak dukungan R dalam mode-org menggunakan plugin Jupyter. Eksekusi blok jupyter-python berfungsi dengan baik:

Tetapi eksekusi blok jupyter-R tidak:

Adakah saran tentang cara melanjutkan?

@mbosley https://github.com/hlissner/doom-emacs/pull/2477 kemungkinan akan memperbaiki masalah Anda.

Sementara itu, saya akan menutup utas ini karena masalah OP telah diselesaikan.