Light refactoring and suppress an error in one instance

* jupyter-org-client.el (jupyter-org--with-src-block-client): New
function. same as what the non-private version did, in addition, use
the new NOERROR argument of `org-babel-jupyter-session-initiated-p`.
(jupyter-org-with-src-block-client): Move the work to the above so as
to reduce clutter of the macro expansion.
(jupyter-org--insert-stream): Remove a `setq`.

* ob-jupyter.el (org-babel-jupyter-session-key): Add optional
argument, NOERROR, that returns nil if a session key could not be
formed instead of raising an error.
(org-babel-jupyter-session-initiated-p): Add optional argument, same
as above.

* jupyter-repl.el (jupyter-repl-interaction-mode-line): Use `pcase`.

Author: nnicandro

jupyter-org-client.el

@@ -657,6 +657,20 @@ returned."
      (when (jupyter-org--same-src-block-p)
        ,@body)))
 
+(defun jupyter-org--with-src-block-client (thunk)
+  (jupyter-org-when-in-src-block
+   (let ((params (car jupyter-org--src-block-cache)))
+     (when (or jupyter-org-auto-connect
+               (org-babel-jupyter-session-initiated-p params 'noerror))
+       (let* ((buffer (org-babel-jupyter-initiate-session
+                        (alist-get :session params) params))
+              (jupyter-current-client
+               (buffer-local-value 'jupyter-current-client buffer))
+              (syntax (jupyter-kernel-language-syntax-table
+                       jupyter-current-client)))
+         (with-syntax-table syntax
+           (funcall thunk)))))))
+
 (defmacro jupyter-org-with-src-block-client (&rest body)
   "Evaluate BODY with `jupyter-current-client' set to the session's client.
 A client is initialized if needed when `jupyter-org-auto-connect'
@@ -670,21 +684,8 @@ when it is evaluated.
 In addition to evaluating BODY with an active Jupyter client set,
 the `syntax-table' will be set to that of the REPL buffer's."
   (declare (debug (body)))
-  (let ((params (make-symbol "params"))
-        (syntax (make-symbol "syntax"))
-        (buffer (make-symbol "buffer")))
-    `(jupyter-org-when-in-src-block
-      (let ((,params (car jupyter-org--src-block-cache)))
-        (when (or jupyter-org-auto-connect
-                  (org-babel-jupyter-session-initiated-p ,params))
-          (let* ((,buffer (org-babel-jupyter-initiate-session
-                           (alist-get :session ,params) ,params))
-                 (jupyter-current-client
-                  (buffer-local-value 'jupyter-current-client ,buffer))
-                 (,syntax (jupyter-kernel-language-syntax-table
-                           jupyter-current-client)))
-            (with-syntax-table ,syntax
-              ,@body)))))))
+  `(jupyter-org--with-src-block-client
+    (lambda () ,@body)))
 
 (cl-defmethod jupyter-code-context ((_type (eql inspect))
                                     &context (major-mode org-mode))
@@ -1737,10 +1738,12 @@ If INDENTATION is nil, it defaults to `current-indentation'."
 (defun jupyter-org--insert-nonstream (context result)
   (cond
    ((jupyter-org--first-result-context-p context)
-    (unless (jupyter-org-babel-result-p result)
-      ;; Wrap the result if it can't be removed by `org-babel'.
-      (setq result (jupyter-org-results-drawer result)))
-    (insert (org-element-interpret-data result)))
+    (insert (org-element-interpret-data
+             (if (jupyter-org-babel-result-p result)
+                 result
+               ;; Wrap the result if it can't be removed by
+               ;; `org-babel'.
+               (jupyter-org-results-drawer result)))))
    (t
     (let ((elems (jupyter-org--prepare-context context)))
       (insert (org-element-interpret-data

jupyter-repl.el

@@ -1958,14 +1958,15 @@ Do so only if possible in the `current-buffer'."
 `*' means the kernel is busy, `-' means the kernel is idle and
 the REPL is connected, `x' means the REPL is disconnected
 from the kernel."
-  (and (cl-typep jupyter-current-client 'jupyter-repl-client)
-       (concat " JuPy["
-               (cond
-                ((not (jupyter-hb-beating-p jupyter-current-client)) "x")
-                ((equal (jupyter-execution-state jupyter-current-client) "busy")
-                 "*")
-                (t "-"))
-               "]")))
+  (pcase jupyter-current-client
+    ((and client (cl-type jupyter-repl-client))
+     (concat " JuPy["
+             (cond
+              ((not (jupyter-hb-beating-p client)) "x")
+              ((equal (jupyter-execution-state client) "busy")
+               "*")
+              (t "-"))
+             "]"))))
 
 (defun jupyter-repl-pop-to-buffer ()
   "Switch to the REPL buffer of the `jupyter-current-client'."

ob-jupyter.el

@@ -102,18 +102,22 @@ table for the source block at `point'.")
       (advice-member-p
        'ob-jupyter (intern (concat "org-babel-execute:" lang)))))
 
-(defun org-babel-jupyter-session-key (params)
+(defun org-babel-jupyter-session-key (params &optional noerror)
   "Return a string that is the concatenation of the :session and :kernel PARAMS.
 PARAMS is the arguments alist as returned by
 `org-babel-get-src-block-info'.  The returned string can then be
-used to identify unique Jupyter Org babel sessions."
+used to identify unique Jupyter Org babel sessions.
+
+If NOERROR is non-nil and PARAMS does not have valid information
+to identify a session return nil, otherwise raise an error."
   ;; Take into account a Lisp expression as a session name.
   (let ((session (org-babel-read (alist-get :session params)))
         (kernel (alist-get :kernel params)))
-    (unless (and session kernel
-                 (not (equal session "none")))
-      (error "Need a valid session and a kernel to form a key"))
-    (concat session "-" kernel)))
+    (if (and session kernel
+             (not (equal session "none")))
+        (concat session "-" kernel)
+      (unless noerror
+        (error "Need a valid session and a kernel to form a key")))))
 
 (defun org-babel-jupyter-src-block-session ()
   "Return the session key for the current Jupyter source block.
@@ -385,9 +389,13 @@ session."
             ;; TODO: Would we always want to do this?
             (jupyter-server-name-client-kernel client sname)))))))
 
-(defun org-babel-jupyter-session-initiated-p (params)
-  "Return non-nil if the session corresponding to PARAMS is initiated."
-  (let ((key (org-babel-jupyter-session-key params)))
+(defun org-babel-jupyter-session-initiated-p (params &optional noerror)
+  "Return non-nil if the session corresponding to PARAMS is initiated.
+If NOERROR is nil, raise an error if PARAMS doesn't contain valid
+information to identify a session, e.g. the `:session' key is
+\"none\".  Otherwise, for a non-nil NOERROR and when PARAMS
+doesn't contain valid information, return nil."
+  (when-let* ((key (org-babel-jupyter-session-key params noerror)))
     (gethash key org-babel-jupyter-session-clients)))
 
 (defun org-babel-jupyter-initiate-session-by-key (session params)