get user statistics from leetcode

Author: Sorosliu1029

jupyterlab_leetcode/handlers/__init__.py

@@ -2,13 +2,17 @@
 
 from .base_handler import BaseHandler
 from .cookie_handler import GetCookieHandler
-from .leetcode_handler import LeetCodeProfileHandler
+from .leetcode_handler import LeetCodeProfileHandler, LeetCodeStatisticsHandler
 
 
 def setup_handlers(web_app):
     host_pattern = ".*$"
     base_url = web_app.settings["base_url"]
-    handlers: list[type[BaseHandler]] = [GetCookieHandler, LeetCodeProfileHandler]
+    handlers: list[type[BaseHandler]] = [
+        GetCookieHandler,
+        LeetCodeProfileHandler,
+        LeetCodeStatisticsHandler,
+    ]
 
     web_app.add_handlers(
         host_pattern,

jupyterlab_leetcode/handlers/cookie_handler.py

@@ -30,7 +30,7 @@ class GetCookieHandler(BaseHandler):
 
     @tornado.web.authenticated
     def get(self):
-        self.log.info("Loading all cookies for LeetCode...")
+        self.log.debug("Loading all cookies for LeetCode...")
         browser = self.get_query_argument("browser", "", strip=True)
         if not browser:
             self.set_status(400)
@@ -62,7 +62,6 @@ def get(self):
                 else 3600 * 24 * 14
             )
             self.set_cookie("leetcode_browser", browser, max_age=max_age)
-            leetcode_ua = self.request.headers.get("user-agent")
             self.settings.update(
                 leetcode_browser=browser,
                 leetcode_cookiejar=cj,
@@ -79,8 +78,9 @@ def get(self):
                         ),
                     }
                 ),
-                leetcode_ua=leetcode_ua,
             )
-            AsyncHTTPClient.configure(None, defaults=dict(user_agent=leetcode_ua))
+            AsyncHTTPClient.configure(
+                None, defaults=dict(user_agent=self.request.headers.get("user-agent"))
+            )
 
         self.finish(json.dumps(resp))

jupyterlab_leetcode/handlers/leetcode_handler.py

@@ -1,40 +1,176 @@
 import json
+from typing import cast
 
 import tornado
-from tornado.httpclient import AsyncHTTPClient, HTTPRequest
+from tornado.gen import multi
+from tornado.httpclient import AsyncHTTPClient, HTTPRequest, HTTPResponse
 from tornado.httputil import HTTPHeaders
 
 from .base_handler import BaseHandler
 
 LEETCODE_GRAPHQL_URL = "https://leetcode.com/graphql"
 
+type QueryType = dict[str, str | dict[str, str]]
 
-class LeetCodeProfileHandler(BaseHandler):
-    route = r"leetcode/profile"
 
-    @tornado.web.authenticated
-    async def get(self):
+class LeetCodeHandler(BaseHandler):
+    """Base handler for LeetCode-related requests."""
+
+    async def graphql(self, name: str, query: QueryType) -> None:
+        self.log.debug(f"Fetching LeetCode {name} data...")
         client = AsyncHTTPClient()
-        headers = HTTPHeaders(self.settings.get("leetcode_headers", {}))
         req = HTTPRequest(
             url=LEETCODE_GRAPHQL_URL,
             method="POST",
-            headers=headers,
-            body=json.dumps(
-                {
-                    "operationName": "globalData",
-                    "variables": {},
-                    "query": "query globalData { userStatus { isSignedIn username realName avatar } }",
-                }
-            ),
+            headers=HTTPHeaders(self.settings.get("leetcode_headers", {})),
+            body=json.dumps(query),
         )
 
         try:
             resp = await client.fetch(req)
         except Exception as e:
-            self.log.error(f"Error fetching LeetCode profile: {e}")
+            self.log.error(f"Error fetching LeetCode {name}: {e}")
             self.set_status(500)
-            self.finish(json.dumps({"message": "Failed to fetch LeetCode profile"}))
+            self.finish(json.dumps({"message": f"Failed to fetch LeetCode {name}"}))
             return
         else:
             self.finish(resp.body)
+
+    async def graphql_multi(
+        self, name: str, queries: dict[str, QueryType]
+    ) -> dict[str, HTTPResponse]:
+        self.log.debug(f"Fetching LeetCode {name} data...")
+        client = AsyncHTTPClient()
+        request_futures = dict(
+            map(
+                lambda kv: (
+                    kv[0],
+                    client.fetch(
+                        HTTPRequest(
+                            url=LEETCODE_GRAPHQL_URL,
+                            method="POST",
+                            headers=HTTPHeaders(
+                                self.settings.get("leetcode_headers", {})
+                            ),
+                            body=json.dumps(kv[1]),
+                        ),
+                    ),
+                ),
+                queries.items(),
+            )
+        )
+
+        try:
+            responses = await multi(request_futures)
+        except Exception as e:
+            self.log.error(f"Error fetching LeetCode {name}: {e}")
+            self.set_status(500)
+            self.finish(json.dumps({"message": f"Failed to fetch LeetCode {name}"}))
+            return {}
+        else:
+            return cast("dict[str, HTTPResponse]", responses)
+
+
+class LeetCodeProfileHandler(LeetCodeHandler):
+    route = r"leetcode/profile"
+
+    @tornado.web.authenticated
+    async def get(self):
+        await self.graphql(
+            name="profile",
+            query={
+                "query": """query globalData {
+                                userStatus {
+                                    isSignedIn
+                                    username
+                                    realName
+                                    avatar
+                                }
+                            }"""
+            },
+        )
+
+
+class LeetCodeStatisticsHandler(LeetCodeHandler):
+    route = r"leetcode/statistics"
+
+    @tornado.web.authenticated
+    async def get(self):
+        username = self.get_query_argument("username", "", strip=True)
+        if not username:
+            self.set_status(400)
+            self.finish(json.dumps({"message": "Username parameter is required"}))
+            return
+
+        responses = await self.graphql_multi(
+            name="statistics",
+            queries={
+                "userSessionProgress": {
+                    "query": """query userSessionProgress($username: String!) {
+                                          allQuestionsCount {
+                                            difficulty
+                                            count
+                                          }
+                                          matchedUser(username: $username) {
+                                            submitStats {
+                                              acSubmissionNum {
+                                                difficulty
+                                                count
+                                              }
+                                              totalSubmissionNum {
+                                                difficulty
+                                                count
+                                              }
+                                            }
+                                          }
+                                        }""",
+                    "variables": {"username": username},
+                },
+                "userProfileUserQuestionProgressV2": {
+                    "query": """query userProfileUserQuestionProgressV2($userSlug: String!) {
+                                          userProfileUserQuestionProgressV2(userSlug: $userSlug) {
+                                            numAcceptedQuestions {
+                                              count
+                                              difficulty
+                                            }
+                                            numFailedQuestions {
+                                              count
+                                              difficulty
+                                            }
+                                            numUntouchedQuestions {
+                                              count
+                                              difficulty
+                                            }
+                                            userSessionBeatsPercentage {
+                                              difficulty
+                                              percentage
+                                            }
+                                            totalQuestionBeatsPercentage
+                                          }
+                                        }""",
+                    "variables": {"userSlug": username},
+                },
+                "userPublicProfile": {
+                    "query": """query userPublicProfile($username: String!) {
+                                          matchedUser(username: $username) {
+                                            username
+                                            profile {
+                                              ranking
+                                            }
+                                          }
+                                        }""",
+                    "variables": {"username": username},
+                },
+            },
+        )
+
+        if not responses:
+            return
+
+        res = dict(
+            map(
+                lambda kv: (kv[0], json.loads(kv[1].body).get("data", {})),
+                responses.items(),
+            )
+        )
+        self.finish(res)

src/components/LeetCode.tsx

@@ -1,24 +1,39 @@
 import React, { useEffect, useState } from 'react';
-import { getProfile } from '../services/leetcode';
+import { getProfile, getStatistics } from '../services/leetcode';
+import { LeetCodeProfile } from '../types/leetcode';
 
 const LeetCode = () => {
-  const [username, setUsername] = useState('');
+  const [profile, setProfile] = useState<LeetCodeProfile | null>(null);
 
   useEffect(() => {
     getProfile().then(profile => {
       if (!profile || !profile.isSignedIn) {
         alert('Please sign in to LeetCode.');
         return;
       }
-      setUsername(profile.username);
+      setProfile(profile);
     });
   }, []);
 
-  return (
+  useEffect(() => {
+    if (!profile) {
+      return;
+    }
+    getStatistics(profile.username).then(d => {
+      console.log('LeetCode Statistics:', d);
+    });
+  }, [profile]);
+
+  return profile ? (
     <div>
-      <p>Welcome {username}</p>
+      <p>Welcome {profile.username}</p>
+      <img
+        src={profile.avatar}
+        alt="Avatar"
+        style={{ width: '100px', height: '100px' }}
+      />
     </div>
-  );
+  ) : null;
 };
 
 export default LeetCode;

src/services/leetcode.ts

@@ -1,4 +1,4 @@
-import { LeetCodeProfile } from '../types/leetcode';
+import { LeetCodeProfile, LeetCodeStatistics } from '../types/leetcode';
 import { requestAPI } from './handler';
 
 export async function getProfile(): Promise<LeetCodeProfile | null> {
@@ -8,3 +8,11 @@ export async function getProfile(): Promise<LeetCodeProfile | null> {
     .then(d => d.data.userStatus)
     .catch(() => null);
 }
+
+export async function getStatistics(
+  username: string
+): Promise<LeetCodeStatistics | null> {
+  return requestAPI<LeetCodeStatistics>(
+    `/leetcode/statistics?username=${username}`
+  ).catch(() => null);
+}

src/types/leetcode.d.ts

@@ -4,3 +4,48 @@ export type LeetCodeProfile = {
   realName: string;
   username: string;
 };
+
+export type LeetCodePublicProfile = {
+  matchedUser: {
+    profile: {
+      ranking: number;
+    };
+    username: string;
+  };
+};
+
+export type LeetCodeQuestionStatistic = {
+  count: number;
+  difficulty: string;
+};
+
+export type LeetCodeBeatsPercentage = {
+  percentage: number;
+  difficulty: string;
+};
+
+export type LeetCodeQuestionProgress = {
+  totalQuestionBeatsPercentage: number;
+  numAcceptedQuestions: LeetCodeQuestionStatistic[];
+  numFailedQuestions: LeetCodeQuestionStatistic[];
+  numUntouchedQuestions: LeetCodeQuestionStatistic[];
+  userSessionBeatsPercentage: LeetCodeBeatsPercentage[];
+};
+
+export type LeetCodeSessionProgress = {
+  allQuestionsCount: LeetCodeQuestionStatistic[];
+  matchedUser: {
+    submitStats: {
+      acSubmissionNum: LeetCodeQuestionStatistic[];
+      totalSubmissionNum: LeetCodeQuestionStatistic[];
+    };
+  };
+};
+
+export type LeetCodeStatistics = {
+  userPublicProfile: LeetCodePublicProfile;
+  userSessionProgress: LeetCodeSessionProgress;
+  userProfileUserQuestionProgressV2: {
+    userProfileUserQuestionProgressV2: LeetCodeQuestionProgress;
+  };
+};