support submit notebook to leetcode to evaluate

Author: Sorosliu1029

jupyterlab_leetcode/handlers/__init__.py

@@ -4,7 +4,8 @@
 from .cookie_handler import GetCookieHandler
 from .leetcode_handler import (CreateNotebookHandler, LeetCodeProfileHandler,
                                LeetCodeQuestionHandler,
-                               LeetCodeStatisticsHandler)
+                               LeetCodeStatisticsHandler,
+                               SubmitNotebookHandler)
 
 
 def setup_handlers(web_app):
@@ -16,6 +17,7 @@ def setup_handlers(web_app):
         LeetCodeStatisticsHandler,
         LeetCodeQuestionHandler,
         CreateNotebookHandler,
+        SubmitNotebookHandler,
     ]
 
     web_app.add_handlers(

jupyterlab_leetcode/handlers/leetcode_handler.py

@@ -1,4 +1,5 @@
 import json
+import os
 from typing import Any, Mapping, cast, overload
 
 import tornado
@@ -7,9 +8,11 @@
 from tornado.httputil import HTTPHeaders
 
 from ..utils.notebook_generator import NotebookGenerator
+from ..utils.utils import first
 from .base_handler import BaseHandler
 
-LEETCODE_GRAPHQL_URL = "https://leetcode.com/graphql"
+LEETCODE_URL = "https://leetcode.com"
+LEETCODE_GRAPHQL_URL = f"{LEETCODE_URL}/graphql"
 
 type QueryType = dict[str, str | Mapping[str, Any]]
 
@@ -81,6 +84,25 @@ async def graphql_multi(
         else:
             return cast("dict[str, HTTPResponse]", responses)
 
+    async def request_api(self, url: str, method: str, body: Mapping[str, Any]):
+        self.log.debug(f"Requesting LeetCode API: {url} with method {method}")
+        client = AsyncHTTPClient()
+        req = HTTPRequest(
+            url=f"{LEETCODE_URL}{url}",
+            method=method,
+            headers=HTTPHeaders(self.settings.get("leetcode_headers", {})),
+            body=json.dumps(body),
+        )
+        try:
+            resp = await client.fetch(req)
+        except Exception as e:
+            self.log.error(f"Error requesting LeetCode API: {e}")
+            self.set_status(500)
+            self.finish(json.dumps({"message": "Failed to request LeetCode API"}))
+            return None
+        else:
+            return json.loads(resp.body) if resp.body else {}
+
     async def get_question_detail(self, title_slug: str) -> dict[str, Any]:
         resp = await self.graphql(
             name="question_detail",
@@ -358,3 +380,85 @@ async def post(self):
 
         file_path = notebook_generator.generate(question)
         self.finish({"filePath": file_path})
+
+
+class SubmitNotebookHandler(LeetCodeHandler):
+    route = r"notebook/submit"
+
+    def get_solution(self, notebook):
+        solution_cell = first(
+            notebook["cells"],
+            lambda c: c["cell_type"] == "code" and c["metadata"].get("isSolutionCode"),
+        )
+        if not solution_cell:
+            return
+
+        code = "".join(solution_cell["source"]).strip()
+        return code if not code.endswith("pass") else None
+
+    async def submit(self, file_path: str):
+        if not os.path.exists(file_path):
+            self.set_status(404)
+            self.finish({"message": "Notebook file not found"})
+            return
+
+        with open(file_path, "r", encoding="utf-8") as f:
+            notebook = json.load(f)
+
+        question_info = notebook["metadata"]["leetcode_question_info"]
+        if not question_info:
+            self.set_status(400)
+            self.finish({"message": "Notebook does not contain LeetCode question info"})
+            return
+
+        question_frontend_id = question_info["questionFrontendId"]
+        question_submit_id = question_info["questionId"]
+        submit_url = question_info["submitUrl"]
+        sample_testcase = question_info["sampleTestCase"]
+        if (
+            not question_frontend_id
+            or not question_submit_id
+            or not submit_url
+            or not sample_testcase
+        ):
+            self.set_status(400)
+            self.finish({"message": "Invalid question info in notebook"})
+            return
+
+        solution_code = self.get_solution(notebook)
+        if not solution_code:
+            self.set_status(400)
+            self.finish({"message": "No solution code found in notebook"})
+            return
+
+        resp = await self.request_api(
+            submit_url,
+            "POST",
+            {
+                "question_id": str(question_submit_id),
+                "data_input": sample_testcase,
+                "lang": "python3",
+                "typed_code": solution_code,
+                "test_mode": False,
+                "judge_type": "large",
+            },
+        )
+
+        self.finish(resp)
+
+    @tornado.web.authenticated
+    async def post(self):
+        body = self.get_json_body()
+        if not body:
+            self.set_status(400)
+            self.finish({"message": "Request body is required"})
+            return
+
+        body = cast("dict[str, str]", body)
+        file_path = cast(str, body.get("filePath", ""))
+        if not file_path:
+            self.set_status(400)
+            self.finish({"message": "filePath is required"})
+            return
+
+        await self.submit(file_path)

jupyterlab_leetcode/utils/notebook_generator.py

@@ -37,10 +37,11 @@ def __populate_metadata(self, q):
 
         metadata_question_info = self.template["metadata"]["leetcode_question_info"]
         metadata_question_info["submitUrl"] = q["submitUrl"]
-        metadata_question_info["sampleTestCase"] = q["sampleTestCase"]
         metadata_question_info["questionId"] = q["questionId"]
         metadata_question_info["questionFrontendId"] = q["questionFrontendId"]
         metadata_question_info["questionDetailUrl"] = q["questionDetailUrl"]
+        metadata_question_info["sampleTestCase"] = q["sampleTestCase"]
+        metadata_question_info["exampleTestcaseList"] = q["exampleTestcaseList"]
 
     def __populate_title(self, q):
         title_cell = first(

src/components/LeetCode.tsx

@@ -1,14 +1,33 @@
 import React, { useEffect, useState } from 'react';
 import { IDocumentManager } from '@jupyterlab/docmanager';
+import { IDocumentWidget } from '@jupyterlab/docregistry';
+import { JupyterFrontEnd, LabShell } from '@jupyterlab/application';
 import { getProfile } from '../services/leetcode';
 import { LeetCodeProfile } from '../types/leetcode';
 import Profile from './Profile';
 import Statistics from './Statistics';
 import QuestionList from './QuestionList';
 
-const LeetCode: React.FC<{ docManager: IDocumentManager }> = ({
-  docManager
-}) => {
+export function getCurrentOpenFilePath(
+  shell: LabShell,
+  docManager: IDocumentManager,
+  widget?: IDocumentWidget
+): string | null {
+  const currentWidget = widget ?? shell.currentWidget;
+  if (!currentWidget || !docManager) {
+    return null;
+  }
+  const context = docManager.contextForWidget(currentWidget);
+  if (!context) {
+    return null;
+  }
+  return context.path;
+}
+
+const LeetCode: React.FC<{
+  app: JupyterFrontEnd;
+  docManager: IDocumentManager;
+}> = ({ app, docManager }) => {
   const [profile, setProfile] = useState<LeetCodeProfile | null>(null);
 
   useEffect(() => {

src/components/LeetCodeMainArea.tsx

@@ -0,0 +1,35 @@
+import React, { useEffect, useState } from 'react';
+import { IDocumentManager } from '@jupyterlab/docmanager';
+import { JupyterFrontEnd } from '@jupyterlab/application';
+import LandingPage from './LandingPage';
+import LeetCode from './LeetCode';
+import { getCookie } from '../services/cookie';
+
+const LeetCodeMainArea: React.FC<{
+  app: JupyterFrontEnd;
+  docManager: IDocumentManager;
+}> = ({ app, docManager }) => {
+  const [cookieLoggedIn, setCookieLoggedIn] = useState('');
+
+  useEffect(() => {
+    const leetcode_browser = document.cookie
+      .split('; ')
+      .find(cookie => cookie.startsWith('leetcode_browser='))
+      ?.split('=')[1];
+    if (leetcode_browser) {
+      getCookie(leetcode_browser).then(resp => {
+        if (resp['checked']) {
+          setCookieLoggedIn(leetcode_browser);
+        }
+      });
+    }
+  });
+
+  return cookieLoggedIn ? (
+    <LeetCode app={app} docManager={docManager} />
+  ) : (
+    <LandingPage setCookieLoggedIn={b => setCookieLoggedIn(b)} />
+  );
+};
+
+export default LeetCodeMainArea;

src/components/LeetCodeNotebookHeader.tsx

@@ -0,0 +1,24 @@
+import React from 'react';
+import { NotebookPanel } from '@jupyterlab/notebook';
+import { submitNotebook } from '../services/notebook';
+
+const LeetCodeNotebookHeader: React.FC<{ notebook: NotebookPanel }> = ({
+  notebook
+}) => {
+  const submit = () => {
+    notebook.context.save().then(() => {
+      const path = notebook.context.path;
+      submitNotebook(path).then(() => {
+        console.log('Notebook submitted successfully');
+      });
+    });
+  };
+
+  return (
+    <div>
+      <button onClick={submit}>Submit</button>
+    </div>
+  );
+};
+
+export default LeetCodeNotebookHeader;

src/index.ts

@@ -5,8 +5,9 @@ import {
 } from '@jupyterlab/application';
 import { ICommandPalette, WidgetTracker } from '@jupyterlab/apputils';
 import { IDocumentManager } from '@jupyterlab/docmanager';
+import { NotebookPanel } from '@jupyterlab/notebook';
 
-import LeetCodeWidget from './widget';
+import { LeetCodeMainWidget, LeetCodeHeaderWidget } from './widget';
 
 const PLUGIN_ID = 'jupyterlab-leetcode:plugin';
 
@@ -25,14 +26,14 @@ const plugin: JupyterFrontEndPlugin<void> = {
     docManager: IDocumentManager,
     restorer: ILayoutRestorer | null
   ) => {
-    let leetcodeWidget: LeetCodeWidget;
+    let leetcodeWidget: LeetCodeMainWidget;
 
     const command = 'leetcode-widget:open';
     app.commands.addCommand(command, {
       label: 'Open LeetCode Widget',
       execute: () => {
         if (!leetcodeWidget || leetcodeWidget.isDisposed) {
-          leetcodeWidget = new LeetCodeWidget(docManager);
+          leetcodeWidget = new LeetCodeMainWidget(app, docManager);
         }
         if (!tracker.has(leetcodeWidget)) {
           tracker.add(leetcodeWidget);
@@ -43,9 +44,24 @@ const plugin: JupyterFrontEndPlugin<void> = {
         app.shell.activateById(leetcodeWidget.id);
       }
     });
-
     palette.addItem({ command, category: 'LeetCode' });
-    const tracker = new WidgetTracker<LeetCodeWidget>({
+
+    const addHeaderCommand = 'leetcode-widget:add-header';
+    app.commands.addCommand(addHeaderCommand, {
+      label: 'Add Header to LeetCode Widget',
+      caption: 'Add Header to LeetCode Widget',
+      execute: () => {
+        const main = app.shell.currentWidget;
+        if (main instanceof NotebookPanel) {
+          const widget = new LeetCodeHeaderWidget(main);
+          widget.node.style.minHeight = '20px';
+          main.contentHeader.addWidget(widget);
+        }
+      }
+    });
+    palette.addItem({ command: addHeaderCommand, category: 'LeetCode' });
+
+    const tracker = new WidgetTracker<LeetCodeMainWidget>({
       namespace: 'leetcode-widget'
     });
     if (restorer) {

src/services/notebook.ts

@@ -6,3 +6,10 @@ export async function generateNotebook(titleSlug: string) {
     body: JSON.stringify({ titleSlug })
   }).catch(() => null);
 }
+
+export async function submitNotebook(path: string) {
+  return requestAPI<void>('/notebook/submit', {
+    method: 'POST',
+    body: JSON.stringify({ filePath: path })
+  }).catch(() => null);
+}