Hello, PyTorch (1) | 环境配置

1
# Jupyter Lab 配置
2
# 使用 Pycharm/VSCode/其他 IDE 编辑代码，这部分可以全部注释掉
3
jupyterlab # Jupyter Lab 本体
4
jupyterlab-language-pack-zh-CN # Jupyter Lab 中文语言包
5
jupyterlab-lsp # Jupyter Lab 语言服务器（LSP）支持
6
jedi-language-server # Jedi 语言服务器
7

8
# 其他需要的包
9
ipykernel # 运行 Jupyter Notebook 的核心包，使用 VSCode 时需要
10
scipy # 提供一些实用函数
11
pandas # 数据处理包，可以注释掉
12
matplotlib # 绘图包，如果需要导出数据用其他软件绘图，可以注释掉

1
'use strict';
2

3
const HUB_HOST = 'registry-1.docker.io';
4
const AUTH_URL = 'https://auth.docker.io';
5
const WORKERS_URL = 'https://你的域名';
6
const ASSET_URL = 'https://hunshcn.github.io/gh-proxy/';
7
const PREFIX = '/';
8
const Config = { jsdelivr: 0 };
9
const whiteList = [];
10

11
const exp1 = /^(?:https?:\/\/)?github\.com\/.+?\/.+?\/(?:releases|archive)\/.*$/i;
12
const exp2 = /^(?:https?:\/\/)?github\.com\/.+?\/.+?\/(?:blob|raw)\/.*$/i;
13
const exp3 = /^(?:https?:\/\/)?github\.com\/.+?\/.+?\/(?:info|git-).*$/i;
14
const exp4 = /^(?:https?:\/\/)?raw\.(?:githubusercontent|github)\.com\/.+?\/.+?\/.+?\/.+$/i;
15
const exp5 = /^(?:https?:\/\/)?gist\.(?:githubusercontent|github)\.com\/.+?\/.+?\/.+$/i;
16
const exp6 = /^(?:https?:\/\/)?github\.com\/.+?\/.+?\/tags.*$/i;
17

18
/** @type {RequestInit} */
19
const PREFLIGHT_INIT = {
20
  // @ts-ignore
21
  status: 204,
22
  headers: new Headers({
23
    'access-control-allow-origin': '*',
24
    'access-control-allow-methods': 'GET, POST, PUT, PATCH, TRACE, DELETE, HEAD, OPTIONS',
25
    'access-control-max-age': '1728000',
26
  }),
27
};
28

29
/**
30
 * Create a new response.
31
 * @param {any} body
32
 * @param {number} [status=200]
33
 * @param {Object<string, string>} headers
34
 * @returns {Response}
35
 */
36
function makeResponse(body, status = 200, headers = {}) {
37
  headers['access-control-allow-origin'] = '*';
38
  return new Response(body, { status, headers });
39
}
40

41
/**
42
 * Create a new URL object.
43
 * @param {string} urlStr
44
 * @returns {URL|null}
45
 */
46
function createURL(urlStr) {
47
  try {
48
    return new URL(urlStr);
49
  } catch (err) {
50
    return null;
51
  }
52
}
53

54
addEventListener('fetch', (event) => {
55
  event.respondWith(
56
    handleFetchEvent(event).catch((err) => makeResponse(`cfworker error:\n${err.stack}`, 502))
57
  );
58
});
59

60
/**
61
 * Handle the fetch event.
62
 * @param {FetchEvent} event
63
 * @returns {Promise<Response>}
64
 */
65
async function handleFetchEvent(event) {
66
  const req = event.request;
67
  const url = new URL(req.url);
68

69
  if (url.pathname.startsWith('/token') || url.pathname.startsWith('/v2')) {
70
    return handleDockerProxy(req, url);
71
  }
72

73
  if (url.pathname.startsWith(PREFIX)) {
74
    return handleGitHubProxy(req, url);
75
  }
76

77
  return makeResponse('Not Found', 404);
78
}
79

80
/**
81
 * Handle token requests and Docker proxy.
82
 * @param {Request} req
83
 * @param {URL} url
84
 * @returns {Promise<Response>}
85
 */
86
async function handleDockerProxy(req, url) {
87
  if (url.pathname === '/token') {
88
    const tokenURL = AUTH_URL + url.pathname + url.search;
89
    const headers = new Headers({
90
      Host: 'auth.docker.io',
91
      'User-Agent': req.headers.get('User-Agent'),
92
      Accept: req.headers.get('Accept'),
93
      'Accept-Language': req.headers.get('Accept-Language'),
94
      'Accept-Encoding': req.headers.get('Accept-Encoding'),
95
      Connection: 'keep-alive',
96
      'Cache-Control': 'max-age=0',
97
    });
98
    return fetch(new Request(tokenURL, req), { headers });
99
  }
100

101
  url.hostname = HUB_HOST;
102
  const headers = new Headers({
103
    Host: HUB_HOST,
104
    'User-Agent': req.headers.get('User-Agent'),
105
    Accept: req.headers.get('Accept'),
106
    'Accept-Language': req.headers.get('Accept-Language'),
107
    'Accept-Encoding': req.headers.get('Accept-Encoding'),
108
    Connection: 'keep-alive',
109
    'Cache-Control': 'max-age=0',
110
  });
111

112
  if (req.headers.has('Authorization')) {
113
    headers.set('Authorization', req.headers.get('Authorization'));
114
  }
115

116
  const response = await fetch(new Request(url, req), { headers });
117
  const responseHeaders = new Headers(response.headers);
118
  const status = response.status;
119

120
  if (responseHeaders.get('Www-Authenticate')) {
121
    const authHeader = responseHeaders.get('Www-Authenticate');
122
    const re = new RegExp(AUTH_URL, 'g');
123
    responseHeaders.set('Www-Authenticate', authHeader.replace(re, WORKERS_URL));
124
  }
125

126
  if (responseHeaders.get('Location')) {
127
    return handleHttpRedirect(req, responseHeaders.get('Location'));
128
  }
129

130
  responseHeaders.set('access-control-expose-headers', '*');
131
  responseHeaders.set('access-control-allow-origin', '*');
132
  responseHeaders.set('Cache-Control', 'max-age=1500');
133
  responseHeaders.delete('Content-Security-Policy');
134
  responseHeaders.delete('Content-Security-Policy-Report-Only');
135
  responseHeaders.delete('Clear-Site-Data');
136

137
  return new Response(response.body, { status, headers: responseHeaders });
138
}
139

140
/**
141
 * Handle GitHub proxy requests.
142
 * @param {Request} req
143
 * @param {URL} url
144
 * @returns {Promise<Response>}
145
 */
146
async function handleGitHubProxy(req, url) {
147
  let path = url.searchParams.get('q');
148
  if (path) {
149
    return Response.redirect('https://' + url.host + PREFIX + path, 301);
150
  }
151
  path = url.href.substr(url.origin.length + PREFIX.length).replace(/^https?:\/+/, 'https://');
152
  if (checkUrl(path)) {
153
    return httpHandler(req, path);
154
  } else if (path.search(exp2) === 0) {
155
    if (Config.jsdelivr) {
156
      const newUrl = path
157
        .replace('/blob/', '@')
158
        .replace(/^(?:https?:\/\/)?github\.com/, 'https://cdn.jsdelivr.net/gh');
159
      return Response.redirect(newUrl, 302);
160
    } else {
161
      path = path.replace('/blob/', '/raw/');
162
      return httpHandler(req, path);
163
    }
164
  } else if (path.search(exp4) === 0) {
165
    const newUrl = path
166
      .replace(/(?<=com\/.+?\/.+?)\/(.+?\/)/, '@$1')
167
      .replace(
168
        /^(?:https?:\/\/)?raw\.(?:githubusercontent|github)\.com/,
169
        'https://cdn.jsdelivr.net/gh'
170
      );
171
    return Response.redirect(newUrl, 302);
172
  } else {
173
    return fetch(ASSET_URL + path);
174
  }
175
}
176

177
/**
178
 * Check if the URL matches GitHub patterns.
179
 * @param {string} url
180
 * @returns {boolean}
181
 */
182
function checkUrl(url) {
183
  return [exp1, exp2, exp3, exp4, exp5, exp6].some((exp) => url.search(exp) === 0);
184
}
185

186
/**
187
 * Handle HTTP redirects.
188
 * @param {Request} req
189
 * @param {string} location
190
 * @returns {Promise<Response>}
191
 */
192
async function handleHttpRedirect(req, location) {
193
  const url = createURL(location);
194
  if (!url) {
195
    return makeResponse('Invalid URL', 400);
196
  }
197
  return proxyRequest(url, req);
198
}
199

200
/**
201
 * Handle HTTP requests.
202
 * @param {Request} req
203
 * @param {string} pathname
204
 * @returns {Promise<Response>}
205
 */
206
async function httpHandler(req, pathname) {
207
  if (req.method === 'OPTIONS' && req.headers.has('access-control-request-headers')) {
208
    return new Response(null, PREFLIGHT_INIT);
209
  }
210

211
  const headers = new Headers(req.headers);
212
  let flag = !whiteList.length;
213
  for (const i of whiteList) {
214
    if (pathname.includes(i)) {
215
      flag = true;
216
      break;
217
    }
218
  }
219
  if (!flag) {
220
    return new Response('blocked', { status: 403 });
221
  }
222

223
  if (pathname.search(/^https?:\/\//) !== 0) {
224
    pathname = 'https://' + pathname;
225
  }
226

227
  const url = createURL(pathname);
228
  return proxyRequest(url, { method: req.method, headers, body: req.body });
229
}
230

231
/**
232
 * Proxy a request.
233
 * @param {URL} url
234
 * @param {RequestInit} reqInit
235
 * @returns {Promise<Response>}
236
 */
237
async function proxyRequest(url, reqInit) {
238
  const response = await fetch(url.href, reqInit);
239
  const responseHeaders = new Headers(response.headers);
240

241
  if (responseHeaders.has('location')) {
242
    const location = responseHeaders.get('location');
243
    if (checkUrl(location)) {
244
      responseHeaders.set('location', PREFIX + location);
245
    } else {
246
      reqInit.redirect = 'follow';
247
      return proxyRequest(createURL(location), reqInit);
248
    }
249
  }
250

251
  responseHeaders.set('access-control-expose-headers', '*');
252
  responseHeaders.set('access-control-allow-origin', '*');
253
  responseHeaders.delete('content-security-policy');
254
  responseHeaders.delete('content-security-policy-report-only');
255
  responseHeaders.delete('clear-site-data');
256

257
  return new Response(response.body, {
258
    status: response.status,
259
    headers: responseHeaders,
260
  });
261
}