jupyterlab-leetcode 0.1.1__py3-none-any.whl

jupyterlab_leetcode/__init__.py

@@ -0,0 +1,32 @@
+try:
+    from ._version import __version__
+except ImportError:
+    # Fallback when using the package in dev mode without installing
+    # in editable mode with pip. It is highly recommended to install
+    # the package from a stable release or in editable mode: https://pip.pypa.io/en/stable/topics/local-project-installs/#editable-installs
+    import warnings
+
+    warnings.warn("Importing 'jupyterlab_leetcode' outside a proper installation.")
+    __version__ = "dev"
+from .handlers import setup_handlers
+
+
+def _jupyter_labextension_paths():
+    return [{"src": "labextension", "dest": "jupyterlab-leetcode"}]
+
+
+def _jupyter_server_extension_points():
+    return [{"module": "jupyterlab_leetcode"}]
+
+
+def _load_jupyter_server_extension(server_app):
+    """Registers the API handler to receive HTTP requests from the frontend extension.
+
+    Parameters
+    ----------
+    server_app: jupyterlab.labapp.LabApp
+        JupyterLab application instance
+    """
+    setup_handlers(server_app.web_app)
+    name = "jupyterlab_leetcode"
+    server_app.log.info(f"Registered {name} server extension")

jupyterlab_leetcode/_version.py

@@ -0,0 +1,4 @@
+# This file is auto-generated by Hatchling. As such, do not:
+#   - modify
+#   - track in version control e.g. be sure to add to .gitignore
+__version__ = VERSION = '0.1.1'

jupyterlab_leetcode/handlers/__init__.py

@@ -0,0 +1,31 @@
+from jupyter_server.utils import url_path_join
+
+from .base_handler import BaseHandler
+from .cookie_handler import GetCookieHandler
+from .leetcode_handler import (CreateNotebookHandler, LeetCodeProfileHandler,
+                               LeetCodeQuestionHandler,
+                               LeetCodeStatisticsHandler,
+                               SubmitNotebookHandler)
+
+
+def setup_handlers(web_app):
+    host_pattern = ".*$"
+    base_url = web_app.settings["base_url"]
+    handlers: list[type[BaseHandler]] = [
+        GetCookieHandler,
+        LeetCodeProfileHandler,
+        LeetCodeStatisticsHandler,
+        LeetCodeQuestionHandler,
+        CreateNotebookHandler,
+        SubmitNotebookHandler,
+    ]
+
+    web_app.add_handlers(
+        host_pattern,
+        list(
+            map(
+                lambda h: (url_path_join(base_url, "jupyterlab-leetcode", h.route), h),
+                handlers,
+            )
+        ),
+    )

jupyterlab_leetcode/handlers/base_handler.py

@@ -0,0 +1,10 @@
+from jupyter_server.base.handlers import APIHandler
+
+
+class BaseHandler(APIHandler):
+    """Base handler for JupyterLab LeetCode extension.
+    This class extends APIHandler to provide a base for other handlers.
+    It can be used to define common functionality or properties for all handlers.
+    """
+
+    route = r""

jupyterlab_leetcode/handlers/cookie_handler.py

@@ -0,0 +1,87 @@
+import json
+import time
+from http.cookiejar import Cookie
+from typing import cast
+
+import browser_cookie3
+import tornado
+from tornado.httpclient import AsyncHTTPClient
+from tornado.httputil import HTTPHeaders
+
+from ..utils.utils import first
+from .base_handler import BaseHandler
+
+BROWSER_COOKIE_METHOD_MAP = {
+    "chrome": browser_cookie3.chrome,
+    "chromium": browser_cookie3.chromium,
+    "opera": browser_cookie3.opera,
+    "opera_gx": browser_cookie3.opera_gx,
+    "brave": browser_cookie3.brave,
+    "edge": browser_cookie3.edge,
+    "vivaldi": browser_cookie3.vivaldi,
+    "firefox": browser_cookie3.firefox,
+    "librewolf": browser_cookie3.librewolf,
+    "safari": browser_cookie3.safari,
+    "arc": browser_cookie3.arc,
+}
+
+
+class GetCookieHandler(BaseHandler):
+    route = r"cookies"
+
+    @tornado.web.authenticated
+    def get(self):
+        self.log.debug("Loading all cookies for LeetCode...")
+        browser = self.get_query_argument("browser", "", strip=True)
+        if not browser:
+            self.set_status(400)
+            self.finish(json.dumps({"message": "Browser parameter is required"}))
+            return
+
+        if browser not in BROWSER_COOKIE_METHOD_MAP:
+            self.set_status(400)
+            self.finish(json.dumps({"message": f"Unsupported browser: {browser}"}))
+            return
+
+        cj = BROWSER_COOKIE_METHOD_MAP[browser](domain_name="leetcode.com")
+        cookie_session = first(cj, lambda c: c.name == "LEETCODE_SESSION")
+        cookie_csrf = first(cj, lambda c: c.name == "csrftoken")
+        exist = bool(cookie_session and cookie_csrf)
+        expired = exist and (
+            cast(Cookie, cookie_session).is_expired()
+            or cast(Cookie, cookie_csrf).is_expired()
+        )
+        checked = exist and not expired
+
+        resp = {"exist": exist, "expired": expired, "checked": checked}
+
+        if checked:
+            cookie_session_expires = cast(Cookie, cookie_session).expires
+            max_age = (
+                cookie_session_expires - int(time.time())
+                if cookie_session_expires is not None
+                else 3600 * 24 * 14
+            )
+            self.set_cookie("leetcode_browser", browser, max_age=max_age)
+            self.settings.update(
+                leetcode_browser=browser,
+                leetcode_cookiejar=cj,
+                leetcode_headers=HTTPHeaders(
+                    {
+                        "Cookie": "; ".join(f"{c.name}={c.value}" for c in cj),
+                        "Content-Type": "application/json",
+                        "Origin": "https://leetcode.com",
+                        "Referer": "https://leetcode.com/",
+                        "X-CsrfToken": (
+                            cookie_csrf.value
+                            if cookie_csrf and cookie_csrf.value
+                            else ""
+                        ),
+                    }
+                ),
+            )
+            AsyncHTTPClient.configure(
+                None, defaults=dict(user_agent=self.request.headers.get("user-agent"))
+            )
+
+        self.finish(json.dumps(resp))

jupyterlab_leetcode/handlers/leetcode_handler.py

@@ -0,0 +1,464 @@
+import json
+import os
+from typing import Any, Mapping, cast, overload
+
+import tornado
+from tornado.gen import multi
+from tornado.httpclient import AsyncHTTPClient, HTTPRequest, HTTPResponse
+from tornado.httputil import HTTPHeaders
+
+from ..utils.notebook_generator import NotebookGenerator
+from ..utils.utils import first
+from .base_handler import BaseHandler
+
+LEETCODE_URL = "https://leetcode.com"
+LEETCODE_GRAPHQL_URL = f"{LEETCODE_URL}/graphql"
+
+type QueryType = dict[str, str | Mapping[str, Any]]
+
+
+class LeetCodeHandler(BaseHandler):
+    """Base handler for LeetCode-related requests."""
+
+    @overload
+    async def graphql(self, name: str, query: QueryType) -> None: ...
+
+    @overload
+    async def graphql(
+        self, name: str, query: QueryType, returnJson=True
+    ) -> dict[str, Any]: ...
+
+    async def graphql(self, name: str, query: QueryType, returnJson=False):
+        self.log.debug(f"Fetching LeetCode {name} data...")
+        client = AsyncHTTPClient()
+        req = HTTPRequest(
+            url=LEETCODE_GRAPHQL_URL,
+            method="POST",
+            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 {name}: {e}")
+            self.set_status(500)
+            self.finish(json.dumps({"message": f"Failed to fetch LeetCode {name}"}))
+            return
+        else:
+            if returnJson:
+                return json.loads(resp.body)
+            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)
+
+    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",
+            query={
+                "query": """query questionData($titleSlug: String!) {
+                                        question(titleSlug: $titleSlug) {
+                                            questionId
+                                            questionFrontendId
+                                            submitUrl
+                                            questionDetailUrl
+                                            title
+                                            titleSlug
+                                            content
+                                            isPaidOnly
+                                            difficulty
+                                            likes
+                                            dislikes
+                                            isLiked
+                                            similarQuestions
+                                            exampleTestcaseList
+                                            topicTags {
+                                                name
+                                                slug
+                                                translatedName
+                                            }
+                                            codeSnippets {
+                                                lang
+                                                langSlug
+                                                code
+                                            }
+                                            stats
+                                            hints
+                                            solution {
+                                                id
+                                                canSeeDetail
+                                                paidOnly
+                                                hasVideoSolution
+                                                paidOnlyVideo
+                                            }
+                                            status
+                                            sampleTestCase
+                                        }
+                                    }""",
+                "variables": {"titleSlug": title_slug},
+            },
+            returnJson=True,
+        )
+        return resp
+
+
+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)
+
+
+class LeetCodeQuestionHandler(LeetCodeHandler):
+    route = r"leetcode/questions"
+
+    @tornado.web.authenticated
+    async def post(self):
+        body = self.get_json_body()
+        if not body:
+            self.set_status(400)
+            self.finish(json.dumps({"message": "Request body is required"}))
+            return
+
+        body = cast("dict[str, str|int]", body)
+        skip = cast(int, body.get("skip", 0))
+        limit = cast(int, body.get("limit", 0))
+        keyword = cast(str, body.get("keyword", ""))
+        sortField = cast(str, body.get("sortField", "CUSTOM"))
+        sortOrder = cast(str, body.get("sortOrder", "ASCENDING"))
+
+        await self.graphql(
+            name="question_list",
+            query={
+                "query": """query problemsetQuestionListV2($filters: QuestionFilterInput,
+                                                                $limit: Int,
+                                                                $searchKeyword: String,
+                                                                $skip: Int,
+                                                                $sortBy: QuestionSortByInput,
+                                                                $categorySlug: String) {
+                                              problemsetQuestionListV2(
+                                                filters: $filters
+                                                limit: $limit
+                                                searchKeyword: $searchKeyword
+                                                skip: $skip
+                                                sortBy: $sortBy
+                                                categorySlug: $categorySlug
+                                              ) {
+                                                questions {
+                                                  id
+                                                  titleSlug
+                                                  title
+                                                  translatedTitle
+                                                  questionFrontendId
+                                                  paidOnly
+                                                  difficulty
+                                                  topicTags {
+                                                    name
+                                                    slug
+                                                    nameTranslated
+                                                  }
+                                                  status
+                                                  isInMyFavorites
+                                                  frequency
+                                                  acRate
+                                                }
+                                                totalLength
+                                                finishedLength
+                                                hasMore
+                                              }
+                                            }""",
+                "variables": {
+                    "skip": skip,
+                    "limit": limit,
+                    "searchKeyword": keyword,
+                    "categorySlug": "algorithms",
+                    "filters": {
+                        "filterCombineType": "ALL",
+                        "statusFilter": {
+                            "questionStatuses": ["TO_DO"],
+                            "operator": "IS",
+                        },
+                        "difficultyFilter": {
+                            "difficulties": ["MEDIUM", "HARD"],
+                            "operator": "IS",
+                        },
+                        "languageFilter": {"languageSlugs": [], "operator": "IS"},
+                        "topicFilter": {"topicSlugs": [], "operator": "IS"},
+                        "acceptanceFilter": {},
+                        "frequencyFilter": {},
+                        "frontendIdFilter": {},
+                        "lastSubmittedFilter": {},
+                        "publishedFilter": {},
+                        "companyFilter": {"companySlugs": [], "operator": "IS"},
+                        "positionFilter": {"positionSlugs": [], "operator": "IS"},
+                        "premiumFilter": {"premiumStatus": [], "operator": "IS"},
+                    },
+                    "sortBy": {"sortField": sortField, "sortOrder": sortOrder},
+                },
+            },
+        )
+
+
+class CreateNotebookHandler(LeetCodeHandler):
+    route = r"notebook/create"
+
+    @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)
+        title_slug = cast(str, body.get("titleSlug", ""))
+        if not title_slug:
+            self.set_status(400)
+            self.finish({"message": "titleSlug is required"})
+            return
+
+        question = await self.get_question_detail(title_slug)
+        question = question.get("data", {}).get("question")
+        if not question:
+            self.set_status(404)
+            self.finish({"message": "Question not found"})
+            return
+
+        notebook_generator = self.settings.get("notebook_generator")
+        if not notebook_generator:
+            notebook_generator = NotebookGenerator()
+            self.settings.update(notebook_generator=notebook_generator)
+
+        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)