]> code.communitydata.science - articlequality_ordinal.git/blob - wikiq
add the rest of the code.
[articlequality_ordinal.git] / wikiq
1 #!/usr/bin/env python3
2
3 # original wikiq headers are: title articleid revid date_time anon
4 # editor editor_id minor text_size text_entropy text_md5 reversion
5 # additions_size deletions_size
6
7 import argparse
8 import sys
9 import os, os.path
10 import re
11
12 from subprocess import Popen, PIPE
13 from collections import deque
14 from hashlib import sha1
15
16 from mwxml import Dump
17
18 from deltas.tokenizers import wikitext_split
19 import mwpersistence
20 import mwreverts
21 from urllib.parse import quote
22 TO_ENCODE = ('title', 'editor')
23 PERSISTENCE_RADIUS=7
24 from deltas import SequenceMatcher
25 from deltas import SegmentMatcher
26
27 class PersistMethod:
28     none = 0
29     sequence = 1
30     segment = 2
31     legacy = 3
32
33 def calculate_persistence(tokens_added):
34     return(sum([(len(x.revisions)-1) for x in tokens_added]),
35            len(tokens_added))
36
37
38 class WikiqIterator():
39     def __init__(self, fh, collapse_user=False):
40         self.fh = fh
41         self.collapse_user = collapse_user
42         self.mwiterator = Dump.from_file(self.fh)
43         self.namespace_map = { ns.id : ns.name for ns in
44                                self.mwiterator.site_info.namespaces }
45         self.__pages = self.load_pages()
46
47     def load_pages(self):
48         for page in self.mwiterator:
49             yield WikiqPage(page,
50                             namespace_map = self.namespace_map,
51                             collapse_user=self.collapse_user)
52
53     def __iter__(self):
54         return self.__pages
55
56     def __next__(self):
57         return next(self._pages)
58
59 class WikiqPage():
60     __slots__ = ('id', 'title', 'namespace', 'redirect',
61                  'restrictions', 'mwpage', '__revisions',
62                  'collapse_user')
63     
64     def __init__(self, page, namespace_map, collapse_user=False):
65         self.id = page.id
66         self.namespace = page.namespace
67         # following mwxml, we assume namespace 0 in cases where
68         # page.namespace is inconsistent with namespace_map
69         if page.namespace not in namespace_map:
70             self.title = page.title
71             page.namespace = 0
72         if page.namespace != 0:
73             self.title = ':'.join([namespace_map[page.namespace], page.title])
74         else:
75             self.title = page.title
76         self.restrictions = page.restrictions
77         self.collapse_user = collapse_user
78         self.mwpage = page
79         self.__revisions = self.rev_list()
80
81     def rev_list(self):
82         # Outline for how we want to handle collapse_user=True
83         # iteration   rev.user   prev_rev.user   add prev_rev?
84         #         0          A            None           Never
85         #         1          A               A           False
86         #         2          B               A            True
87         #         3          A               B            True
88         #         4          A               A           False
89         # Post-loop                          A          Always
90         for i, rev in enumerate(self.mwpage):
91             # never yield the first time
92             if i == 0:
93                 if self.collapse_user: 
94                     collapsed_revs = 1
95                     rev.collapsed_revs = collapsed_revs
96
97             else:
98                 if self.collapse_user:
99                     # yield if this is the last edit in a seq by a user and reset
100                     # also yield if we do know who the user is
101
102                     if rev.deleted.user or prev_rev.deleted.user:
103                         yield prev_rev
104                         collapsed_revs = 1
105                         rev.collapsed_revs = collapsed_revs
106
107                     elif not rev.user.text == prev_rev.user.text:
108                         yield prev_rev
109                         collapsed_revs = 1
110                         rev.collapsed_revs = collapsed_revs
111                     # otherwise, add one to the counter
112                     else:
113                         collapsed_revs += 1
114                         rev.collapsed_revs = collapsed_revs
115                 # if collapse_user is false, we always yield
116                 else:
117                     yield prev_rev
118
119             prev_rev = rev
120
121         # also yield the final time
122         yield prev_rev
123
124     def __iter__(self):
125         return self.__revisions
126
127     def __next__(self):
128         return next(self.__revisions)
129
130
131 class RegexPair(object):
132     def __init__(self, pattern, label):
133         self.pattern = re.compile(pattern)
134         self.label = label
135         self.has_groups = bool(self.pattern.groupindex)
136         if self.has_groups:
137             self.capture_groups = list(self.pattern.groupindex.keys())
138             
139     def _make_key(self, cap_group):
140         return ("{}_{}".format(self.label, cap_group))
141
142     def matchmake(self, content, rev_data):
143         
144         temp_dict = {}
145         # if there are named capture groups in the regex
146         if self.has_groups:
147
148             # if there are matches of some sort in this revision content, fill the lists for each cap_group
149             if self.pattern.search(content) is not None:
150                 m = self.pattern.finditer(content)
151                 matchobjects = list(m)
152
153                 for cap_group in self.capture_groups:
154                     key = self._make_key(cap_group)
155                     temp_list = []
156                     for match in matchobjects:
157                         # we only want to add the match for the capture group if the match is not None
158                         if match.group(cap_group) != None:
159                             temp_list.append(match.group(cap_group))
160
161                     # if temp_list of matches is empty just make that column None
162                     if len(temp_list)==0:
163                         temp_dict[key] = None
164                     # else we put in the list we made in the for-loop above
165                     else:
166                         temp_dict[key] = ', '.join(temp_list)
167
168             # there are no matches at all in this revision content, we default values to None
169             else:
170                 for cap_group in self.capture_groups:
171                     key = self._make_key(cap_group)
172                     temp_dict[key] = None
173
174         # there are no capture groups, we just search for all the matches of the regex
175         else:
176             #given that there are matches to be made
177             if self.pattern.search(content) is not None:
178                 m = self.pattern.findall(content)
179                 temp_dict[self.label] = ', '.join(m)
180             else:
181                 temp_dict[self.label] = None    
182         # update rev_data with our new columns
183         rev_data.update(temp_dict)
184         return rev_data
185
186         
187 class WikiqParser():
188     def __init__(self, input_file, output_file, regex_match_revision, regex_match_comment, regex_revision_label, regex_comment_label, collapse_user=False, persist=None, urlencode=False, namespaces = None, revert_radius=15):
189         """ 
190         Parameters:
191            persist : what persistence method to use. Takes a PersistMethod value
192         """
193         self.input_file = input_file
194         self.output_file = output_file
195         self.collapse_user = collapse_user
196         self.persist = persist
197         self.printed_header = False
198         self.namespaces = []
199         self.urlencode = urlencode
200         self.revert_radius = revert_radius
201
202         if namespaces is not None:
203             self.namespace_filter = set(namespaces)
204         else:
205             self.namespace_filter = None
206
207         self.regex_revision_pairs = self.make_matchmake_pairs(regex_match_revision, regex_revision_label)
208         self.regex_comment_pairs = self.make_matchmake_pairs(regex_match_comment, regex_comment_label)
209         
210
211     def make_matchmake_pairs(self, patterns, labels):
212         if (patterns is not None and labels is not None) and \
213            (len(patterns) == len(labels)):
214             return [RegexPair(pattern, label) for pattern, label in zip(patterns, labels)]
215         elif (patterns is None and labels is None):
216             return []
217         else:
218             sys.exit('Each regular expression *must* come with a corresponding label and vice versa.')
219
220     def matchmake(self, rev, rev_data):
221         rev_data = self.matchmake_revision(rev.text, rev_data)
222         rev_data = self.matchmake_comment(rev.comment, rev_data)
223         return rev_data
224
225     def matchmake_revision(self, text, rev_data):
226         return self.matchmake_pairs(text, rev_data, self.regex_revision_pairs)
227
228     def matchmake_comment(self, comment, rev_data):
229         return self.matchmake_pairs(comment, rev_data, self.regex_comment_pairs)
230
231     def matchmake_pairs(self, text, rev_data, pairs):
232         for pair in pairs:
233             rev_data = pair.matchmake(text, rev_data)
234         return rev_data
235
236     def __get_namespace_from_title(self, title):
237         default_ns = None
238
239         for ns in self.namespaces:
240             # skip if the namespace is not defined
241             if ns == None:
242                 default_ns = self.namespaces[ns]
243                 continue
244
245             if title.startswith(ns + ":"):
246                 return self.namespaces[ns]
247
248         # if we've made it this far with no matches, we return the default namespace
249         return default_ns
250
251
252     def process(self):
253
254         # create a regex that creates the output filename
255         # output_filename = re.sub(r'^.*/(enwiki\-\d+)\-.*p(\d+)p.*$',
256         #                         r'output/wikiq-\1-\2.tsv',
257         #                         input_filename)
258
259         # Construct dump file iterator
260         dump = WikiqIterator(self.input_file, collapse_user=self.collapse_user)
261
262         # extract list of namspaces
263         self.namespaces = {ns.name : ns.id for ns in dump.mwiterator.site_info.namespaces}
264
265         page_count = 0
266         rev_count = 0
267
268
269         # Iterate through pages
270         for page in dump:
271             namespace = page.namespace if page.namespace is not None else self.__get_namespace_from_title(page.title)
272
273             # skip namespaces not in the filter
274             if self.namespace_filter is not None:
275                 if namespace not in self.namespace_filter:
276                     continue
277
278             rev_detector = mwreverts.Detector(radius = self.revert_radius)
279
280             if self.persist != PersistMethod.none:
281                 window = deque(maxlen=PERSISTENCE_RADIUS)
282
283                 if self.persist == PersistMethod.sequence:
284                     state = mwpersistence.DiffState(SequenceMatcher(tokenizer = wikitext_split),
285                                                     revert_radius=PERSISTENCE_RADIUS)
286
287                 elif self.persist == PersistMethod.segment:
288                     state = mwpersistence.DiffState(SegmentMatcher(tokenizer = wikitext_split),
289                                                     revert_radius=PERSISTENCE_RADIUS)
290
291                 # self.persist == PersistMethod.legacy
292                 else:
293                     from mw.lib import persistence
294                     state = persistence.State()
295
296             # Iterate through a page's revisions
297             for rev in page:
298                 
299                 # initialize rev_data
300                 rev_data = {
301                     'revid':rev.id,
302                     'date_time' : rev.timestamp.strftime('%Y-%m-%d %H:%M:%S'),
303                     'articleid' : page.id,
304                     'editor_id' : "" if rev.deleted.user == True or rev.user.id is None else rev.user.id,
305                     'title' : '"' + page.title + '"',
306                     'namespace' : namespace,
307                     'deleted' : "TRUE" if rev.deleted.text else "FALSE"
308                 }
309
310                 rev_data = self.matchmake(rev, rev_data)
311
312                 # if revisions are deleted, /many/ things will be missing
313                 if rev.deleted.text:
314                     rev_data['text_chars'] = ""
315                     rev_data['sha1'] = ""
316                     rev_data['revert'] = ""
317                     rev_data['reverteds'] = ""
318
319                 else:
320                     # rev.text can be None if the page has no text
321                     if not rev.text:
322                         rev.text = ""
323                     # if text exists, we'll check for a sha1 and generate one otherwise
324
325                     if rev.sha1:
326                         text_sha1 = rev.sha1
327                     else:
328
329                         text_sha1 = sha1(bytes(rev.text, "utf8")).hexdigest()
330                     
331                     rev_data['sha1'] = text_sha1
332
333                     # TODO rev.bytes doesn't work.. looks like a bug
334                     rev_data['text_chars'] = len(rev.text)
335
336                     # generate revert data
337                     revert = rev_detector.process(text_sha1, rev.id)
338                     
339                     if revert:
340                         rev_data['revert'] = "TRUE"
341                         rev_data['reverteds'] = '"' + ",".join([str(x) for x in revert.reverteds]) + '"'
342                     else:
343                         rev_data['revert'] = "FALSE"
344                         rev_data['reverteds'] = ""
345
346                 # if the fact that the edit was minor can be hidden, this might be an issue
347                 rev_data['minor'] = "TRUE" if rev.minor else "FALSE"
348
349                 if not rev.deleted.user:
350                     # wrap user-defined editors in quotes for fread
351                     rev_data['editor'] = '"' + rev.user.text + '"'
352                     rev_data['anon'] = "TRUE" if rev.user.id == None else "FALSE"
353                     
354                 else:
355                     rev_data['anon'] = ""
356                     rev_data['editor'] = ""
357
358                 #if re.match(r'^#redirect \[\[.*\]\]', rev.text, re.I):
359                 #    redirect = True
360                 #else:
361                 #    redirect = False
362                 
363                 #TODO missing: additions_size deletions_size
364                 
365                 # if collapse user was on, lets run that
366                 if self.collapse_user:
367                     rev_data['collapsed_revs'] = rev.collapsed_revs
368
369                 if self.persist != PersistMethod.none:
370                     if rev.deleted.text:
371                         for k in ["token_revs", "tokens_added", "tokens_removed", "tokens_window"]:
372                             old_rev_data[k] = None
373                     else:
374
375                         if self.persist != PersistMethod.legacy:
376                             _, tokens_added, tokens_removed = state.update(rev.text, rev.id)
377
378                         else:
379                             _, tokens_added, tokens_removed = state.process(rev.text, rev.id, text_sha1)
380                             
381                         window.append((rev.id, rev_data, tokens_added, tokens_removed))
382                         
383                         if len(window) == PERSISTENCE_RADIUS:
384                             old_rev_id, old_rev_data, old_tokens_added, old_tokens_removed = window[0]
385                             
386                             num_token_revs, num_tokens = calculate_persistence(old_tokens_added)
387
388                             old_rev_data["token_revs"] = num_token_revs
389                             old_rev_data["tokens_added"] = num_tokens
390                             old_rev_data["tokens_removed"] = len(old_tokens_removed)
391                             old_rev_data["tokens_window"] = PERSISTENCE_RADIUS-1
392
393                             self.print_rev_data(old_rev_data)
394
395                 else:
396                     self.print_rev_data(rev_data)
397
398                 rev_count += 1
399
400             if self.persist != PersistMethod.none:
401                 # print out metadata for the last RADIUS revisions
402                 for i, item in enumerate(window):
403                     # if the window was full, we've already printed item 0
404                     if len(window) == PERSISTENCE_RADIUS and i == 0:
405                         continue
406
407                     rev_id, rev_data, tokens_added, tokens_removed = item
408                     num_token_revs, num_tokens = calculate_persistence(tokens_added)
409
410                     rev_data["token_revs"] = num_token_revs
411                     rev_data["tokens_added"] = num_tokens
412                     rev_data["tokens_removed"] = len(tokens_removed)
413                     rev_data["tokens_window"] = len(window)-(i+1)
414                     
415                     self.print_rev_data(rev_data)
416
417             page_count += 1
418
419         print("Done: %s revisions and %s pages." % (rev_count, page_count),
420               file=sys.stderr)
421
422     def print_rev_data(self, rev_data):
423         # if it's the first time through, print the header
424         if self.urlencode:
425             for field in TO_ENCODE:
426                 rev_data[field] = quote(str(rev_data[field]))
427
428         if not self.printed_header:
429             print("\t".join([str(k) for k in sorted(rev_data.keys())]), file=self.output_file)
430             self.printed_header = True
431         
432         print("\t".join([str(v) for k, v in sorted(rev_data.items())]), file=self.output_file)
433
434
435 def open_input_file(input_filename):
436     if re.match(r'.*\.7z$', input_filename):
437         cmd = ["7za", "x", "-so", input_filename, '*'] 
438     elif re.match(r'.*\.gz$', input_filename):
439         cmd = ["zcat", input_filename] 
440     elif re.match(r'.*\.bz2$', input_filename):
441         cmd = ["bzcat", "-dk", input_filename] 
442
443     try:
444         input_file = Popen(cmd, stdout=PIPE).stdout
445     except NameError:
446         input_file = open(input_filename, 'r')
447
448     return input_file
449
450 def open_output_file(input_filename):
451     # create a regex that creates the output filename
452     output_filename = re.sub(r'\.(7z|gz|bz2)?$', '', input_filename)
453     output_filename = re.sub(r'\.xml', '', output_filename)
454     output_filename = output_filename + ".tsv"
455     output_file = open(output_filename, "w")
456
457     return output_file
458
459 parser = argparse.ArgumentParser(description='Parse MediaWiki XML database dumps into tab delimitted data.')
460
461 # arguments for the input direction
462 parser.add_argument('dumpfiles', metavar="DUMPFILE", nargs="*", type=str, 
463                     help="Filename of the compressed or uncompressed XML database dump. If absent, we'll look for content on stdin and output on stdout.")
464
465 parser.add_argument('-o', '--output-dir', metavar='DIR', dest='output_dir', type=str, nargs=1,
466                     help="Directory for output files.")
467
468 parser.add_argument('-s', '--stdout', dest="stdout", action="store_true",
469                     help="Write output to standard out (do not create dump file)")
470
471 parser.add_argument('--collapse-user', dest="collapse_user", action="store_true",
472                     help="Operate only on the final revision made by user a user within all sequences of consecutive edits made by a user. This can be useful for addressing issues with text persistence measures.")
473
474 parser.add_argument('-p', '--persistence', dest="persist", default=None, const='', type=str, choices = ['','segment','sequence','legacy'], nargs='?',
475                     help="Compute and report measures of content persistent: (1) persistent token revisions, (2) tokens added, and (3) number of revision used in computing the first measure. This may by slow.  The defualt is -p=sequence, which uses the same algorithm as in the past, but with improvements to wikitext parsing. Use -p=legacy for old behavior used in older research projects. Use -p=segment for advanced persistence calculation method that is robust to content moves, but prone to bugs, and slower.")
476
477 parser.add_argument('-u', '--url-encode', dest="urlencode", action="store_true",
478                     help="Output url encoded text strings. This works around some data issues like newlines in editor names. In the future it may be used to output other text data.")
479
480 parser.add_argument('-n', '--namespace-include', dest="namespace_filter", type=int, action='append',
481                     help="Id number of namspace to include. Can be specified more than once.")
482
483 parser.add_argument('-rr',
484                     '--revert-radius',
485                     dest="revert_radius",
486                     type=int,
487                     action='store',
488                     default=15,
489                     help="Number of edits to check when looking for reverts (default: 15)")
490
491 parser.add_argument('-RP', '--revision-pattern', dest="regex_match_revision", default=None, type=str, action='append',
492                     help="The regular expression to search for in revision text. The regex must be surrounded by quotes.")
493
494 parser.add_argument('-RPl', '--revision-pattern-label', dest="regex_revision_label", default=None, type=str, action='append',
495                     help="The label for the outputted column based on matching the regex in revision text.")
496
497 parser.add_argument('-CP', '--comment-pattern', dest="regex_match_comment", default=None, type=str, action='append',
498                     help="The regular expression to search for in comments of revisions.")
499
500 parser.add_argument('-CPl', '--comment-pattern-label', dest="regex_comment_label", default=None, type=str, action='append',
501                     help="The label for the outputted column based on matching the regex in comments.")
502
503 args = parser.parse_args()
504
505 # set persistence method
506
507 if args.persist is None:
508     persist = PersistMethod.none
509 elif args.persist == "segment":
510     persist = PersistMethod.segment
511 elif args.persist == "legacy":
512     persist = PersistMethod.legacy
513 else:
514     persist = PersistMethod.sequence
515
516 if args.namespace_filter is not None:
517     namespaces = args.namespace_filter
518 else:
519     namespaces = None
520
521 if len(args.dumpfiles) > 0:
522     for filename in args.dumpfiles:
523         input_file = open_input_file(filename)
524
525         # open directory for output
526         if args.output_dir:
527             output_dir = args.output_dir[0]
528         else:
529             output_dir = "."
530
531         print("Processing file: %s" % filename, file=sys.stderr)
532
533         if args.stdout:
534             output_file = sys.stdout
535         else:
536             filename = os.path.join(output_dir, os.path.basename(filename))
537             output_file = open_output_file(filename)
538
539         wikiq = WikiqParser(input_file,
540                             output_file,
541                             collapse_user=args.collapse_user,
542                             persist=persist,
543                             urlencode=args.urlencode,
544                             namespaces=namespaces,
545                             revert_radius=args.revert_radius,
546                             regex_match_revision = args.regex_match_revision,
547                             regex_revision_label = args.regex_revision_label,
548                             regex_match_comment = args.regex_match_comment,
549                             regex_comment_label = args.regex_comment_label)
550
551         wikiq.process()
552
553         # close things 
554         input_file.close()
555         output_file.close()
556 else:
557     wikiq = WikiqParser(sys.stdin,
558                         sys.stdout,
559                         collapse_user=args.collapse_user,
560                         persist=persist,
561                         #persist_legacy=args.persist_legacy,
562                         urlencode=args.urlencode,
563                         namespaces=namespaces,
564                         revert_radius=args.revert_radius,
565                         regex_match_revision = args.regex_match_revision,
566                         regex_revision_label = args.regex_revision_label,
567                         regex_match_comment = args.regex_match_comment,
568                         regex_comment_label = args.regex_comment_label)
569
570     wikiq.process() 
571
572 # stop_words = "a,able,about,across,after,all,almost,also,am,among,an,and,any,are,as,at,be,because,been,but,by,can,cannot,could,dear,did,do,does,either,else,ever,every,for,from,get,got,had,has,have,he,her,hers,him,his,how,however,i,if,in,into,is,it,its,just,least,let,like,likely,may,me,might,most,must,my,neither,no,nor,not,of,off,often,on,only,or,other,our,own,rather,said,say,says,she,should,since,so,some,than,that,the,their,them,then,there,these,they,this,tis,to,too,twas,us,wants,was,we,were,what,when,where,which,while,who,whom,why,will,with,would,yet,you,your"
573 # stop_words = stop_words.split(",")

Community Data Science Collective || Want to submit a patch?