monitor pages from dsaez's wikidata crawler

diff --git a/wikipedia/scripts/fetch_daily_views.py b/wikipedia/scripts/fetch_daily_views.py
old mode 100755 (executable)
new mode 100644 (file)
index 9f147e0..8f56e83
--- a/wikipedia/scripts/fetch_daily_views.py
+++ b/wikipedia/scripts/fetch_daily_views.py
@@ -1,110 +1,85 @@
 #!/usr/bin/env python3
 #!/usr/bin/env python3

-
-###############################################################################
-#
-# This script assumes the presence of the COVID-19 repo.
-# 
-# It (1) reads in the article list and then (2) calls the Wikimedia API to 
-# fetch view information for each article. Output is to (3) JSON and TSV.
-#
-###############################################################################
-
-import sys
-import requests

 import argparse
 import argparse

-import json
-import time
-import os.path
-import datetime
+import sqlite3
+import requests
+from datetime import datetime, timedelta

 import logging
 import logging

-from csv import DictWriter

 import digobs
 import digobs

-#import feather #TBD
+from os import path, mkdir
+from functools import partial
+from itertools import chain

 
 

-def parse_args():
-    parser = argparse.ArgumentParser(description='Call the views API to collect Wikipedia view data.')
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(description="Get a list of pages related to COVID19, pandemic, and SARS-COV2 virus related entities.")

     parser.add_argument('-o', '--output_folder', help='Where to save output', default="wikipedia/data", type=str)
     parser.add_argument('-o', '--output_folder', help='Where to save output', default="wikipedia/data", type=str)

-    parser.add_argument('-i', '--article_file', help='File listing article names', default="wikipedia/resources/enwp_wikiproject_covid19_articles.txt", type=str)
-    parser.add_argument('-d', '--query_date', help='Date if not yesterday, in YYYYMMDD format.', type=str)
-    parser.add_argument('-L', '--logging_level', help='Logging level. Options are debug, info, warning, error, critical. Default: info.', default='info', type=digobs.get_loglevel), 
-    parser.add_argument('-W', '--logging_destination', help='Logging destination file. (default: standard error)', type=str), 
-    args = parser.parse_args()
-    return(args)
+    parser.add_argument('-L', '--logging_level', help='Logging level. Options are debug, info, warning, error, critical. Default: info.', default='info', type=digobs.get_loglevel)
+    parser.add_argument('-W', '--logging_destination', help='Logging destination file. (default: standard error)', type=argparse.FileType('a'))
+    parser.add_argument('-d', '--query_date', help='Date if not yesterday, in YYYYMMDD format.', type=lambda s: datetime.strptime(s, "%Y%m%d"))

 
 

-def main():
+    parser.add_argument('-i', '--input_file', help="Input a file of page names from the English Wikiproject.", type=argparse.FileType('r'), default='./wikipedia/resources/enwp_wikiproject_covid19_articles.txt')

 
 

-    args = parse_args()
+    parser.add_argument('-b', '--input_db', help="Input a path to a sqlite3 database from the real-time-covid-tracker project", type = sqlite3.connect, default='real-time-wiki-covid-tracker/AllWikidataItems.sqlite')

 
 

-    outputPath = args.output_folder
-    articleFile = args.article_file
+    args = parser.parse_args()
+    conn = args.input_db
+    conn.row_factory = sqlite3.Row

 
     #handle -d
     if args.query_date:
 
     #handle -d
     if args.query_date:

-        query_date = args.query_date
+        query_date = args.query_date.strftime("%Y%m%d")

     else:
     else:

-        yesterday = datetime.datetime.today() - datetime.timedelta(days=1)
+        yesterday = datetime.today() - timedelta(days=1)

         query_date = yesterday.strftime("%Y%m%d")
 
         query_date = yesterday.strftime("%Y%m%d")
 

-    #handle -W
-    if args.logging_destination:
-        logging.basicConfig(filename=args.logging_destination, filemode='a', level=args.logging_level)
-    else:
-        logging.basicConfig(level=args.logging_level)
-
-    export_time = str(datetime.datetime.now())
-    export_date = datetime.datetime.today().strftime("%Y%m%d")
+    digobs.init_logging(args)

 
 

-    logging.info(f"Starting run at {export_time}")
-    logging.info(f"Last commit: {digobs.git_hash()}")
+    logging.info(f"Destructively outputting results to {args.output_folder}")

 
     #1 Load up the list of article names
 
     #1 Load up the list of article names

-    j_outfilename = os.path.join(outputPath, f"digobs_covid19-wikipedia-enwiki_dailyviews-{query_date}.json")
-    t_outfilename = os.path.join(outputPath, f"digobs_covid19-wikipedia-enwiki_dailyviews-{query_date}.tsv")

 
 

-    with open(articleFile, 'r') as infile:
-        articleList = list(map(str.strip, infile))
+    logging.info("loading info from database")
+    projects = [row['project'] for row in conn.execute("SELECT DISTINCT project from pagesPerProjectTable;").fetchall()]
+
+    successes = 0
+    failures = 0

 
 

-    success = 0 #for logging how many work/fail
-    failure = 0 
+    for project in projects:
+        project_folder = path.join(args.output_folder, project)
+        if not path.exists(project.folder):
+            mkdir(project_folder)

 
 

-    #3 Save results as a JSON and TSV
-    with open(j_outfilename, 'w') as j_outfile, \
-         open(t_outfilename, 'w') as t_outfile:
+        dump_folder = path.join(projct.folder, export_date)
+        if not path.exists(dump_folder):
+            mkdir(dump_folder)

 
 

-        #2 Repeatedly call the API with that list of names
-        for a in articleList:
-            url= f"https://wikimedia.org/api/rest_v1/metrics/pageviews/per-article/en.wikipedia/all-access/all-agents/{a}/daily/{query_date}00/{query_date}00"
+        logging.info(f"Getting page views for {project}")
+        rows = conn.execute(f"SELECT DISTINCT page from pagesPerProjectTable WHERE project='{project}';").fetchall()
+        pages = (row['page'] for row in rows)

 
 

-            response = requests.get(url)
-            if response.ok:
-                jd = response.json()["items"][0]
-                success = success + 1
-            else:
-                failure = failure + 1
-                logging.warning(f"Failure: {response.status_code} from {url}")
-                continue
+        # special case for english, we have a wikiproject input file
+        if project == "en.wikipedia":
+            pages = chain(pages, map(str.strip,args.input_file))

 
 

-            # start writing the CSV File if it doesn't exist yet
-            try:
-                dw
-            except NameError:
-                dw = DictWriter(t_outfile, sorted(jd.keys()), delimiter='\t')
-                dw.writeheader()
+        call_view_api = partial(digobs.call_view_api, project=project, query_date = query_date)

 
 

-            logging.debug(f"printing data: {jd}")
+        responses = map(call_view_api, pages)
+        
+        j_outfilename = path.join(j_output_folder, f"digobs_covid19_{project}_dailyviews-{query_date}.json")
+        t_outfilename = path.join(t_output_folder, f"digobs_covid19_{project}_dailyviews-{query_date}.tsv")

 
 

-            # write out the line of the json file
-            print(json.dumps(jd), file=j_outfile)
+        with open(j_outfilename, 'w') as j_outfile, \
+             open(t_outfilename, 'w') as t_outfile:

 
 

-            # write out of the csv file
-            dw.writerow(jd)
+            proj_successes, proj_failures = digobs.process_view_responses(responses, j_outfile, t_outfile, logging)
+        logging.info(f"(Processed {proj_successes} successes and {proj_failures} for {project}")
+        successes = proj_successes + successes
+        failures = proj_failures + failures

 
 

+    conn.close()

     # f_Out = outputPath + "dailyviews" + query_date + ".feather"
     # read the json back in and make a feather file? 
     # f_Out = outputPath + "dailyviews" + query_date + ".feather"
     # read the json back in and make a feather file? 

-    logging.debug(f"Run complete at {datetime.datetime.now()}")
-    logging.info(f"Processed {success} successful URLs and {failure} failures.")
-
-
-if __name__ == "__main__":
+    logging.debug(f"Run complete at {datetime.now()}")
+    logging.info(f"Processed {successes} successful URLs and {failures} failures.")

 
 

-    main()
+        

diff --git a/wikipedia/scripts/fetch_revisions.py b/wikipedia/scripts/fetch_revisions.py
old mode 100755 (executable)
new mode 100644 (file)
index 2d25e85..9acaef1
--- a/wikipedia/scripts/fetch_revisions.py
+++ b/wikipedia/scripts/fetch_revisions.py
@@ -11,48 +11,34 @@
 
 import argparse
 import logging
 
 import argparse
 import logging

-import os.path
+from os import path, mkdir

 import json
 import datetime
 import json
 import datetime

-
-from requests import Request
+import sqlite3
+from functools import partial
+from itertools import chain

 from csv import DictWriter
 from csv import DictWriter

-from mw import api

 import digobs
 
 import digobs
 

-
-def parse_args():
+def main():

 
     parser = argparse.ArgumentParser(description='Call the views API to collect Wikipedia revision data.')
     parser.add_argument('-o', '--output_folder', help='Where to save output', default="wikipedia/data", type=str)
 
     parser = argparse.ArgumentParser(description='Call the views API to collect Wikipedia revision data.')
     parser.add_argument('-o', '--output_folder', help='Where to save output', default="wikipedia/data", type=str)

-    parser.add_argument('-i', '--article_file', help='File listing article names', default="wikipedia/resources/enwp_wikiproject_covid19_articles.txt", type=str)
+    parser.add_argument('-i', '--input_file', help="Input a file of page names from the English Wikiproject.", type=argparse.FileType('r'), default='./wikipedia/resources/enwp_wikiproject_covid19_articles.txt')
+    parser.add_argument('-d', '--input_db', help="Input a path to a sqlite3 database from the real-time-covid-tracker project", type = sqlite3.connect, default='real-time-wiki-covid-tracker/AllWikidataItems.sqlite')

     parser.add_argument('-L', '--logging_level', help='Logging level. Options are debug, info, warning, error, critical. Default: info.', default='info', type=digobs.get_loglevel), 
     parser.add_argument('-L', '--logging_level', help='Logging level. Options are debug, info, warning, error, critical. Default: info.', default='info', type=digobs.get_loglevel), 

-    parser.add_argument('-W', '--logging_destination', help='Logging destination file. (default: standard error)', type=str), 
-    args = parser.parse_args()
-    return(args)
-
-def main():
-    args = parse_args()
+    parser.add_argument('-W', '--logging_destination', help='Logging destination file. (default: standard error)', type=argparse.FileType('a'))

 
 

-    output_path = args.output_folder
-    article_filename = args.article_file
+    args = parser.parse_args()

 
 

-    #handle -W
-    if args.logging_destination:
-        logging.basicConfig(filename=args.logging_destination, filemode='a', level=args.logging_level)
-    else:
-        logging.basicConfig(level=args.logging_level)
+    logging = digobs.init_logging(args)

 
 

-    export_time = str(datetime.datetime.now())
-    export_date = datetime.datetime.today().strftime("%Y%m%d")
+    conn = args.input_db
+    conn.row_factory = sqlite3.Row

 
 

-    logging.info(f"Starting run at {export_time}")
-    logging.info(f"Last commit: {digobs.git_hash()}")
+    projects = (row['project'] for row in conn.execute("SELECT DISTINCT project from pagesPerProjectTable;").fetchall())

 
 

-    json_output_filename = os.path.join(output_path, f"digobs_covid19-wikipedia-enwiki_revisions-{export_date}.json")
-    tsv_output_filename =  os.path.join(output_path, f"digobs_covid19-wikipedia-enwiki_revisions-{export_date}.tsv")
-    
-    api_session = api.Session("https://en.wikipedia.org/w/api.php")
+    tsv_fields = ['title', 'pageid', 'namespace']

 
     # list of properties from the API we want to gather (basically all of
     # them supported by mediawik-utilities)
 
     # list of properties from the API we want to gather (basically all of
     # them supported by mediawik-utilities)


@@ -68,81 +54,67 @@ def main():
                  'flags' : 'flags',
                  'comment' : 'comment',
                  'content' : 'content' }
                  'flags' : 'flags',
                  'comment' : 'comment',
                  'content' : 'content' }

+    
+    def get_project_pages(project):
+        return (row['page'] for row in conn.execute(f"SELECT DISTINCT page FROM pagesPerProjectTable WHERE project == '{project}';").fetchall())

 
 

-    exclude_from_tsv = ['tags', 'comment', 'content', 'flags']
-
-    # load the list of articles
-    with open(article_filename, 'r') as infile:
-        article_list= list(map(str.strip, infile))
-
-    def get_revisions_for_page(title):
-        return api_session.revisions.query(properties=rv_props.values(),
-                                           titles={title},
-                                           direction="newer")
+    def get_project_revisions(project):
+        pages = get_project_pages(project)
+        if project=="en.wikipedia":
+            pages = chain(pages, map(str.strip,args.input_file))
+        return digobs.get_pages_revisions(pages, project=project, logging=logging, rv_props=rv_props)

 
 

-    tsv_fields = ['title', 'pageid', 'namespace']

     tsv_fields = tsv_fields + list(rv_props.keys())
 
     tsv_fields = tsv_fields + list(rv_props.keys())
 

+    exclude_from_tsv = ['tags', 'comment', 'content', 'flags']
+

     # drop fields that we identified for exclusion
     tsv_fields = [e for e in tsv_fields if e not in exclude_from_tsv]
 
     # add special export fields
     tsv_fields = tsv_fields + ['anon', 'minor', 'url', 'export_timestamp', 'export_commit']
     # drop fields that we identified for exclusion
     tsv_fields = [e for e in tsv_fields if e not in exclude_from_tsv]
 
     # add special export fields
     tsv_fields = tsv_fields + ['anon', 'minor', 'url', 'export_timestamp', 'export_commit']

+    
+    export_time = str(datetime.datetime.now())
+
+    rev_batch_to_tsv = partial(digobs.rev_batch_to_tsv,
+                         tsv_fields = tsv_fields,
+                         export_info={'export_timestamp':export_time,
+                                      'export_commit':digobs.git_hash(short=True)})    

 
     export_info = { 'git_commit' : digobs.git_hash(),
                     'timestamp' : export_time }
 
 
     export_info = { 'git_commit' : digobs.git_hash(),
                     'timestamp' : export_time }
 

-    with open(json_output_filename, 'w') as json_output, \
-         open(tsv_output_filename, 'w') as tsv_output:
-
-        tsv_writer = DictWriter(tsv_output, fieldnames=tsv_fields, delimiter="\t")
-        tsv_writer.writeheader()
-
-        for article in article_list:
-            logging.info(f"pulling revisions for: {article}")
-            for rev in get_revisions_for_page(article):
-                logging.debug(f"processing raw revision: {rev}")
-
-                # add export metadata
-                rev['exported'] = export_info
-
-                # save the json version of the code
-                print(json.dumps(rev), file=json_output)
-
-                # handle missing data
-                if "sha1" not in rev:
-                    rev["sha1"] = ""
-
-                if "userhidden" in rev:
-                    rev["user"] = ""
-                    rev["userid"] = ""
-
-                # recode anon so it's true or false instead of present/missing
-                if "anon" in rev:
-                    rev["anon"] = True
-                else:
-                    rev["anon"] = False
-                    
-                # let's recode "minor" in the same way
-                if "minor" in rev:
-                    rev["minor"] = True
-                else:
-                    rev["minor"] = False
-
-                # add page title information
-                rev['title'] = rev['page']['title']
-                rev['pageid'] = rev['page']['pageid']
-                rev['namespace'] = rev['page']['ns']
-
-                # construct a URL
-                rev['url'] = Request('GET', 'https://en.wikipedia.org/w/index.php',
-                                     params={'title' : rev['title'].replace(" ", "_"),
-                                            'oldid' : rev['revid']}).prepare().url
-
-                rev['export_timestamp'] = export_time
-                rev['export_commit'] = digobs.git_hash(short=True)
-
-                tsv_writer.writerow({k: rev[k] for k in tsv_fields})
+    export_date = datetime.datetime.today().strftime("%Y%m%d")
+
+    rev_batch_to_json = partial(digobs.rev_batch_to_json,
+                                export_info = export_info)
+
+    def write_project_pages(project):
+        project_folder = path.join(args.output_folder, project)
+        if not path.exists(project_folder):
+            mkdir(project_folder)
+
+        dump_folder = path.join(project_folder, export_date)
+        if not path.exists(dump_folder):
+            mkdir(dump_folder)
+
+        project_revs = get_project_revisions(project)
+        
+        json_output_filename = path.join(dump_folder, f"digobs_covid19_{project}_revisions-{export_date}.json")
+        tsv_output_filename =  path.join(dump_folder, f"digobs_covid19_{project}_revisions-{export_date}.tsv")
+
+        with open(json_output_filename, 'w') as json_output, \
+             open(tsv_output_filename, 'w') as tsv_output:
+            tsv_writer = DictWriter(tsv_output, fieldnames=tsv_fields, delimiter="\t")
+            tsv_writer.writeheader()
+  
+            for rev_batch in project_revs:
+                logging.debug(f"processing raw revision: {rev_batch}")
+                rev_batch_to_json(rev_batch, json_output=json_output)
+                rev_batch_to_tsv(rev_batch, project=project, tsv_writer=tsv_writer)
+
+    for project in projects:
+        write_project_pages(project)

 
 if __name__ == "__main__":
     main()
 
 if __name__ == "__main__":
     main()