Move code to leetcode-export folder

Author: NeverMendel

README.md

@@ -4,24 +4,21 @@
 
 ## DISCLAIMER
 
-All the problems hosted on leetcode.com are intellectual propriety of LeetCode, LLC. **DO NOT UPLOAD
-THE DESCRIPTION OF LEETCODE PROBLEMS ON GITHUB OR ON ANY OTHER WEBSITE** or you might receive ad DMCA Takedown notice.
+All the problems hosted on leetcode.com are intellectual propriety of LeetCode, LLC. **DO NOT UPLOAD THE DESCRIPTION OF
+LEETCODE PROBLEMS ON GITHUB OR ON ANY OTHER WEBSITE** or you might receive ad DMCA Takedown notice.
 
 Read [LeetCode Terms of Service here](https://leetcode.com/terms/).
 
 To avoid committing the problem description on git, you can add `*.txt` to your `.gitignore` file.
 
 ## How it works
 
-This script uses `selenium` and LeetCode APIs to download all your LeetCode submitted solutions.
+This script uses LeetCode REST and GraphQL APIs to download all your LeetCode submitted solutions.
 
-Before running the script, make sure that python3, chrome and `chromedriver` are installed in your system.
+Before running the script, make sure that python3 is installed in your system.
 
-If you do not want to configure and install all the required dependencies, you can download the Docker image. For
-further instructions read the section [Docker Image here](#docker-image).
-
-`chromedriver` is used to get the cookies needed to download your LeetCode submissions. Alternatively, you can provide
-the cookies using the flag `--cookies` in the Python script.
+If you prefer, you can use the Docker image to download your submissions. For further instructions read the
+section [Docker Image here](#docker-image).
 
 ## How to use
 
@@ -47,6 +44,49 @@ Now you can download all your LeetCode submission in the current folder by execu
 docker run -it -v $(pwd):/usr/app/out --rm nevermendel/leetcode-export
 ```
 
+## App parameters
+
+The script accepts the following parameters:
+
+```bash
+usage: app.py [-h] [--username USERNAME] [--password PASSWORD]
+              [--folder FOLDER] [--cookies COOKIES] [-v] [-vv]
+
+Export LeetCode solutions
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --username USERNAME   LeetCode username
+  --password PASSWORD   LeetCode password
+  --folder FOLDER       Output folder
+  --cookies COOKIES     LeetCode cookies
+  -v, --verbose         Enable verbose logging details
+  -vv, --extra-verbose  Enable more verbose logging details
+```
+
+## Login
+
+There are two ways to login in your LeetCode account, by providing username and password or by passing the cookies as program argument.
+
+### Username and Password:
+
+To login using username and password, insert them when prompted or pass them as parameter when lunching the
+script, like in the following example:
+
+```bash
+python ./app.py --username {USERNAME} --password {PASSWORD}`
+```
+
+The former option is to be preferred as it will avoid storing your password in the command history.
+
+### Cookies
+
+To login using cookies, pass the string containing them as parameter when lunching the script, like in the following example:
+
+```bash
+python ./app.py --cookies {COOKIES}
+```
+
 ## License
 
 [Apache License 2.0](LICENSE)

leetcode-export/app.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+import argparse
+import getpass
+import logging
+import os
+from datetime import datetime
+from string import Template
+from typing import List, Dict
+
+from leetcode import LeetCode
+from leetcode_rest import Submission
+from utils import language_to_extension, remove_special_characters
+
+PROBLEM_INFO_TEMPLATE = Template('''${questionId} - ${title}
+${difficulty} - https://leetcode.com/problems/${titleSlug}/
+
+${content}
+''')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Export LeetCode solutions')
+    parser.add_argument('--username', type=str, required=False, help='LeetCode username')
+    parser.add_argument('--password', type=str, required=False, help='LeetCode password')
+    parser.add_argument('--folder', type=str, required=False, help='Output folder', default='out')
+    parser.add_argument('--cookies', type=str, required=False, help='LeetCode cookies')
+    parser.add_argument('-v', '--verbose', dest='verbose', action='store_true', help='Enable verbose logging details')
+    parser.add_argument('-vv', '--extra-verbose', dest='extra_verbose', action='store_true',
+                        help='Enable more verbose logging details')
+    parser.set_defaults(verbose=False, extra_verbose=False)
+
+    return parser.parse_args()
+
+
+class App(object):
+    args = parse_args()
+
+    # Set logging level based on program arguments
+    level = logging.WARNING
+    if args.verbose:
+        level = logging.INFO
+    if args.extra_verbose:
+        level = logging.DEBUG
+
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s [%(levelname)s] %(filename)s:%(lineno)d - %(message)s",
+        handlers=[
+            logging.FileHandler("debug.log"),
+            logging.StreamHandler()
+        ]
+    )
+
+    leetcode = LeetCode()
+
+    if not args.cookies:
+        username = args.username
+        password = args.password
+
+        if not username:
+            username = input("Insert LeetCode username: ")
+        if not password:
+            password = getpass.getpass(prompt="Insert LeetCode password: ")
+        if not leetcode.log_in(args.username, args.password):
+            print(
+                "Login not successful! You might have entered the wrong username/password or you need to complete the reCAPTCHA. If you need to complete the captcha, log in with the cookies instead. Check the log for more informaton.")
+            exit(1)
+    else:
+        leetcode.set_cookies(args.cookies)
+
+    if not os.path.exists(args.folder):
+        os.mkdir(args.folder)
+    os.chdir(args.folder)
+
+    submissions: Dict[str, List[Submission]] = leetcode.get_submissions()
+
+    for slug in submissions:
+        logging.info(f"Processing {slug}")
+        if not os.path.exists(slug):
+            os.mkdir(slug)
+        else:
+            logging.info(f"Folder {slug} already exists")
+        os.chdir(slug)
+        problem_info = leetcode.get_problem(slug)
+        info_filename = f"{problem_info.questionId} - {slug}.txt"
+        if not os.path.exists(info_filename):
+            info_file = open(info_filename, 'w+')
+            info_file.write(PROBLEM_INFO_TEMPLATE.substitute(**problem_info.__dict__))
+            info_file.close()
+
+        for sub in submissions[slug]:
+            sub_filename = f"{datetime.fromtimestamp(sub.timestamp).strftime('%Y-%m-%d %H.%M.%S')} - {sub.status_display} - runtime {remove_special_characters(sub.runtime)} - memory {remove_special_characters(sub.memory)}.{language_to_extension(sub.lang)}"
+            if not os.path.exists(sub_filename):
+                logging.info(f"Writing {slug}/{sub_filename}")
+                sub_file = open(sub_filename, 'w+')
+                sub_file.write(sub.code)
+                sub_file.close()
+            else:
+                logging.info(f"{slug}/{sub_filename} already exists, skipping it")
+
+        os.chdir("..")

leetcode-export/leetcode.py

@@ -0,0 +1,78 @@
+import logging
+from time import sleep
+from typing import Dict, List
+
+import requests
+
+from leetcode_graphql import GRAPHQL_URL, question_detail_json, Problem
+from leetcode_rest import LOGIN_URL, SUBMISSIONS_API_URL, Submission, BASE_URL
+
+
+class LeetCode(object):
+    def __init__(self):
+        logging.debug("LeetCode class instantiated")
+        self.cookies = ''
+        self.user_logged = False
+
+    def log_in(self, username: str, password: str) -> bool:
+        session = requests.Session()
+
+        session.get(LOGIN_URL)
+
+        csrftoken = session.cookies.get('csrftoken')
+
+        headers = {'Origin': BASE_URL, 'Referer': LOGIN_URL}
+        payload = {'csrfmiddlewaretoken': csrftoken, 'login': username, 'password': password}
+
+        response_post = session.post(LOGIN_URL, headers=headers,
+                                     data=payload)  # sent using the same session, headers will also contain the cookies of the previous get request
+
+        if response_post.status_code == 200:
+            self.cookies = f"csrftoken={session.cookies.get('csrftoken')};LEETCODE_SESSION={session.cookies.get('LEETCODE_SESSION')};"
+            self.user_logged = True
+            logging.info("Login successful")
+            return True
+        else:
+            logging.warning(response_post.json())
+            return False
+
+    def set_cookies(self, cookies: str):
+        self.cookies = cookies
+        self.user_logged = True
+        logging.info("Cookies set successful")
+
+    def is_user_logged(self) -> bool:
+        if self.user_logged:
+            logging.debug("User is logged in")
+        else:
+            logging.debug("User is not logged in")
+        return self.user_logged
+
+    def get_problem(self, slug: str) -> Problem:
+        response = requests.post(
+            GRAPHQL_URL,
+            json=question_detail_json(slug),
+            headers={'Cookie': self.cookies})
+        if 'data' in response.json() and 'question' in response.json()['data']:
+            return Problem.from_dict(response.json()['data']['question'])
+
+    def get_submissions(self) -> Dict[str, List[Submission]]:
+        dictionary: Dict[str, List[Submission]] = {}
+        current = 0
+        response_json: Dict = {'has_next': True}
+        while 'detail' not in response_json and 'has_next' in response_json and response_json['has_next']:
+            logging.info(f"Exporting submissions from {current} to {current + 20}")
+            response_json = requests.get(
+                SUBMISSIONS_API_URL.format(current),
+                headers={'Cookie': self.cookies}).json()
+            if 'submissions_dump' in response_json:
+                for submission_dict in response_json['submissions_dump']:
+                    submission = Submission.from_dict(submission_dict)
+                    if submission.title_slug not in dictionary:
+                        dictionary[submission.title_slug] = []
+                    dictionary[submission.title_slug].append(submission)
+                sleep(1)
+            current += 20
+        if 'detail' in response_json:
+            logging.warning(response_json['detail'])
+        return dictionary

leetcode-export/leetcode_graphql.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+
+from dataclasses_json import dataclass_json
+
+GRAPHQL_URL = 'https://leetcode.com/graphql'
+
+
+@dataclass_json
+@dataclass
+class Problem:
+    questionId: int
+    difficulty: str
+    title: str
+    titleSlug: str
+    content: str
+
+
+def question_detail_json(slug):
+    return {
+        "operationName": "getQuestionDetail",
+        "variables": {
+            "titleSlug": slug
+        },
+        "query": """query getQuestionDetail($titleSlug: String!) {
+            question(titleSlug: $titleSlug) {
+                questionId
+                difficulty
+                title
+                titleSlug
+                content
+            }
+        }"""
+    }

leetcode-export/leetcode_rest.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+
+from dataclasses_json import dataclass_json
+
+BASE_URL = 'https://leetcode.com'
+LOGIN_URL = 'https://leetcode.com/accounts/login/'
+SUBMISSIONS_API_URL = 'https://leetcode.com/api/submissions/?offset={}&limit=20'
+PROBLEM_URL = 'https://leetcode.com/problems/'
+
+
+@dataclass_json
+@dataclass
+class Submission:
+    id: int
+    lang: str
+    time: str
+    timestamp: int
+    status_display: str
+    runtime: str
+    url: str
+    is_pending: str
+    title: str
+    memory: str
+    code: str
+    compare_result: str
+    title_slug: str

leetcode-export/utils.py

@@ -0,0 +1,34 @@
+FILE_EXTENSIONS = {
+    "python": 'py',
+    "python3": 'py',
+    "c": 'c',
+    "cpp": 'cpp',
+    "csharp": 'cs',
+    "java": 'java',
+    "kotlin": 'kt',
+    "mysql": 'sql',
+    "mssql": 'sql',
+    "oraclesql": 'sql',
+    "javascript": 'js',
+    "html": 'html',
+    "php": 'php',
+    "golang": 'go',
+    "scala": 'scala',
+    "pythonml": 'py',
+    "rust": 'rs',
+    "ruby": 'rb',
+    "bash": 'sh',
+    "swift": 'swift'
+}
+
+SPECIAL_CHARACTERS_FILENAME = ['/', '\\', ':', '*', '?', '"', '"', '<', '>', ' ', '|']
+
+
+def language_to_extension(language: str) -> str:
+    return FILE_EXTENSIONS[language]
+
+
+def remove_special_characters(string: str) -> str:
+    for el in SPECIAL_CHARACTERS_FILENAME:
+        string = string.replace(el, '')
+    return string