Change variable names of Problem class to snake_case and improve is_user_logged function to determine if user is logged based on get request result

Author: NeverMendel

Dockerfile

@@ -7,8 +7,8 @@ RUN apk add --no-cache \
       py3-pip
 
 # Copy current directory to /usr/src/app
-ADD . /usr/src/app
-WORKDIR /usr/src/app
+ADD . /usr/app
+WORKDIR /usr/app
 
 # Create out folder
 RUN mkdir -p out

README.md

@@ -23,14 +23,39 @@ section [Docker Image here](#docker-image).
 
 ## How to use
 
-### Run locally
+To use it locally you can either download it from pypi.org or you can clone this repository.
 
-First install all the needed dependencies by executing:
+## Download from pypi.org
+
+Execute `py install leetcode-export` to download it and install all the needed dependencies. You might need to use `py3`
+depending on how python is configured in your system.
+
+### Clone the repository
+
+Clone this repository:
+
+```bash
+git clone https://github.com/NeverMendel/leetcode-exports
+```
+
+Install all the needed dependencies:
 
 ```bash
 pip install -r requirements.txt
 ```
 
+Now you can either install it or just execute it:
+
+- To install leetcode-export in your system:
+    ```bash
+    python ./setup.py install
+    ```
+
+- To run the project without installing it:
+    ```bash
+    python -m leetcode_export --folder submissions
+    ```
+
 ### Docker Image
 
 Download the docker image from the DockerHub repository:
@@ -49,7 +74,7 @@ docker run -it -v $(pwd):/usr/app/out --rm nevermendel/leetcode-export
 
 The script accepts the following arguments:
 
-```bash
+```
 usage: leetcode-export [-h] [--username USERNAME] [--password PASSWORD]
                        [--folder FOLDER] [--cookies COOKIES] [-v] [-vv]
                        [--problem-filename PROBLEM_FILENAME]
@@ -73,27 +98,31 @@ optional arguments:
 
 ## Login
 
-To download your submissions you need to log in your LeetCode account. There are two ways to log in, by
+To download your submissions you need to log in your LeetCode account. There are two ways to log in, by inserting
 username/password or by cookies.
 
 You can either use the interactive menu to supply the required information or you can pass them as program arguments
 when lunching the script.
 
+The former option is to be preferred as it will avoid storing your password or your cookies in the command history.
+
 ### Username/Password
 
 To log in using username and password, insert them using the interactive menu (preferred) or pass them as arguments when
 lunching the script, like in the following example:
 
 ```bash
-python leetcode-export --username {USERNAME} --password {PASSWORD}`
+python leetcode-export --username {USERNAME} --password {PASSWORD}
 ```
 
-The former option is to be preferred as it will avoid storing your password in the command history.
-
 ### Cookies
 
-To log in using cookies, pass the string containing them as arguments when lunching the script, like in the following
-example:
+To log in using cookies, you first need to get them from a session where you are already logged in. Login in your
+browser, open the browser's Dev Tool, click on the Network tab and copy the cookie header that is sent when you visit
+any leetcode webpage.
+
+You can insert the cookie string that you have just copied in the interactive menu (recommended) or you can pass it as a
+program argument when lunching the script, like in the following example:
 
 ```bash
 python leetcode-export --cookies {COOKIES}
@@ -114,11 +143,11 @@ The template can contain parameters that will later be replaced based on the Lee
 parameters are the following:
 
 ```python
-questionId: int
+question_id: int
 difficulty: str
 stats: str
 title: str
-titleSlug: str
+title_slug: str
 ```
 
 Default problem description filename template: `${questionId} - ${titleSlug}.txt`

leetcode_export/__main__.py

@@ -9,23 +9,23 @@
 from leetcode_export.leetcode import LeetCode
 from leetcode_export.leetcode_rest import Submission
 
-PROBLEM_CONTENT_TEMPLATE = Template('''${questionId} - ${title}
-${difficulty} - https://leetcode.com/problems/${titleSlug}/
+PROBLEM_CONTENT_TEMPLATE = Template('''${question_id} - ${title}
+${difficulty} - https://leetcode.com/problems/${title_slug}/
 
 ${content}
 ''')
 
 
 def parse_args():
     parser = argparse.ArgumentParser(description='Export LeetCode solutions')
-    parser.add_argument('--username', type=str, required=False, help='Set LeetCode username')
-    parser.add_argument('--password', type=str, required=False, help='Set LeetCode password')
-    parser.add_argument('--folder', type=str, required=False, help='Output folder', default='out')
-    parser.add_argument('--cookies', type=str, required=False, help='Set LeetCode cookies')
+    parser.add_argument('--username', type=str, help='Set LeetCode username')
+    parser.add_argument('--password', type=str, help='Set LeetCode password')
+    parser.add_argument('--cookies', type=str, help='Set LeetCode cookies')
+    parser.add_argument('--folder', type=str, default='.', help='Output folder')
     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.add_argument('--problem-filename', type=str, default='${questionId} - ${titleSlug}.txt',
+    parser.add_argument('--problem-filename', type=str, default='${question_id} - ${title_slug}.txt',
                         help='Problem description filename format')
     parser.add_argument('--submission-filename', type=str,
                         default='${date_formatted} - ${status_display} - runtime ${runtime} - memory ${memory}.${extension}',

leetcode_export/leetcode.py

@@ -1,72 +1,84 @@
+import datetime
 import logging
-from datetime import datetime
 from time import sleep
 from typing import Dict, List
 
 import requests
 
 from leetcode_export.leetcode_graphql import GRAPHQL_URL, question_detail_json, Problem
 from leetcode_export.leetcode_rest import LOGIN_URL, SUBMISSIONS_API_URL, Submission, BASE_URL
-from leetcode_export.utils import language_to_extension, remove_special_characters
+from leetcode_export.utils import language_to_extension, remove_special_characters, dict_camelcase_to_snakecase
 
 
 class LeetCode(object):
     def __init__(self):
         logging.debug("LeetCode class instantiated")
-        self.cookies = ''
+        self.session = requests.Session()
         self.user_logged = False
+        self.user_logged_expiration = datetime.datetime.now()
 
     def log_in(self, username: str, password: str) -> bool:
-        session = requests.Session()
+        self.session.get(LOGIN_URL)
 
-        session.get(LOGIN_URL)
-
-        csrftoken = session.cookies.get('csrftoken')
+        csrftoken = self.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
+        response_post = self.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
+        if response_post.status_code == 200 and self.is_user_logged():
+            # self.cookies = f"csrftoken={self.session.cookies.get('csrftoken')};LEETCODE_SESSION={self.session.cookies.get('LEETCODE_SESSION')};"
             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")
+        cookies_list = cookies.split(';')
+        cookies_list = map(lambda el: el.split('='), cookies_list)
+        for cookies in cookies_list:
+            self.session.cookies.set(cookies[0].strip(), cookies[1].strip())
+        if self.is_user_logged():
+            logging.info("Cookies set successful")
+        else:
+            logging.warning("Cookies set failed")
 
     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
+        if self.user_logged and datetime.datetime.now() > self.user_logged_expiration:
+            return True
+        cookie_dict = self.session.cookies.get_dict()
+        if 'csrftoken' in cookie_dict and 'LEETCODE_SESSION' in cookie_dict:
+            get_request = self.session.get(SUBMISSIONS_API_URL.format(0))
+            if 'detail' not in get_request.json():
+                logging.debug("User is logged in")
+                self.user_logged = True
+                self.user_logged_expiration = datetime.datetime.now() + datetime.timedelta(hours=5)
+                return True
+        logging.debug("User is not logged in")
+        return False
 
     def get_problem(self, slug: str) -> Problem:
-        response = requests.post(
+        response = self.session.post(
             GRAPHQL_URL,
-            json=question_detail_json(slug),
-            headers={'Cookie': self.cookies})
+            json=question_detail_json(slug))
         if 'data' in response.json() and 'question' in response.json()['data']:
-            return Problem.from_dict(response.json()['data']['question'])
+            problem_dict = dict_camelcase_to_snakecase(response.json()['data']['question'])
+            return Problem.from_dict(problem_dict)
 
     def get_submissions(self) -> Dict[str, List[Submission]]:
+        if not self.is_user_logged():
+            logging.warning("Trying to get user submissions while user is not logged in")
+            return {}
         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()
+            response_json = self.session.get(
+                SUBMISSIONS_API_URL.format(current)).json()
             if 'submissions_dump' in response_json:
                 for submission_dict in response_json['submissions_dump']:
                     submission_dict['runtime'] = submission_dict['runtime'].replace(' ', '')

leetcode_export/leetcode_graphql.py

@@ -8,11 +8,11 @@
 @dataclass_json
 @dataclass
 class Problem:
-    questionId: int
+    question_id: int
     difficulty: str
     stats: str
     title: str
-    titleSlug: str
+    title_slug: str
     content: str
 
 

leetcode_export/utils.py

@@ -1,3 +1,6 @@
+import re
+from typing import Dict
+
 FILE_EXTENSIONS = {
     "python": 'py',
     "python3": 'py',
@@ -22,6 +25,8 @@
 }
 
 SPECIAL_CHARACTERS_FILENAME = ['/', '\\', ':', '*', '?', '"', '"', '<', '>', '|']
+_regex_camelcase_to_snakecase1 = re.compile(r'(.)([A-Z][a-z]+)')
+_regex_camelcase_to_snakecase2 = re.compile('([a-z0-9])([A-Z])')
 
 
 def language_to_extension(language: str) -> str:
@@ -32,3 +37,15 @@ def remove_special_characters(string: str) -> str:
     for el in SPECIAL_CHARACTERS_FILENAME:
         string = string.replace(el, '')
     return string
+
+
+def camelcase_to_snakecase(string: str) -> str:
+    subbed = _regex_camelcase_to_snakecase1.sub(r'\1_\2', string)
+    return _regex_camelcase_to_snakecase2.sub(r'\1_\2', subbed).lower()
+
+
+def dict_camelcase_to_snakecase(dictionary: Dict[str, any]) -> Dict[str, any]:
+    new_dict: Dict[str, any] = {}
+    for key in dictionary:
+        new_dict[camelcase_to_snakecase(key)] = dictionary[key]
+    return new_dict