support score-at-point in client

Author: rolandwalker

README.md

@@ -115,6 +115,11 @@ of each game starting with an `[Event "?"]` tagpair.
 
  * `pygn-mode-dependency-check` — check Python and python-chess dependencies
 
+### Engine Commands
+
+ * `pygn-mode-display-score-at-point` — display engine evaluation corresponding to the position of the point
+ * `pygn-mode-display-variation-score-at-point` — display engine evaluation respecting variations
+
 ## Minor Mode
 
 Enabling `pygn-mode-follow-minor-mode` causes a GUI board to be displayed and

pygn-mode.el

@@ -149,6 +149,16 @@
   :group 'pygn-mode
   :type 'boolean)
 
+(defcustom pygn-mode-engine-executable "stockfish"
+  "Path to a UCI engine executable."
+  :group 'pygn-mode
+  :type 'string)
+
+(defcustom pygn-mode-default-engine-depth 20
+  "Default depth for engine analysis."
+  :group 'pygn-mode
+  :type 'int)
+
 ;;;###autoload
 (defgroup pygn-mode-faces nil
   "Faces used by pygn-mode."
@@ -203,6 +213,9 @@
 (defvar pygn-mode--server-receive-max-seconds 0.5
   "The maximum amount of time `pygn-mode--server-receive' should check the server for output when polling.")
 
+(defvar pygn-mode--server-receive-engine-max-seconds 60
+  "The maximum amount of time `pygn-mode--server-receive' should check the server for output when polling for an engine response.")
+
 ;;; Syntax table
 
 (defvar pygn-mode-syntax-table
@@ -269,6 +282,9 @@
       '(menu-item "Next Move" pygn-mode-next-move
                   :help "Navigate to the next move"))
     (define-key map [menu-bar PyGN sep-2] menu-bar-separator)
+    (define-key map [menu-bar PyGN pygn-mode-display-score-at-point]
+      '(menu-item "Score at point" pygn-mode-display-score-at-point
+                  :help "Display engine score at point in separate window"))
     (define-key map [menu-bar PyGN pygn-mode-display-fen-at-point]
       '(menu-item "FEN at Point" pygn-mode-display-fen-at-point
                   :help "Display FEN at point in separate window"))
@@ -397,36 +413,49 @@ data payload, and PAYLOAD may contain arbitrary data."
                payload)
               " ")))
 
-(defun pygn-mode--server-receive ()
+(defun pygn-mode--server-receive (needs-engine)
   "Receive a response after `pygn-mode--server-send'.
 
-Respects the variables `pygn-mode--server-receive-every-seconds' and
-`pygn-mode--server-receive-max-seconds'."
+When NEEDS-ENGINE is non-nil, wait longer, and show a progress reporter.
+
+Respects the variables `pygn-mode--server-receive-every-seconds',
+`pygn-mode--server-receive-max-seconds', and
+`pygn-mode--server-receive-engine-max-seconds'."
   (unless (pygn-mode--server-running-p)
     (error "The pygn-mode server is not running -- cannot receive a response"))
   (unless (get-buffer pygn-mode--server-buffer)
     (error "The pygn-mode server output buffer does not exist -- cannot receive a response"))
   (with-current-buffer pygn-mode--server-buffer
     (erase-buffer)
-    (let ((tries 0))
+    (let ((tries 0)
+          (reporter (when needs-engine (make-progress-reporter "Waiting for engine"))))
       (goto-char (point-min))
       (while (and (not (eq ?\n (char-before (point-max))))
-                  (< (* tries pygn-mode--server-receive-every-seconds) pygn-mode--server-receive-max-seconds))
+                  (< (* tries pygn-mode--server-receive-every-seconds)
+                     (if needs-engine pygn-mode--server-receive-engine-max-seconds pygn-mode--server-receive-max-seconds)))
         (accept-process-output pygn-mode--server-process pygn-mode--server-receive-every-seconds nil 1)
-        (cl-incf tries))
+        (cl-incf tries)
+        (when needs-engine
+          (progress-reporter-update reporter)
+          (sit-for 0)))
+      (when needs-engine
+        (progress-reporter-done reporter))
       (buffer-substring-no-properties (point-min) (point-max)))))
 
 (cl-defun pygn-mode--server-query (&key
                                    command
                                    options
                                    payload-type
                                    payload
+                                   needs-engine
                                    force)
   "Send a request to `pygn-mode--server-process', await, and return the response.
 
 COMMAND, OPTIONS, PAYLOAD-TYPE, and PAYLOAD are as documented at
 `pygn-mode--server-send'.
 
+NEEDS-ENGINE is as documented at `pygn-mode--server-receive'.
+
 FORCE forces a new server process to be created."
   (unless (pygn-mode--server-running-p)
     (pygn-mode--server-start force))
@@ -435,7 +464,7 @@ FORCE forces a new server process to be created."
    :options      options
    :payload-type payload-type
    :payload      payload)
-  (pygn-mode--server-receive))
+  (pygn-mode--server-receive needs-engine))
 
 (defun pygn-mode--parse-response (response)
   "Parse RESPONSE string into a list of payload-id and payload."
@@ -590,13 +619,15 @@ Does not work for nested variations."
 (cl-defun pygn-mode--send-pgn-and-fetch (&key
                                          command
                                          options
+                                         needs-engine
                                          pos)
   "Get PGN string preceding POS, send a `pygn-mode--server-process' request denoted by COMMAND, and return the response."
   (cl-callf or pos (point))
   (save-excursion
     (let ((pgn (buffer-substring-no-properties (pygn-mode-game-start-position) pos)))
       (pygn-mode--server-query
        :command       command
+       :needs-engine  needs-engine
        :options       options
        :payload-type :pgn
        :payload       pgn))))
@@ -636,6 +667,19 @@ Does not work for nested variations."
 
 ;;; Font-lock
 
+(defun pygn-mode-score-at-pos (pos &optional depth)
+  "Get engine score for PGN string preceding POS."
+  (let ((response (pygn-mode--send-pgn-and-fetch
+                   :needs-engine t
+                   :command      :pgn-to-score
+                   :options      `(:engine ,pygn-mode-engine-executable
+                                   :depth ,(or depth pygn-mode-default-engine-depth))
+                   :pos          pos)))
+    (cl-callf pygn-mode--parse-response response)
+    (unless (eq :score (car response))
+      (error "Bad response from `pygn-mode' server"))
+    (cadr response)))
+
 (defun pygn-mode-after-change-function (beg end old-len)
   "Help refontify multi-line variations during edits."
   (let ((syn (syntax-ppss beg)))
@@ -826,6 +870,14 @@ Recenters buffer afterwards."
           "[ ] Bad. The executable '%s' cannot import the python-chess library.  Try installing python-chess, and/or customizing the value of pygn-mode-pythonpath.\n\n"
           pygn-mode-python-executable))
         (cl-return-from pygn-mode-dependency-check))
+      (if (executable-find pygn-mode-engine-executable)
+          (insert (format "[x] Good. The pygn-mode-engine-executable exists at '%s'\n\n" (executable-find pygn-mode-engine-executable)))
+        ;; else
+        (insert
+         (format
+          "[ ] Bad. The engine executable '%s' cannot be found.  Try installing a chess engine and/or customizing the value of pygn-mode-engine-executable.\n\n"
+          pygn-mode-engine-executable))
+        (cl-return-from pygn-mode-dependency-check))
       (insert (format "------------------------------------\n\n"))
       (insert (format "All pygn-mode dependencies verified.\n")))))
 
@@ -983,6 +1035,44 @@ When called non-interactively, display the board corresponding to POS."
       (insert pgn)
       (pygn-mode-display-fen-at-point (point-max)))))
 
+(defun pygn-mode-display-score-at-point (pos &optional arg)
+  "Display an engine score corresponding to the point in a separate buffer.
+
+When called non-interactively, display the score corresponding to POS.
+
+With optional universal prefix ARG, prompt for the desired engine depth.
+With optional numeric prefix ARG, ARG specifies the desired depth.
+
+The UCI engine is defined by `pygn-mode-engine-executable'.  The
+default depth is defined by `pygn-mode-default-engine-depth'."
+  (interactive "d\nP")
+  (let* ((depth (cond
+                  ((numberp arg) arg)
+                  (arg (completing-read "Depth: " nil))
+                  (t pygn-mode-default-engine-depth)))
+         (score (pygn-mode-score-at-pos pos depth))
+         (buf (get-buffer-create " *pygn-mode-score*"))
+         (win (get-buffer-window buf)))
+    (with-current-buffer buf
+      (erase-buffer)
+      (insert score)
+      (goto-char (point-min))
+      (display-buffer buf '(display-buffer-reuse-window))
+      (unless win
+        (setq win (get-buffer-window buf))
+        (set-window-dedicated-p win t)
+        (resize-temp-buffer-window win)))))
+
+(defun pygn-mode-display-variation-score-at-point (pos)
+  "Respecting variations, display and engine score corresponding to the point.
+
+When called non-interactively, display the score corresponding to POS."
+  (interactive "d")
+  (let ((pgn (pygn-mode-pgn-as-if-variation pos)))
+    (with-temp-buffer
+      (insert pgn)
+      (pygn-mode-display-score-at-point (point-max)))))
+
 ;; interactive helper
 (defun pygn-mode--save-gui-board-at-point (pos)
   "Save the board image corresponding to POS to a file."

pygn_server.py

@@ -49,7 +49,11 @@
 
 def instantiate_engine(engine_path):
     if not engine_path in ENGINES:
-        ENGINES[engine_path] = chess.engine.SimpleEngine.popen_uci(engine_path)
+        ENGINES[engine_path] = chess.engine.SimpleEngine.popen_uci(engine_path, timeout=None)
+    try:
+        ENGINES[engine_path].ping()
+    except:
+        ENGINES[engine_path] = chess.engine.SimpleEngine.popen_uci(engine_path, timeout=None)
     return ENGINES[engine_path]
 
 def cleanup():
@@ -171,8 +175,8 @@ def generate_argparser():
     argparser.add_argument('-depth', '--depth',
                            nargs=1,
                            type=int,
-                           default=[10],
-                           help='set depth for depth-limited to UCI evaluations. Default is 10.')
+                           default=[20],
+                           help='set depth for depth-limited to UCI evaluations. Default is 20.')
     return argparser
 
 ###