-
Notifications
You must be signed in to change notification settings - Fork 25
/
Copy pathwhatsnew-t.py
executable file
·106 lines (95 loc) · 3.65 KB
/
whatsnew-t.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
#!/usr/bin/env python3
# Copyright © 2012-13 Qtrac Ltd. All rights reserved.
# This program or module is free software: you can redistribute it
# and/or modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version. It is provided for
# educational purposes and is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
import sys
if sys.version_info < (3, 2):
print("requires Python 3.2+ for concurrent.futures")
sys.exit(1)
import argparse
import concurrent.futures
import multiprocessing
import os
import tempfile
import webbrowser
import Feed
import Qtrac
def main():
limit, concurrency = handle_commandline()
Qtrac.report("starting...")
filename = os.path.join(os.path.dirname(__file__), "whatsnew.dat")
futures = set()
with concurrent.futures.ThreadPoolExecutor(
max_workers=concurrency) as executor:
for feed in Feed.iter(filename):
future = executor.submit(Feed.read, feed, limit)
futures.add(future)
done, filename, canceled = process(futures)
if canceled:
executor.shutdown()
Qtrac.report("read {}/{} feeds using {} threads{}".format(done,
len(futures), concurrency, " [canceled]" if canceled else ""))
print()
if not canceled:
webbrowser.open(filename)
def handle_commandline():
parser = argparse.ArgumentParser()
parser.add_argument("-l", "--limit", type=int, default=0,
help="the maximum items per feed [default: unlimited]")
parser.add_argument("-c", "--concurrency", type=int,
default=multiprocessing.cpu_count() * 4,
help="specify the concurrency (for debugging and "
"timing) [default: %(default)d]")
args = parser.parse_args()
return args.limit, args.concurrency
def process(futures):
canceled = False
done = 0
filename = os.path.join(tempfile.gettempdir(), "whatsnew.html")
with open(filename, "wt", encoding="utf-8") as file:
file.write("<!doctype html>\n")
file.write("<html><head><title>What's New</title></head>\n")
file.write("<body><h1>What's New</h1>\n")
canceled, results = wait_for(futures)
if not canceled:
for result in (result for ok, result in results if ok and
result is not None):
done += 1
for item in result:
file.write(item)
else:
done = sum(1 for ok, result in results if ok and result is not
None)
file.write("</body></html>\n")
return done, filename, canceled
# Could have yielded each result but that doesn't play nicely with
# KeyboardInterrupt.
def wait_for(futures):
canceled = False
results = []
try:
for future in concurrent.futures.as_completed(futures):
err = future.exception()
if err is None:
ok, result = future.result()
if not ok:
Qtrac.report(result, True)
elif result is not None:
Qtrac.report("read {}".format(result[0][4:-6]))
results.append((ok, result))
else:
raise err # Unanticipated
except KeyboardInterrupt:
Qtrac.report("canceling...")
canceled = True
for future in futures:
future.cancel()
return canceled, results
if __name__ == "__main__":
main()