├── .gitattributes
├── .gitignore
├── LICENSE
├── README.md
├── config.json
├── helper
    ├── __init__.py
    ├── config.py
    ├── constants.py
    ├── extractor.py
    ├── login.py
    ├── main.py
    ├── node.py
    ├── problems.py
    ├── templates.py
    └── utils.py
├── imgs
    ├── leetcode-logo.png
    └── leetcode_dashboard.png
├── run.py
├── tests
    ├── __init__.py
    └── test_config.py
└── update_leetcode_dashboard.sh


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | db/
2 | .vscode
3 | **/__pycache__
4 | **/.ipynb_checkpoints/
5 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Herbert Lu, KivenChen
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## hugo-leetcode-dashboard
 2 | 
 3 | ✨ 一个 LeetCode 答题看板的生成插件， 支持一键部署到 Hugo 站点。 **完整记录刷题心路历程** ✨
 4 | 
 5 | [在线预览 Demo](https://blog.herbert.top/leetcode/)
 6 | 
 7 | ## Screenshots
 8 | 
 9 | ![leetcode-dashboard](https://raw.githubusercontent.com/lryong/hugo-leetcode-dashboard/master/imgs/leetcode_dashboard.png)
10 | 
11 | ## Installation
12 | 
13 | 1. 下载 Repo 到本地：
14 | 
15 |    ```shell
16 |    git  clone https://github.com/lryong/hugo-leetcode-dashboard
17 |    ```
18 | 
19 | 2. 安装依赖： 本项目需要用到 `requests` 和 `aiohttp` 包， 通过 pip 安装即可。
20 | 
21 | 3. 更新仓库根目录下的 `config.json`文件：
22 | 
23 |    ```json
24 |    {
25 |      "username": "leetcode-cn@leetcode",
26 |      "password": "leetcode",
27 |      "outputDir": "../LeetCode"
28 |    }
29 |    ```
30 | 
31 |    username 是 LeetCode-cn 账号， password 是对应密码。
32 |    outputDir 为 dashboard 生成路径。 (注： 这里配置为 hugo 站点的文档路径， 如：/Users/XXX/my_blogs/content)
33 | 
34 | 4. 因为 Hugo 默认只支持 _markdown_ 文档, 在个人网站根目录下新建 `layouts/shortcodes/rawhtml.html`文件，以支持原生 HTML：
35 | 
36 |    ```css
37 |    <!-- raw html -- > {
38 |       {
39 |        .Inner;
40 |      }
41 |    }
42 |    ```
43 | 
44 |    (_具体参考[这里](https://anaulin.org/blog/hugo-raw-html-shortcode/)_)
45 | 
46 | 5. 最后**一键部署到 Hugo 站点**， 参考以下命令：
47 | 
48 |    ```shell
49 |    echo "2" | python3 run.py && cp imgs/leetcode-logo.png /Users/XXX/my_blogs/static/images
50 |    ```
51 | 
52 | ## Directory Structure
53 | 
54 | 通过 `hugo-leetcode-dashboard` 生成的文件目录如下：
55 | 
56 | ```shell
57 | .
58 | ├── leetcode.md # 中文看板入口
59 | ├── leetcode_en.md #英文看板入口
60 | ├── problemset # 答题集
61 | │   ├── 3sum #题目
62 | │   │   ├── 3sum.go #题解原文件
63 | │   │   ├── 3sum.go.md # 题解
64 | │   │   ├── readme.md # 中文题目描述
65 | │   │   └── readme_en.md # 英文题目描述
66 | ```
67 | 
68 | 把以上文件放到 hugo 文章根目录即可
69 | 
70 | ## Features
71 | 
72 | 1. 答题情况总览（完成的题目和整体进程）
73 | 2. LeetCode 个人答题看板， 包括展示 题号，题目，收藏标签，解答的语言， 题目通过率， 难度和题目类型
74 | 3. 展示 LeetCode 问题描述
75 | 4. 展示 LeetCode 个人的解题方案
76 | 
77 | ## License
78 | 
79 | Released under the [MIT](https://github.com/lryong/hugo-leetcode-dashboard/blob/master/LICENSE) License.
80 | 
81 | ## Acknowledgements
82 | 
83 | - [LeetCode_Helper](https://github.com/KivenCkl/LeetCode_Helper)
84 | 


--------------------------------------------------------------------------------
/config.json:
--------------------------------------------------------------------------------
1 | {"username": "leecode-cn@leetcode.com", "password": "leetcode", "outputDir": "/Users/XXX/my_blogs/content"}
2 | 


--------------------------------------------------------------------------------
/helper/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lryong/hugo-leetcode-dashboard/d3ae5f6a93d05286a4b2294d4ae58a93851c8ccd/helper/__init__.py


--------------------------------------------------------------------------------
/helper/config.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | import os
 3 | 
 4 | 
 5 | class Config:
 6 |     '''
 7 |     获取配置信息并储存至 `config.json`
 8 |     '''
 9 | 
10 |     def __init__(self):
11 |         self.data = self.__getConfig()
12 | 
13 |     def __getConfig(self):
14 |         path = os.path.join(os.path.abspath(os.path.join(__file__, "../..")),
15 |                             'config.json')
16 |         if not os.path.exists(path):
17 |             username = input('请输入您的用户名: ')
18 |             password = input('请输入您的密码: ')
19 |             outputDir = input('请选择您要输出的目录: ')
20 |             data = dict(username=username,
21 |                         password=password,
22 |                         outputDir=outputDir,
23 |                         timeInterval=0.1)
24 |             with open(path, 'w') as f:
25 |                 json.dump(data, f)
26 |             return data
27 |         else:
28 |             with open(path, 'r') as f:
29 |                 return json.load(f)
30 | 
31 |     def __getData(self, item):
32 |         return self.data.get(item) if self.data else None
33 | 
34 |     @property
35 |     def username(self):
36 |         return self.__getData('username')
37 | 
38 |     @property
39 |     def password(self):
40 |         return self.__getData('password')
41 | 
42 |     @property
43 |     def outputDir(self):
44 |         return self.__getData('outputDir')
45 | 
46 |     @property
47 |     def timeInterval(self):
48 |         return self.__getData('timeInterval') or 0.1
49 | 
50 | 
51 | config = Config()
52 | 


--------------------------------------------------------------------------------
/helper/constants.py:
--------------------------------------------------------------------------------
  1 | # LeetCode 相关链接
  2 | LEETCODE = "https://leetcode-cn.com"
  3 | GRAPHQL = LEETCODE + "/graphql"
  4 | LOGIN = LEETCODE + "/accounts/login/"
  5 | PROBLEMS = LEETCODE + "/api/problems/all/"
  6 | SUBMISSIONS_FORMAT = LEETCODE + "/api/submissions/?offset={}&limit=20"
  7 | CODE_FORMAT = LEETCODE + "/submissions/latest/?qid={}&lang={}"
  8 | TAG_FORMAT = LEETCODE + "/tag/{}"
  9 | PROBLEM_FORMAT = LEETCODE + "/problems/{}/"
 10 | 
 11 | HEADERS = {
 12 |     'Origin':
 13 |     LEETCODE,
 14 |     'User-Agent':
 15 |     'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.140 Safari/537.36 Edge/17.17134'
 16 | }
 17 | 
 18 | DIFFICULTY_CN = ['', '简单', '中等', '困难']
 19 | DIFFICULTY_EN = ['', 'easy', 'medium', 'hard']
 20 | 
 21 | LANGS = {
 22 |     'bash': {
 23 |         'lang': 'Shell',
 24 |         'ext': 'sh',
 25 |         'style': '#'
 26 |     },
 27 |     'c': {
 28 |         'lang': 'C',
 29 |         'ext': 'c',
 30 |         'style': '//'
 31 |     },
 32 |     'cpp': {
 33 |         'lang': 'C++',
 34 |         'ext': 'cpp',
 35 |         'style': '//'
 36 |     },
 37 |     'php': {
 38 |         'lang': 'PHP',
 39 |         'ext': 'php',
 40 |         'style': '//'
 41 |     },
 42 |     'typescript': {
 43 |         'lang': 'TypeScript',
 44 |         'ext': 'ts',
 45 |         'style': '//'
 46 |     },
 47 |     'racket': {
 48 |         'lang': 'Racket',
 49 |         'ext': 'rkt',
 50 |         'style': ';'
 51 |     },
 52 |     'erlang': {
 53 |         'lang': 'Erlang',
 54 |         'ext': 'erl',
 55 |         'style': '%'
 56 |     },
 57 |     'elixir': {
 58 |         'lang': 'Elixir',
 59 |         'ext': 'exs',
 60 |         'style': '#'
 61 |     },
 62 |     'csharp': {
 63 |         'lang': 'C#',
 64 |         'ext': 'cs',
 65 |         'style': '//'
 66 |     },
 67 |     'golang': {
 68 |         'lang': 'Go',
 69 |         'ext': 'go',
 70 |         'style': '//'
 71 |     },
 72 |     'java': {
 73 |         'lang': 'Java',
 74 |         'ext': 'java',
 75 |         'style': '//'
 76 |     },
 77 |     'javascript': {
 78 |         'lang': 'JavaScript',
 79 |         'ext': 'js',
 80 |         'style': '//'
 81 |     },
 82 |     'kotlin': {
 83 |         'lang': 'Kotlin',
 84 |         'ext': 'kt',
 85 |         'style': '//'
 86 |     },
 87 |     'mysql': {
 88 |         'lang': 'SQL',
 89 |         'ext': 'sql',
 90 |         'style': '--'
 91 |     },
 92 |     'python': {
 93 |         'lang': 'Python',
 94 |         'ext': 'py',
 95 |         'style': '#'
 96 |     },
 97 |     'python3': {
 98 |         'lang': 'Python3',
 99 |         'ext': 'py',
100 |         'style': '#'
101 |     },
102 |     'ruby': {
103 |         'lang': 'Ruby',
104 |         'ext': 'rb',
105 |         'style': '#'
106 |     },
107 |     'rust': {
108 |         'lang': 'Rust',
109 |         'ext': 'rs',
110 |         'style': '//'
111 |     },
112 |     'scala': {
113 |         'lang': 'Scala',
114 |         'ext': 'scala',
115 |         'style': '//'
116 |     },
117 |     'swift': {
118 |         'lang': 'Swift',
119 |         'ext': 'swift',
120 |         'style': '//'
121 |     }
122 | }
123 | 


--------------------------------------------------------------------------------
/helper/extractor.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import time
  3 | import concurrent.futures
  4 | from .templates import *
  5 | from .constants import *
  6 | 
  7 | 
  8 | class Extractor:
  9 |     '''
 10 |     高速并发导出数据类
 11 |     '''
 12 |     def __init__(self, output_dir, author):
 13 |         self.output_dir = output_dir
 14 |         self.author = author
 15 | 
 16 |     def extractInfo(self, info, datas):
 17 |         '''导出 LeetCode README 文件'''
 18 |         # 当前时间
 19 |         cur_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
 20 |         readme_cn_path = os.path.join(self.output_dir, 'leetcode.md')
 21 |         with open(readme_cn_path, 'w', encoding='utf-8') as f:
 22 |             f.write(
 23 |                 TEMPLATE_README_CN.format(
 24 |                     user_name=info.user_name,
 25 |                     num_solved=info.num_solved,
 26 |                     num_total=info.num_total,
 27 |                     ac_easy=info.ac_easy,
 28 |                     ac_medium=info.ac_medium,
 29 |                     ac_hard=info.ac_hard,
 30 |                     time=cur_time))
 31 |             solutions = []
 32 |             for i, data in enumerate(datas):
 33 |                 solutions.append('[{0}](../problemset/{1}/{1}.{2})'.format(
 34 |                     data["language"], data["title_slug"],
 35 |                     LANGS[data["lang"]]["ext"]))
 36 |                 title = '[{}](../problemset/{}/readme)'.format(
 37 |                     data["title_cn"], data["title_slug"])
 38 |                 # 判断同一问题是否有多个解
 39 |                 if i == len(datas) - 1 or datas[i]['title_en'] != datas[
 40 |                         i + 1]['title_en']:
 41 |                     f.write(
 42 |                         TEMPLATE_README_APPEND.format(
 43 |                             frontend_id=data['frontend_id'],
 44 |                             title=title,
 45 |                             paid_only=data['paid_only'],
 46 |                             is_favor=data['is_favor'],
 47 |                             solutions='、'.join(solutions),
 48 |                             ac_rate=data['ac_rate'],
 49 |                             difficulty=DIFFICULTY_CN[data['difficulty']],
 50 |                             tags=data['tags_cn'].replace('- ', '').replace(
 51 |                                 '\n', '、')))
 52 |                     solutions = []
 53 |         print(f'{os.path.abspath(readme_cn_path)} done!')
 54 |         readme_en_path = os.path.join(self.output_dir, 'leetcode_en.md')
 55 |         with open(readme_en_path, 'w', encoding='utf-8') as f:
 56 |             f.write(
 57 |                 TEMPLATE_README_EN.format(
 58 |                     user_name=info.user_name,
 59 |                     num_solved=info.num_solved,
 60 |                     num_total=info.num_total,
 61 |                     ac_easy=info.ac_easy,
 62 |                     ac_medium=info.ac_medium,
 63 |                     ac_hard=info.ac_hard,
 64 |                     time=cur_time))
 65 |             solutions = []
 66 |             for i, data in enumerate(datas):
 67 |                 solutions.append('[{0}](../problemset/{1}/{1}.{2})'.format(
 68 |                     data["language"], data["title_slug"],
 69 |                     LANGS[data["lang"]]["ext"]))
 70 |                 title = '[{}](../problemset/{}/readme_en)'.format(
 71 |                     data["title_en"], data["title_slug"])
 72 |                 if i == len(datas) - 1 or datas[i]['title_en'] != datas[
 73 |                         i + 1]['title_en']:
 74 |                     f.write(
 75 |                         TEMPLATE_README_APPEND.format(
 76 |                             frontend_id=data['frontend_id'],
 77 |                             title=title,
 78 |                             paid_only=data['paid_only'],
 79 |                             is_favor=data['is_favor'],
 80 |                             solutions=', '.join(solutions),
 81 |                             ac_rate=data['ac_rate'],
 82 |                             difficulty=DIFFICULTY_EN[data['difficulty']],
 83 |                             tags=data['tags_en'].replace('- ', '').replace(
 84 |                                 '\n', ', ')))
 85 |                     solutions = []
 86 |         print(f'{os.path.abspath(readme_en_path)} done!')
 87 | 
 88 |     def __extractDesc(self, data):
 89 |         if data['d_stored'] == 1:
 90 |             return
 91 |         folder_path = os.path.join(self.output_dir, 'problemset',
 92 |                                    data['title_slug'])
 93 |         if not os.path.exists(folder_path):
 94 |             # 创建问题文件夹
 95 |             os.makedirs(folder_path, exist_ok=True)
 96 |         readme_cn_path = os.path.join(folder_path, 'readme.md')
 97 |         title_cn = '[{}. {}]({})'.format(
 98 |             data['frontend_id'], data['title_cn'],
 99 |             PROBLEM_FORMAT.format(data['title_slug']))
100 |         with open(readme_cn_path, 'w', encoding='utf-8') as f:
101 |             f.write(
102 |                 TEMPLATE_DESC_CN.format(
103 |                     title_cn=title_cn,
104 |                     content_cn=data['content_cn'],
105 |                     tags_cn=data['tags_cn'],
106 |                     similar_questions_cn=data['similar_questions_cn']))
107 |         print(f'{os.path.abspath(readme_cn_path)} done!')
108 | 
109 |         readme_en_path = os.path.join(folder_path, 'readme_en.md')
110 |         title_en = '[{}. {}]({})'.format(
111 |             data['frontend_id'], data['title_en'],
112 |             PROBLEM_FORMAT.format(data['title_slug']))
113 |         with open(readme_en_path, 'w', encoding='utf-8') as f:
114 |             f.write(
115 |                 TEMPLATE_DESC_EN.format(
116 |                     title_en=title_en,
117 |                     content_en=data['content_en'],
118 |                     tags_en=data['tags_en'],
119 |                     similar_questions_en=data['similar_questions_en']))
120 |         print(f'{os.path.abspath(readme_en_path)} done!')
121 | 
122 |     def extractDesc(self, datas):
123 |         '''导出问题描述'''
124 |         with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
125 |             # futures = {executor.submit(self.__extractDesc, data): data for data in datas}
126 |             # for future in concurrent.futures.as_completed(futures):
127 |             #     data = futures[future]
128 |             for _ in executor.map(self.__extractDesc, datas):
129 |                 pass
130 | 
131 |     def __extractCode(self, data):
132 |         if data['s_stored'] == 1:
133 |             return
134 |         folder_path = os.path.join(self.output_dir, 'problemset',
135 |                                    data['title_slug'])
136 |         if not os.path.exists(folder_path):
137 |             os.makedirs(folder_path)
138 |         code_path = os.path.join(
139 |             folder_path, f'{data["title_slug"]}.{LANGS[data["lang"]]["ext"]}.md')
140 |         with open(code_path, 'w', encoding='utf-8') as f:
141 |             f.write(
142 |                 TEMPLATE_CODE.format(
143 |                     style=LANGS[data['lang']]['style'],
144 |                     title_cn=data['title_cn'],
145 |                     title_en=data['title_en'],
146 |                     author=self.author,
147 |                     timestamp=data['timestamp'],
148 |                     runtime=data['runtime'],
149 |                     memory=data['memory'],
150 |                     ext=LANGS[data['lang']]['ext'],
151 |                     code=data['code']))
152 |         print(f'{os.path.abspath(code_path)} done!')
153 | 
154 |     def extractCode(self, datas):
155 |         '''导出代码'''
156 |         with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
157 |             for _ in executor.map(self.__extractCode, datas):
158 |                 pass
159 | 


--------------------------------------------------------------------------------
/helper/login.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | from .constants import LEETCODE, LOGIN, HEADERS
 3 | 
 4 | 
 5 | class Login:
 6 |     '''
 7 |     登录 LeetCode-cn, 获取 cookies 值
 8 |     '''
 9 | 
10 |     def __init__(self, username, password):
11 |         self.username = username
12 |         self.password = password
13 |         self.__cookies = ''
14 |         self.status = False
15 | 
16 |     def doLogin(self):
17 |         resp = requests.get(LEETCODE, headers=HEADERS)
18 |         # token = resp.cookies['csrftoken']
19 |         token = ""
20 |         headers = HEADERS.copy()
21 |         headers.update({
22 |             'referer': LOGIN,
23 |             'x-csrftoken': token,
24 |             'x-requested-with': 'XMLHttpRequest'
25 |         })
26 |         payload = {
27 |             'login': self.username,
28 |             'password': self.password,
29 |             'csrfmiddlewaretoken': token
30 |         }
31 |         cookies = {'csrftoken': token}
32 |         resp = requests.post(
33 |             LOGIN, data=payload, headers=headers, cookies=cookies)
34 |         if resp.status_code == 200:
35 |             self.status = True
36 |             self.__cookies = resp.cookies
37 |             # user = resp.json()['form']['fields']['login']['value']
38 |         if self.status:
39 |             print(f'{self.username} 登录成功！')
40 |         else:
41 |             print('登录失败！')
42 |             print('请检查用户名和密码！')
43 | 
44 |     @property
45 |     def cookies(self):
46 |         if not self.status:
47 |             self.doLogin()
48 |         return self.__cookies
49 | 


--------------------------------------------------------------------------------
/helper/main.py:
--------------------------------------------------------------------------------
 1 | from .problems import Problems
 2 | import asyncio
 3 | 
 4 | 
 5 | class Main:
 6 |     '''主程序'''
 7 | 
 8 |     def __init__(self):
 9 |         self.problems = Problems()
10 | 
11 |     def __info(self):
12 |         print(self.problems.info)
13 | 
14 |     def update(self):
15 |         '''更新数据'''
16 |         self.__info()
17 |         loop = asyncio.get_event_loop()
18 |         loop.run_until_complete(self.problems.update())
19 | 
20 |     def rebuild(self):
21 |         '''重建数据'''
22 |         self.__info()
23 |         self.problems.clearDB()
24 |         self.update()
25 | 


--------------------------------------------------------------------------------
/helper/node.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | import re
  3 | import time
  4 | from .constants import LANGS, TAG_FORMAT
  5 | 
  6 | 
  7 | class ProblemInfoNode:
  8 |     '''解析问题基本信息'''
  9 | 
 10 |     def __init__(self, json_data):
 11 |         self.difficulty = json_data['difficulty']['level']
 12 |         self.is_favor = self.__formFavor(json_data['is_favor'])
 13 |         self.paid_only = self.__formPaid(json_data['paid_only'])
 14 |         self.status = json_data['status']
 15 |         self.id = json_data['stat']['question_id']
 16 |         # self.frontend_id = self.__formId(
 17 |         #     json_data['stat']['frontend_question_id'])
 18 |         self.frontend_id = json_data['stat']['frontend_question_id']
 19 |         self.title_en = json_data['stat']['question__title']
 20 |         self.title_slug = json_data['stat']['question__title_slug']
 21 |         self.total_acs = json_data['stat']['total_acs']
 22 |         self.total_submitted = json_data['stat']['total_submitted']
 23 | 
 24 |     @property
 25 |     def ac_rate(self):
 26 |         return '{:.1%}'.format(self.total_acs / (self.total_submitted + 1))
 27 | 
 28 |     def __formFavor(self, is_favor):
 29 |         return '❤️' if is_favor else ''
 30 | 
 31 |     def __formPaid(self, paid_only):
 32 |         return '🔒' if paid_only else ''
 33 | 
 34 |     def __formId(self, id):
 35 |         return '{:0>4d}'.format(id)
 36 | 
 37 | 
 38 | class ProblemDescNode:
 39 |     '''解析问题描述信息'''
 40 | 
 41 |     def __init__(self, json_data):
 42 |         self.id = json_data['data']['question']['questionId']
 43 |         self.content_en = self.__formContentEN(
 44 |             json_data['data']['question']['content'])
 45 |         self.title_cn = json_data['data']['question']['translatedTitle']
 46 |         self.content_cn = self.__formContentCN(
 47 |             json_data['data']['question']['translatedContent'])
 48 |         self.similar_questions_cn, self.similar_questions_en = self.__formSimilarQuestions(
 49 |             json_data['data']['question']['similarQuestions'])
 50 |         self.tags_cn, self.tags_en = self.__formTags(
 51 |             json_data['data']['question']['topicTags'])
 52 |         # self.hints = '\n'.join(json_data['data']['question']['hints'])
 53 | 
 54 |     def __formSimilarQuestions(self, similar_questions):
 55 |         question_list = re.findall(r'{.*?}', similar_questions)
 56 |         similar_questions_cn, similar_questions_en = [], []
 57 |         if question_list:
 58 |             for q in question_list:
 59 |                 data = json.loads(q)
 60 |                 similar_questions_cn.append('- [{}](../{}/README.md)'.format(
 61 |                     data['translatedTitle'], data['titleSlug']))
 62 |                 similar_questions_en.append(
 63 |                     '- [{}](../{}/README_EN.md)'.format(
 64 |                         data['title'], data['titleSlug']))
 65 |         return '\n'.join(similar_questions_cn), '\n'.join(similar_questions_en)
 66 | 
 67 |     def __formTags(self, tags):
 68 |         tags_cn, tags_en = [], []
 69 |         for tag in tags:
 70 |             tags_cn.append(
 71 |                 f'- [{tag["translatedName"]}]({TAG_FORMAT.format(tag["slug"])})'
 72 |             )
 73 |             tags_en.append(
 74 |                 f'- [{tag["name"]}]({TAG_FORMAT.format(tag["slug"])})')
 75 |         return '\n'.join(tags_cn), '\n'.join(tags_en)
 76 | 
 77 |     def __formContentCN(self, content):
 78 |         if not content:
 79 |             return
 80 |         return content.replace('↵↵', '').replace('↵', '\n')
 81 | 
 82 |     def __formContentEN(self, content):
 83 |         if not content:
 84 |             return
 85 |         return content.replace('↵', '').replace('\r\n', '\n')
 86 | 
 87 | 
 88 | class SubmissionNode:
 89 |     '''解析提交的代码信息'''
 90 | 
 91 |     def __init__(self, dic):
 92 |         self.submission_id = dic['id']
 93 |         self.lang = dic['lang']
 94 |         self.memory = dic['memory']
 95 |         self.runtime = dic['runtime']
 96 |         self.timestamp = self.__formTime(int(dic['timestamp']))
 97 |         self.title_slug = dic['title_slug']
 98 | 
 99 |     @property
100 |     def language(self):
101 |         return LANGS[self.lang]['lang']
102 | 
103 |     def __formTime(self, timeStamp):
104 |         return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timeStamp))
105 | 
106 |     def __formCode(self, code):
107 |         return code.replace('↵', '\n')
108 | 
109 | 
110 | class InfoNode:
111 |     '''解析用户基本信息'''
112 | 
113 |     def __init__(self, json_data):
114 |         self.user_name = json_data.get('user_name')
115 |         self.ac_easy = json_data.get('ac_easy')
116 |         self.ac_medium = json_data.get('ac_medium')
117 |         self.ac_hard = json_data.get('ac_hard')
118 |         self.num_solved = json_data.get('num_solved')
119 |         self.num_total = json_data.get('num_total')
120 | 
121 |     def __repr__(self):
122 |         return (
123 |             f'user_name: {self.user_name}\nac_easy: {self.ac_easy}\nac_medium: {self.ac_medium}\nac_hard: {self.ac_hard}\nnum_solved: {self.num_solved}\nnum_total: {self.num_total}'
124 |         )
125 | 


--------------------------------------------------------------------------------
/helper/problems.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import sqlite3
  3 | import requests
  4 | import asyncio
  5 | import aiohttp
  6 | from .config import config
  7 | from .login import Login
  8 | from .extractor import Extractor
  9 | from .utils import handle_tasks
 10 | from .node import InfoNode, ProblemInfoNode, ProblemDescNode, SubmissionNode
 11 | from .constants import PROBLEMS, HEADERS, GRAPHQL, CODE_FORMAT
 12 | 
 13 | 
 14 | class Problems:
 15 |     '''核心逻辑'''
 16 | 
 17 |     def __init__(self):
 18 |         self.login = Login(config.username, config.password)
 19 |         self.__db_dir = os.path.abspath(os.path.join(__file__, "../..", "db"))
 20 |         if not os.path.exists(self.__db_dir):
 21 |             os.makedirs(self.__db_dir)
 22 |         self.db_path = os.path.join(self.__db_dir, "leetcode.db")
 23 |         self.__cookies = self.login.cookies
 24 |         self.problems_json = self.__getProblemsJson()
 25 | 
 26 |     def __getProblemsJson(self):
 27 |         resp = requests.get(PROBLEMS, headers=HEADERS, cookies=self.__cookies)
 28 |         if resp.status_code == 200:
 29 |             return resp.json()
 30 | 
 31 |     @property
 32 |     def info(self):
 33 |         '''获取用户基本信息'''
 34 |         return InfoNode(self.problems_json)
 35 | 
 36 |     def __dict_factory(self, cursor, row):
 37 |         '''修改 SQLite 数据呈现方式'''
 38 |         d = {}
 39 |         for idx, col in enumerate(cursor.description):
 40 |             d[col[0]] = row[idx]
 41 |         return d
 42 | 
 43 |     def updateProblemsInfo(self):
 44 |         '''更新问题基本信息'''
 45 |         problems_list = self.problems_json.get('stat_status_pairs')
 46 |         conn = sqlite3.connect(self.db_path)
 47 |         c = conn.cursor()
 48 |         c.execute('''
 49 |             CREATE TABLE IF NOT EXISTS problem (
 50 |                 id INTEGER,
 51 |                 frontend_id TEXT,
 52 |                 title_en TEXT,
 53 |                 title_slug TEXT,
 54 |                 difficulty INTEGER,
 55 |                 paid_only INTEGER,
 56 |                 is_favor INTEGER,
 57 |                 status TEXT,
 58 |                 total_acs INTEGER,
 59 |                 total_submitted INTEGER,
 60 |                 ac_rate TEXT,
 61 |                 PRIMARY KEY(id)
 62 |             )
 63 |             ''')
 64 |         c.execute('DELETE FROM problem')
 65 |         for problem in problems_list:
 66 |             p = ProblemInfoNode(problem)
 67 |             c.execute(
 68 |                 '''
 69 |                 INSERT INTO problem (
 70 |                     id, frontend_id, title_en, title_slug, difficulty, paid_only, is_favor, status, total_acs, total_submitted, ac_rate
 71 |                 )
 72 |                 VALUES (
 73 |                     ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
 74 |                 )
 75 |                 ''', (p.id, p.frontend_id, p.title_en, p.title_slug,
 76 |                       p.difficulty, p.paid_only, p.is_favor, p.status,
 77 |                       p.total_acs, p.total_submitted, p.ac_rate))
 78 |         conn.commit()
 79 |         conn.close()
 80 | 
 81 |     async def __getProblemDesc(self, title_slug):
 82 |         payload = {
 83 |             'query': '''
 84 |             query questionData($titleSlug: String!) {
 85 |                 question(titleSlug: $titleSlug) {
 86 |                     questionId
 87 |                     content
 88 |                     translatedTitle
 89 |                     translatedContent
 90 |                     similarQuestions
 91 |                     topicTags {
 92 |                         name
 93 |                         slug
 94 |                         translatedName
 95 |                     }
 96 |                     hints
 97 |                 }
 98 |             }
 99 |             ''',
100 |             'operationName': 'questionData',
101 |             'variables': {
102 |                 'titleSlug': title_slug
103 |             }
104 |         }
105 |         async with aiohttp.ClientSession(cookies=self.__cookies) as session:
106 |             async with session.post(GRAPHQL, json=payload,
107 |                                     headers=HEADERS) as resp:
108 |                 return await resp.json()
109 | 
110 |     async def storeProblemsDesc(self):
111 |         '''存储 AC 问题描述信息'''
112 |         conn = sqlite3.connect(self.db_path)
113 |         c = conn.cursor()
114 |         c.execute("SELECT title_slug FROM problem WHERE status == 'ac'")
115 |         res = c.fetchall()
116 |         if not res:
117 |             return
118 |         loop = asyncio.get_event_loop()
119 |         problems_list = await handle_tasks(
120 |             loop, self.__getProblemDesc, [dict(title_slug=t[0]) for t in res])
121 |         c.execute('''
122 |             CREATE TABLE IF NOT EXISTS description (
123 |                 id INTEGER,
124 |                 content_en TEXT,
125 |                 title_cn TEXT,
126 |                 content_cn TEXT,
127 |                 similar_questions_cn TEXT,
128 |                 similar_questions_en TEXT,
129 |                 tags_cn TEXT,
130 |                 tags_en TEXT,
131 |                 d_stored INTEGER DEFAULT 0,
132 |                 PRIMARY KEY(id)
133 |             )
134 |             ''')
135 |         for problem in problems_list:
136 |             p = ProblemDescNode(problem)
137 |             c.execute(
138 |                 '''
139 |                 INSERT OR IGNORE INTO description (
140 |                     id, content_en, title_cn, content_cn, similar_questions_cn, similar_questions_en, tags_cn, tags_en
141 |                 )
142 |                 VALUES (
143 |                     ?, ?, ?, ?, ?, ?, ?, ?
144 |                 )
145 |                 ''', (p.id, p.content_en, p.title_cn, p.content_cn,
146 |                       p.similar_questions_cn, p.similar_questions_en,
147 |                       p.tags_cn, p.tags_en))
148 |         conn.commit()
149 |         conn.close()
150 | 
151 |     def updateProblemsDesc(self):
152 |         '''更新处理后的 description 数据库'''
153 |         conn = sqlite3.connect(self.db_path)
154 |         c = conn.cursor()
155 |         c.execute('UPDATE description SET d_stored=1')
156 |         conn.commit()
157 |         conn.close()
158 | 
159 |     async def __getSubmissions(self, title_slug, offset=0, limit=500):
160 |         payload = {
161 |             'query': '''
162 |             query submissions($offset: Int!, $limit: Int!, $lastKey: String, $questionSlug: String!) {
163 |                 submissionList(offset: $offset, limit: $limit, lastKey: $lastKey, questionSlug: $questionSlug) {
164 |                     lastKey
165 |                     hasNext
166 |                     submissions {
167 |                         id
168 |                         statusDisplay
169 |                         lang
170 |                         runtime
171 |                         timestamp
172 |                         url
173 |                         isPending
174 |                         memory
175 |                         __typename
176 |                     }
177 |                 __typename
178 |                 }
179 |             }
180 |             ''',
181 |             'operationName': 'submissions',
182 |             'variables': {
183 |                 'limit': limit,
184 |                 'offset': offset,
185 |                 'questionSlug': title_slug
186 |             }
187 |         }
188 |         async with aiohttp.ClientSession(cookies=self.__cookies) as session:
189 |             async with session.post(GRAPHQL, json=payload,
190 |                                     headers=HEADERS) as resp:
191 |                 return await resp.json(), title_slug
192 | 
193 |     async def __getCode(self, qid, lang):
194 |         url = CODE_FORMAT.format(qid, lang)
195 |         async with aiohttp.ClientSession(cookies=self.__cookies) as session:
196 |             async with session.get(url, headers=HEADERS) as resp:
197 |                 return await resp.json(), qid, lang
198 | 
199 |     async def storeSubmissions(self):
200 |         '''存储提交的代码信息'''
201 |         conn = sqlite3.connect(self.db_path)
202 |         c = conn.cursor()
203 |         c.execute("SELECT title_slug FROM problem WHERE status == 'ac'")
204 |         res = c.fetchall()
205 |         if not res:
206 |             return
207 |         loop = asyncio.get_event_loop()
208 |         submissions_list = await handle_tasks(
209 |             loop, self.__getSubmissions, [dict(title_slug=t[0]) for t in res])
210 |         data = []
211 |         for submissions, title_slug in submissions_list:
212 |             dic = set()
213 |             for submission in submissions['data']['submissionList'][
214 |                     'submissions']:
215 |                 status = submission['statusDisplay']
216 |                 key = submission['lang']
217 |                 if status == 'Accepted' and key not in dic:
218 |                     data.append(submission)
219 |                     data[-1]['title_slug'] = title_slug
220 |                     dic.add(key)
221 |         c.execute('''
222 |             CREATE TABLE IF NOT EXISTS submission (
223 |                 submission_id INTEGER,
224 |                 lang TEXT,
225 |                 language TEXT,
226 |                 memory TEXT,
227 |                 runtime TEXT,
228 |                 timestamp TEXT,
229 |                 title_slug TEXT,
230 |                 s_stored INTEGER DEFAULT 0,
231 |                 PRIMARY KEY(submission_id)
232 |             )
233 |             ''')
234 |         for submission in data:
235 |             s = SubmissionNode(submission)
236 |             c.execute(
237 |                 '''
238 |                 INSERT OR IGNORE INTO submission (
239 |                     submission_id, lang, language, memory, runtime, timestamp, title_slug
240 |                 )
241 |                 VALUES (
242 |                     ?, ?, ?, ?, ?, ?, ?
243 |                 )
244 |                 ''', (s.submission_id, s.lang, s.language, s.memory, s.runtime,
245 |                       s.timestamp, s.title_slug))
246 |         conn.commit()
247 |         conn.close()
248 | 
249 |     async def storeCodes(self):
250 |         '''存储提交的代码'''
251 |         conn = sqlite3.connect(self.db_path)
252 |         c = conn.cursor()
253 |         c.execute(
254 |             "SELECT p.id, lang FROM submission s LEFT JOIN problem p ON s.title_slug=p.title_slug"
255 |         )
256 |         res = c.fetchall()
257 |         if not res:
258 |             return
259 |         loop = asyncio.get_event_loop()
260 |         codes_list = await handle_tasks(
261 |             loop, self.__getCode, [dict(qid=t[0], lang=t[1]) for t in res])
262 |         try:
263 |             c.execute("ALTER TABLE submission ADD COLUMN code TEXT")
264 |         except sqlite3.OperationalError:
265 |             pass
266 |         for code, qid, lang in codes_list:
267 |             c.execute(
268 |                 """
269 |                 UPDATE submission SET code = ?
270 |                 WHERE title_slug=(SELECT title_slug
271 |                                 FROM problem
272 |                                 WHERE id=?)
273 |                 AND lang=?""", (code.get("code", ""), qid, lang))
274 |         conn.commit()
275 |         conn.close()
276 | 
277 |     def updateSubmissions(self):
278 |         '''更新处理后的 submission 数据库'''
279 |         conn = sqlite3.connect(self.db_path)
280 |         c = conn.cursor()
281 |         c.execute('UPDATE submission SET s_stored=1')
282 |         conn.commit()
283 |         conn.close()
284 | 
285 |     async def update(self):
286 |         '''增量式更新数据'''
287 |         output_dir = config.outputDir
288 |         if not os.path.exists(output_dir):
289 |             os.makedirs(output_dir)
290 |         extractor = Extractor(output_dir, config.username)
291 |         self.updateProblemsInfo()
292 |         await self.storeProblemsDesc()
293 |         await self.storeSubmissions()
294 |         await self.storeCodes()
295 |         conn = sqlite3.connect(self.db_path)
296 |         conn.row_factory = self.__dict_factory
297 |         c = conn.cursor()
298 |         # 获取新的数据
299 |         c.execute('''
300 |             SELECT *
301 |             FROM description d
302 |             JOIN problem p
303 |             ON p.id=d.id
304 |             JOIN submission s
305 |             ON p.title_slug=s.title_slug
306 |             WHERE (d.d_stored=0 OR s.s_stored=0)
307 |             ORDER BY p.id DESC
308 |             ''')
309 |         datas = c.fetchall()
310 |         if datas:
311 |             extractor.extractDesc(datas)
312 |             self.updateProblemsDesc()
313 |             extractor.extractCode(datas)
314 |             self.updateSubmissions()
315 |             await self.storeCodes()
316 |         c.execute('''
317 |             SELECT *
318 |             FROM description d
319 |             JOIN problem p
320 |             ON p.id=d.id
321 |             JOIN submission s
322 |             ON p.title_slug=s.title_slug
323 |             ORDER BY p.id DESC
324 |             ''')
325 |         datas = c.fetchall()
326 |         extractor.extractInfo(self.info, datas)
327 |         print('数据已更新！')
328 |         conn.close()
329 | 
330 |     def clearDB(self):
331 |         '''重建数据'''
332 |         conn = sqlite3.connect(self.db_path)
333 |         c = conn.cursor()
334 |         c.execute('''
335 |             SELECT name
336 |             FROM sqlite_master
337 |             WHERE type="table" AND name="problem"
338 |             ''')
339 |         if c.fetchone():
340 |             # 删除 problem 表
341 |             c.execute('DROP TABLE problem')
342 |         c.execute('''
343 |             SELECT name
344 |             FROM sqlite_master
345 |             WHERE type="table" AND name="description"
346 |             ''')
347 |         if c.fetchone():
348 |             # 删除 description 表
349 |             c.execute('DROP TABLE description')
350 |         c.execute('''
351 |             SELECT name
352 |             FROM sqlite_master
353 |             WHERE type="table" AND name="submission"
354 |             ''')
355 |         if c.fetchone():
356 |             # 删除 submission 表
357 |             c.execute('DROP TABLE submission')
358 |         conn.commit()
359 |         conn.close()
360 | 


--------------------------------------------------------------------------------
/helper/templates.py:
--------------------------------------------------------------------------------
  1 | # 根目录下的 README 英文模板
  2 | TEMPLATE_README_EN = '''
  3 | ---
  4 | title: "LeetCode_en"
  5 | layout: "leetcode_en"
  6 | url: "/leetcode_en/"
  7 | author: "Herbert Lu"
  8 | ---
  9 | 
 10 | | English | [简体中文](../leetcode) |
 11 | 
 12 | ![leetcode-logo](/images/leetcode-logo.png)
 13 | 
 14 | {{{{< rawhtml >}}}}
 15 | <p align="center">
 16 |     <img src="https://img.shields.io/badge/User-{user_name}-blue.svg?" alt="">
 17 |     <img src="https://img.shields.io/badge/Solved-{num_solved}/{num_total}-blue.svg?" alt="">
 18 |     <img src="https://img.shields.io/badge/Easy-{ac_easy}-green.svg?" alt="">
 19 |     <img src="https://img.shields.io/badge/Medium-{ac_medium}-orange.svg?" alt="">
 20 |     <img src="https://img.shields.io/badge/Hard-{ac_hard}-red.svg?" alt="">
 21 | </p>
 22 | <h1 align="center">My LeetCode Solutions</h1>
 23 | 
 24 | <p align="center">
 25 |     <br>
 26 |     <b>Last updated: {time}</b>
 27 |     <br>
 28 | </p>
 29 | {{{{< /rawhtml >}}}}
 30 | 
 31 | | # | Title | Solutions | Acceptance | Difficulty | Tags |
 32 | |:--:|:-----|:---------:|:----:|:----:|:----|
 33 | '''
 34 | 
 35 | # 根目录下的 README 中文模板
 36 | TEMPLATE_README_CN = '''
 37 | ---
 38 | title: "LeetCode"
 39 | layout: "leetcode"
 40 | url: "/leetcode/"
 41 | menu: "main"
 42 | author: "Herbert Lu"
 43 | ---
 44 | 
 45 | | [English](../leetcode_en) | 简体中文 |
 46 | 
 47 | ![leetcode-logo](/images/leetcode-logo.png)
 48 | {{{{< rawhtml >}}}}
 49 | <p align="center">
 50 |     <img src="https://img.shields.io/badge/用户-{user_name}-blue.svg?" alt="">
 51 |     <img src="https://img.shields.io/badge/已解决-{num_solved}/{num_total}-blue.svg?" alt="">
 52 |     <img src="https://img.shields.io/badge/简单-{ac_easy}-green.svg?" alt="">
 53 |     <img src="https://img.shields.io/badge/中等-{ac_medium}-orange.svg?" alt="">
 54 |     <img src="https://img.shields.io/badge/困难-{ac_hard}-red.svg?" alt="">
 55 | </p>
 56 | <h1 align="center">LeetCode 的解答</h1>
 57 | 
 58 | <p align="center">
 59 |     <br>
 60 |     <b>最近一次更新: {time}</b>
 61 |     <br>
 62 | </p>
 63 | {{{{< /rawhtml >}}}}
 64 | 
 65 | | # | 题名 | 解答 | 通过率 | 难度 | 标签 |
 66 | |:--:|:-----|:---------:|:----:|:----:|:----|
 67 | '''
 68 | 
 69 | # 根目录下 README 中的题目概要信息
 70 | TEMPLATE_README_APPEND = '|{frontend_id}|{title}{paid_only}{is_favor}|{solutions}|{ac_rate}|{difficulty}|{tags}|\n'
 71 | 
 72 | # 题目描述 README 英文模板
 73 | TEMPLATE_DESC_EN = '''
 74 | ---
 75 | title: "{title_en}"
 76 | categories: ["leetcode_en"]
 77 | draft: false
 78 | ---
 79 | 
 80 | | English | [简体中文](../readme) |
 81 | 
 82 | # {title_en}
 83 | 
 84 | ## Description
 85 | 
 86 | {{{{< rawhtml >}}}}
 87 | {content_en}
 88 | {{{{< /rawhtml >}}}}
 89 | 
 90 | ## Related Topics
 91 | 
 92 | {tags_en}
 93 | 
 94 | ## Similar Questions
 95 | 
 96 | {similar_questions_en}
 97 | '''
 98 | 
 99 | # 题目描述 README 中文模板
100 | TEMPLATE_DESC_CN = '''
101 | ---
102 | title: "{title_cn}"
103 | categories: ["leetcode_cn"]
104 | draft: false
105 | ---
106 | 
107 | | [English](../readme_en) | 简体中文 |
108 | 
109 | # {title_cn}
110 | 
111 | ## 题目描述
112 | 
113 | {{{{< rawhtml >}}}}
114 | {content_cn}
115 | {{{{< /rawhtml >}}}}
116 | 
117 | ## 相关话题
118 | 
119 | {tags_cn}
120 | 
121 | ## 相似题目
122 | 
123 | {similar_questions_cn}
124 | '''
125 | 
126 | # 题目代码模板
127 | TEMPLATE_CODE = '''
128 | ---
129 | title: "{title_cn} ({title_en})"
130 | draft: false
131 | ---
132 | ```{ext}
133 | {style} @Title: {title_cn} ({title_en})
134 | {style} @Author: {author}
135 | {style} @Date: {timestamp}
136 | {style} @Runtime: {runtime}
137 | {style} @Memory: {memory}
138 | {code}
139 | ```
140 | '''
141 | 


--------------------------------------------------------------------------------
/helper/utils.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | import aiohttp
 3 | import os
 4 | import time
 5 | from functools import partial
 6 | from .config import config
 7 | 
 8 | 
 9 | def mkdir(path):
10 |     if not os.path.exists(path):
11 |         os.makedirs(path)
12 |         print(f'{path} 已创建！')
13 |     else:
14 |         print(f'{path} 已存在！')
15 |     return os.path.abspath(path)
16 | 
17 | 
18 | # 异步 request
19 | async def request(url='', method='get', cookies='', headers='', **kwargs):
20 |     async with aiohttp.ClientSession(cookies=cookies) as session:
21 |         async with session.request(method=method,
22 |                                    url=url,
23 |                                    headers=headers,
24 |                                    **kwargs) as resp:
25 |             return await resp.read()
26 | 
27 | 
28 | # 异步调度函数
29 | async def handle_tasks(loop, func, args):
30 |     if isinstance(args, list):
31 |         tasks = {
32 |             asyncio.ensure_future(func(**arg)): partial(func, **arg)
33 |             for arg in args
34 |         }
35 |         # loop.run_until_complete(asyncio.wait(tasks))
36 |         pending = set(tasks.keys())
37 |         res = []
38 |         while pending:
39 |             finished, pending = await asyncio.wait(
40 |                 pending, return_when=asyncio.FIRST_COMPLETED)
41 |             time.sleep(config.timeInterval)
42 |             for task in finished:
43 |                 if task.exception():
44 |                     coro = tasks[task]
45 |                     # print(f"{coro} retry...")
46 |                     new_task = asyncio.ensure_future(coro())
47 |                     tasks[new_task] = coro
48 |                     pending.add(new_task)
49 |                 else:
50 |                     res.append(task.result())
51 |         return res
52 |     elif isinstance(args, str):
53 |         task = asyncio.ensure_future(func(args))
54 |         loop.run_until_complete(task)
55 |         return [task.result()]
56 | 


--------------------------------------------------------------------------------
/imgs/leetcode-logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lryong/hugo-leetcode-dashboard/d3ae5f6a93d05286a4b2294d4ae58a93851c8ccd/imgs/leetcode-logo.png


--------------------------------------------------------------------------------
/imgs/leetcode_dashboard.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lryong/hugo-leetcode-dashboard/d3ae5f6a93d05286a4b2294d4ae58a93851c8ccd/imgs/leetcode_dashboard.png


--------------------------------------------------------------------------------
/run.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | '''
 3 | @Author: KivenChen
 4 | @Date: 2019-04-23
 5 | @LastEditTime: 2019-05-02
 6 | '''
 7 | from helper.main import Main
 8 | 
 9 | if __name__ == "__main__":
10 |     while True:
11 |         print('欢迎使用 LeetCode_Helper, 请选择: ')
12 |         print('1. 更新')
13 |         print('2. 重建')
14 |         print('q. 退出')
15 |         key = input()
16 |         if key == 'q':
17 |             break
18 |         elif key == '1':
19 |             Main().update()
20 |             break
21 |         elif key == '2':
22 |             Main().rebuild()
23 |             break
24 |         else:
25 |             print('请重新选择！')
26 | 


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lryong/hugo-leetcode-dashboard/d3ae5f6a93d05286a4b2294d4ae58a93851c8ccd/tests/__init__.py


--------------------------------------------------------------------------------
/tests/test_config.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | @Author: KivenChen
 3 | @Date: 2019-04-22
 4 | @LastEditTime: 2019-04-30
 5 | '''
 6 | import unittest
 7 | import os
 8 | import sys
 9 | sys.path.append(os.path.abspath(os.path.join(__file__, "../..")))
10 | from helper.config import Config
11 | 
12 | 
13 | class TestConfig(unittest.TestCase):
14 |     def test_init(self):
15 |         pass
16 | 
17 |     def test_getUsername(self):
18 |         config = Config()
19 |         self.assertIsNotNone(config.username)
20 | 
21 |     def test_getPassword(self):
22 |         config = Config()
23 |         self.assertIsNotNone(config.password)
24 | 
25 |     def test_getOutputDir(self):
26 |         config = Config()
27 |         self.assertIsNotNone(config.outputDir)
28 | 
29 | 
30 | if __name__ == "__main__":
31 |     unittest.main()
32 | 


--------------------------------------------------------------------------------
/update_leetcode_dashboard.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | echo "Start render hugo leetcode dashboard"
4 | 
5 | echo "2" | python3 run.py && cp imgs/leetcode-logo.png /Users/XXX/my_blogs/static/images
6 | 
7 | echo "All operations Done! "
8 | 


--------------------------------------------------------------------------------