forked from Nandaka/PixivUtil2
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathPixivBookmarkHandler.py
393 lines (341 loc) · 15.9 KB
/
PixivBookmarkHandler.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
import os
import sys
from datetime import time
import PixivArtistHandler
from PixivBrowserFactory import PixivBrowser
import PixivConstant
import PixivDownloadHandler
import PixivHelper
import PixivImageHandler
from PixivBookmark import PixivBookmark
from PixivGroup import PixivGroup
# from bs4 import BeautifulSoup
def process_bookmark(caller,
config,
hide='n',
start_page=1,
end_page=0,
bookmark_count=-1):
br: PixivBrowser = caller.__br__
try:
total_list = list()
print(f"My Member Id = {br._myId}")
if hide != 'o':
print("Importing Bookmarks...")
total_list.extend(get_bookmarks(caller, config, False, start_page, end_page, br._myId))
if hide != 'n':
print("Importing Private Bookmarks...")
total_list.extend(get_bookmarks(caller, config, True, start_page, end_page, br._myId))
print(f"Result: {str(len(total_list))} items.")
i = 0
current_member = 1
for item in total_list:
print("%d/%d\t%f %%" % (i, len(total_list), 100.0 * i / float(len(total_list))))
i += 1
prefix = "[{0} of {1}]".format(current_member, len(total_list))
PixivArtistHandler.process_member(caller,
config,
item.memberId,
user_dir=item.path,
title_prefix=prefix,
bookmark_count=bookmark_count)
current_member = current_member + 1
if len(total_list) > 0:
print("%d/%d\t%f %%" % (i, len(total_list), 100.0 * i / float(len(total_list))))
else:
print("Cannot find any followed member.")
except KeyboardInterrupt:
raise
except BaseException:
PixivHelper.print_and_log('error', 'Error at process_bookmark(): {0}'.format(sys.exc_info()))
raise
def process_image_bookmark(caller,
config,
hide='n',
start_page=1,
end_page=0,
tag=None,
use_image_tag=False):
try:
print("Importing image bookmarks...")
totalList = list()
private_list = list()
public_list = list()
image_count = 1
total_bookmark_count = 0
if hide == 'n':
(public_list, total_bookmark_count) = get_image_bookmark(caller, config, False, start_page, end_page, tag, use_image_tag)
elif hide == 'y':
# public and private image bookmarks
(public_list, total_bookmark_count_pub) = get_image_bookmark(caller, config, False, start_page, end_page, tag, use_image_tag)
(private_list, total_bookmark_count_priv) = get_image_bookmark(caller, config, True, start_page, end_page, tag, use_image_tag)
total_bookmark_count = total_bookmark_count_pub + total_bookmark_count_priv
else:
(private_list, total_bookmark_count) = get_image_bookmark(caller, config, True, start_page, end_page, tag, use_image_tag)
totalList.extend(private_list)
totalList.extend(public_list)
PixivHelper.print_and_log('info', f"Found {len(totalList)} of {total_bookmark_count} possible image(s) .")
for item in totalList:
print(f"Image # {image_count}")
result = PixivImageHandler.process_image(caller,
config,
artist=None,
image_id=item,
search_tags=tag)
image_count = image_count + 1
PixivHelper.wait(result, config)
print("Done.\n")
except KeyboardInterrupt:
raise
except BaseException:
PixivHelper.print_and_log('error', 'Error at process_image_bookmark(): {0}'.format(sys.exc_info()))
raise
def process_new_illust_from_bookmark(caller,
config,
page_num=1,
end_page_num=0,
bookmark_count=-1):
br: PixivBrowser = caller.__br__
parsed_page = None
try:
print("Processing New Illust from bookmark")
i = page_num
image_count = 1
flag = True
while flag:
print(f"Page #{i}")
mode = "all"
if config.r18mode:
mode = "r18"
pb = br.getFollowedNewIllusts(mode, current_page=i)
# url = 'https://www.pixiv.net/bookmark_new_illust.php?p=' + str(i)
# if config.r18mode:
# url = 'https://www.pixiv.net/bookmark_new_illust_r18.php?p=' + str(i)
# PixivHelper.print_and_log('info', "Source URL: " + url)
# page = br.open(url)
# parsed_page = BeautifulSoup(page.read().decode("utf-8"), features="html5lib")
# pb = PixivNewIllustBookmark(parsed_page)
# if not pb.haveImages:
# print("No images!")
# break
for image_id in pb.imageList:
print(f"Image #{image_count}")
result = PixivImageHandler.process_image(caller,
config,
artist=None,
image_id=int(image_id),
bookmark_count=bookmark_count)
image_count = image_count + 1
if result == PixivConstant.PIXIVUTIL_SKIP_OLDER:
flag = False
break
PixivHelper.wait(result, config)
i = i + 1
# page.close()
# parsed_page.decompose()
# del parsed_page
if (end_page_num != 0 and i > end_page_num) or pb.isLastPage:
print("Limit or last page reached.")
flag = False
print("Done.")
except KeyboardInterrupt:
raise
except BaseException:
PixivHelper.print_and_log('error', 'Error at process_new_illust_from_bookmark(): {0}'.format(sys.exc_info()))
if parsed_page is not None:
filename = "Dump for New Illust from bookmark.html"
PixivHelper.dump_html(filename, parsed_page)
raise
def process_from_group(caller,
config,
group_id,
limit=0,
process_external=True):
br: PixivBrowser = caller.__br__
json_response = None
try:
print("Download by Group Id")
if limit != 0:
print(f"Limit: {limit}")
if process_external:
print(f"Include External Image: {process_external}")
max_id = 0
image_count = 0
flag = True
while flag:
url = f"https://www.pixiv.net/group/images.php?format=json&max_id={max_id}&id={group_id}"
PixivHelper.print_and_log('info', f"Getting images from: {url}")
response = br.open(url)
json_response = response.read()
response.close()
group_data = PixivGroup(json_response)
max_id = group_data.maxId
if group_data.imageList is not None and len(group_data.imageList) > 0:
for image in group_data.imageList:
if image_count > limit and limit != 0:
flag = False
break
print(f"Image #{image_count}")
print(f"ImageId: {image}")
result = PixivImageHandler.process_image(caller,
config,
image_id=image)
image_count = image_count + 1
PixivHelper.wait(result, config)
if process_external and group_data.externalImageList is not None and len(group_data.externalImageList) > 0:
for image_data in group_data.externalImageList:
if image_count > limit and limit != 0:
flag = False
break
print(f"Image #{image_count}")
print(f"Member Id : {image_data.artist.artistId}")
PixivHelper.safePrint(f"Member Name : {image_data.artist.artistName}")
print(f"Member Token : {image_data.artist.artistToken}")
print(f"Image Url : {image_data.imageUrls[0]}")
filename = PixivHelper.make_filename(config.filenameFormat,
imageInfo=image_data,
tagsSeparator=config.tagsSeparator,
tagsLimit=config.tagsLimit,
fileUrl=image_data.imageUrls[0],
useTranslatedTag=config.useTranslatedTag,
tagTranslationLocale=config.tagTranslationLocale)
filename = PixivHelper.sanitize_filename(filename, config.rootDirectory)
PixivHelper.safePrint(f"Filename : {filename}")
(result, filename) = PixivDownloadHandler.download_image(caller,
image_data.imageUrls[0],
filename,
url,
config.overwrite,
config.retry,
backup_old_file=config.backupOldFile)
PixivHelper.get_logger().debug("Download %s result: %s", filename, result)
if config.setLastModified and filename is not None and os.path.isfile(filename):
ts = time.mktime(image_data.worksDateDateTime.timetuple())
os.utime(filename, (ts, ts))
image_count = image_count + 1
if (group_data.imageList is None or len(group_data.imageList) == 0) and \
(group_data.externalImageList is None or len(group_data.externalImageList) == 0):
flag = False
print("")
except BaseException:
PixivHelper.print_and_log('error', 'Error at process_from_group(): {0}'.format(sys.exc_info()))
if json_response is not None:
filename = f"Dump for Download by Group {group_id}.json"
PixivHelper.dump_html(filename, json_response)
raise
def export_bookmark(caller,
config,
filename,
hide='n',
start_page=1,
end_page=0,
member_id=None):
try:
total_list = list()
if hide != 'o':
print("Importing Bookmarks...")
total_list.extend(get_bookmarks(caller, config, False, start_page, end_page, member_id))
if hide != 'n':
print("Importing Private Bookmarks...")
total_list.extend(get_bookmarks(caller, config, True, start_page, end_page, member_id))
print(f"Result: {len(total_list)} items.")
PixivBookmark.exportList(total_list, filename)
except KeyboardInterrupt:
raise
except BaseException:
PixivHelper.print_and_log('error', 'Error at export_bookmark(): {0}'.format(sys.exc_info()))
raise
def get_bookmarks(caller, config, hide, start_page=1, end_page=0, member_id=None):
br: PixivBrowser = caller.__br__
"""Get User's bookmarked artists """
total_list = list()
i = start_page
limit = 48
offset = 0
is_json = False
locale = "&lang=en"
if br._locale is not None and len(br._locale) > 0:
locale = f"&lang={br._locale}"
while True:
if end_page != 0 and i > end_page:
print('Limit reached')
break
PixivHelper.print_and_log('info', f'Exporting page {i}')
if member_id:
is_json = True
offset = limit * (i - 1)
url = f'https://www.pixiv.net/ajax/user/{member_id}/following?offset={offset}&limit={limit}'
else:
# Issue #942
member_id = br._myId
is_json = True
url = f'https://www.pixiv.net/ajax/user/{member_id}/following?offset={offset}&limit={limit}'
if hide:
url = url + "&rest=hide"
else:
url = url + "&rest=show"
url = url + locale
PixivHelper.print_and_log('info', f"Source URL: {url}")
page = br.open_with_retry(url)
page_str = page.read().decode('utf8')
page.close()
bookmarks = PixivBookmark.parseBookmark(page_str,
root_directory=config.rootDirectory,
db_path=config.dbPath,
locale=br._locale,
is_json=is_json)
if len(bookmarks) == 0:
print('No more data')
break
total_list.extend(bookmarks)
i = i + 1
print(str(len(bookmarks)), 'items')
PixivHelper.wait(config=config)
return total_list
def get_image_bookmark(caller, config, hide, start_page=1, end_page=0, tag=None, use_image_tag=False):
"""Get user's image bookmark"""
br: PixivBrowser = caller.__br__
total_list = list()
i = start_page
offset = 0
limit = 48
member_id = br._myId
total_bookmark_count = 0
encoded_tag = ''
while True:
if end_page != 0 and i > end_page:
print(f"Page Limit reached: {end_page}")
break
# https://www.pixiv.net/ajax/user/189816/illusts/bookmarks?tag=&offset=0&limit=48&rest=show
show = "show"
if hide:
show = "hide"
if tag is not None and len(tag) > 0:
encoded_tag = PixivHelper.encode_tags(tag)
offset = limit * (i - 1)
PixivHelper.print_and_log('info', f"Importing user's bookmarked image from page {i}")
url = f"https://www.pixiv.net/ajax/user/{member_id}/illusts/bookmarks?tag={encoded_tag}&offset={offset}&limit={limit}&rest={show}"
if use_image_tag: # don't filter based on user's bookmark tag
url = f"https://www.pixiv.net/ajax/user/{member_id}/illusts/bookmarks?tag=&offset={offset}&limit={limit}&rest={show}"
PixivHelper.print_and_log('info', f"Using image tag: {tag}")
PixivHelper.print_and_log('info', f"Source URL: {url}")
page = br.open(url)
page_str = page.read().decode('utf8')
page.close()
if use_image_tag:
(bookmarks, total_bookmark_count) = PixivBookmark.parseImageBookmark(page_str, image_tags_filter=tag)
else:
(bookmarks, total_bookmark_count) = PixivBookmark.parseImageBookmark(page_str)
total_list.extend(bookmarks)
if len(bookmarks) == 0 and not use_image_tag:
print("No more images.")
break
elif use_image_tag and total_bookmark_count / limit < i:
print("Last page reached.")
break
else:
print(f" found {len(bookmarks)} images.")
i = i + 1
# Issue#569
PixivHelper.wait(config=config)
return (total_list, total_bookmark_count)