custom_commoncrawl_crawler.py

#!/usr/bin/env python
"""
Provides functionality to crawl and extract news articles from commoncrawl.org. Filter criteria, such as publish date
and host list, can be defined. Currently, all WARC files will be downloaded to the path WORKINGDIR/cc_download_warc, if
not otherwise specified.
"""
import logging
import os
import time
from functools import partial
from multiprocessing import Pool
import datetime
import gzip
from urllib.parse import urlparse

import boto3
import botocore
from dateutil import parser
import requests
from scrapy.utils.log import configure_logging

import random

from commoncrawl_extractor import CommonCrawlExtractor

__author__ = "Felix Hamborg"
__copyright__ = "Copyright 2017"
__credits__ = ["Sebastian Nagel"]

# commoncrawl.org
__cc_base_url = 'https://data.commoncrawl.org/'
__cc_bucket = 'commoncrawl'

# log file of fully extracted WARC files
__log_pathname_fully_extracted_warcs = None

# logging
logging.basicConfig(level=logging.INFO)
__logger = logging.getLogger(__name__)

__number_of_warc_files_on_cc = 0

__extern_callback_on_warc_completed = None
__counter_article_passed = 0
__counter_article_discarded = 0
__counter_article_error = 0
__counter_article_total = 0
__counter_warc_skipped = 0
__counter_warc_processed = 0
__start_time = time.time()

__shufle = False

# When Common Crawl started.
__common_crawl_start_date = datetime.datetime(2016, 8, 26)

def __setup(local_download_dir_warc, log_level):
    """
    Setup
    :return:
    """
    os.makedirs(local_download_dir_warc, exist_ok=True)

    global __log_pathname_fully_extracted_warcs
    __log_pathname_fully_extracted_warcs = os.path.join(local_download_dir_warc, 'fullyextractedwarcs.list')

    # make loggers quiet
    configure_logging({"LOG_LEVEL": "ERROR"})
    logging.getLogger('requests').setLevel(logging.CRITICAL)
    logging.getLogger('readability').setLevel(logging.CRITICAL)
    logging.getLogger('PIL').setLevel(logging.CRITICAL)
    logging.getLogger('newspaper').setLevel(logging.CRITICAL)
    logging.getLogger('newsplease').setLevel(logging.CRITICAL)
    logging.getLogger('urllib3').setLevel(logging.CRITICAL)
    logging.getLogger('jieba').setLevel(logging.CRITICAL)

    boto3.set_stream_logger('botocore', log_level)
    boto3.set_stream_logger('boto3', log_level)

    # set own logger
    logging.basicConfig(level=log_level)
    __logger = logging.getLogger(__name__)
    __logger.setLevel(log_level)


def __get_publishing_date(warc_record, article):
    """
    Extracts the publishing date from the article
    :param warc_record:
    :return:
    """
    if article.publish_date:
        return parser.parse(article.publish_date)
    else:
        return None


def __get_download_url(name):
    """
    Creates a download url given the name
    :param name:
    :return:
    """
    return __cc_base_url + name


def __iterate_by_month(start_date=None, end_date=None, month_step=1):
    if start_date is None:
        # The starting month of Common Crawl.
        start_date = __common_crawl_start_date
    if end_date is None:
        # Until now.
        end_date = datetime.datetime.today()
    current_date = start_date
    yield current_date
    while True:
        carry, new_month = divmod(current_date.month - 1 + month_step, 12)
        new_month += 1
        current_date = current_date.replace(year=current_date.year + carry,
                                            month=new_month)
        yield current_date
        if current_date > end_date:
            break


def __extract_date_from_warc_filename(path):
    fn = os.path.basename(path)
    # Assume the filename pattern is CC-NEWS-20160911145202-00018.warc.gz
    fn = fn.replace('CC-NEWS-', '')
    dt = fn.split('-')[0]

    try:
        return datetime.datetime.strptime(dt, '%Y%m%d%H%M%S')
    except:
        # return date clearly outside the range
        return datetime.datetime(1900, 1, 1)


def __date_within_period(date, start_date=None, end_date=None):
    if start_date is None:
        # The starting month of Common Crawl.
        start_date = __common_crawl_start_date
    if end_date is None:
        # Until now.
        end_date = datetime.datetime.today()
    return start_date <= date < end_date


def __get_remote_index(warc_files_start_date=None, warc_files_end_date=None):
    """
    Gets the index of news crawl files from commoncrawl.org and returns an array of names
    :param warc_files_start_date: only list .warc files with greater or equal date in
    their filename
    :param warc_files_end_date: only list .warc files with smaller date in their filename
    :return:
    """

    s3_client = boto3.client('s3')
    # Verify access to commoncrawl bucket
    try:
        s3_client.head_bucket(Bucket=__cc_bucket)
    except (botocore.exceptions.ClientError, botocore.exceptions.NoCredentialsError) as e:
        __logger.info('Failed to read %s bucket, using monthly WARC file listings', __cc_bucket)
        self.__logger.warning(str(e))
        s3_client = None

    objects = []

    if s3_client:
        def s3_list_objects(bucket, prefix):
            #response = s3_client.list_objects(Bucket=bucket, Prefix=prefix)
            paginator = s3_client.get_paginator('list_objects')
            pages = paginator.paginate(Bucket=bucket, Prefix=prefix)

            data = []
            for page in pages:
                if 'Contents' not in page:
                    continue
                for obj in page['Contents']:
                    data.append(obj['Key'])

            return data
            #if 'Contents' not in response:
            #    return []
            #return [x['Key'] for x in response['Contents']]

        if warc_files_start_date or warc_files_end_date:
            # The news files are grouped per year and month in separate folders
            warc_dates = __iterate_by_month(start_date=warc_files_start_date, end_date=warc_files_end_date)
            for date in warc_dates:
                year = date.strftime('%Y')
                month = date.strftime('%m')
                prefix = 'crawl-data/CC-NEWS/%s/%s/' % (year, month)
                __logger.debug('Listing objects on S3 bucket %s and prefix %s', __cc_bucket, prefix)
                objects += s3_list_objects(__cc_bucket, prefix)
        else:
            objects = s3_list_objects(__cc_bucket, 'crawl-data/CC-NEWS/')

    else:
        # The news files are grouped per year and month in separate folders
        warc_dates = __iterate_by_month(start_date=warc_files_start_date, end_date=warc_files_end_date)
        for date in warc_dates:
            year = date.strftime('%Y')
            month = date.strftime('%m')
            url = '%scrawl-data/CC-NEWS/%s/%s/warc.paths.gz' % (__cc_base_url, year, month)
            __logger.debug('Fetching WARC paths listing %s', url)
            response = requests.get(url)
            if response:
                objects += gzip.decompress(response.content).decode('ascii').strip().split('\n')
            else:
                __logger.info('Failed to fetch WARC file list %s: %s', url, response)

    if warc_files_start_date or warc_files_end_date:
        # Now filter further on day of month, hour, minute
        objects = [
            p for p in objects if __date_within_period(
                __extract_date_from_warc_filename(p),
                start_date=warc_files_start_date,
                end_date=warc_files_end_date,
            )
        ]

    __logger.info('Found %i WARC files', len(objects))

    return objects

def __get_url_path(url_or_path):
    if url_or_path.startswith('http:') or url_or_path.startswith('https:'):
        try:
            url = urlparse(url_or_path)
            return url.path.lstrip('/') # trim leading slash
        except:
            pass
    return url_or_path

def __get_list_of_fully_extracted_warc_paths():
    """
    Reads in the log file that contains a list of all previously, fully extracted WARC urls
    :return:
    """
    if not os.path.isfile(__log_pathname_fully_extracted_warcs):
        return []

    with open(__log_pathname_fully_extracted_warcs) as log_file:
        list_warcs = log_file.readlines()
    # remove break lines
    list_warcs = [x.strip() for x in list_warcs]

    # (back-ward compatibility) if it's a URL keep only the path
    list_warcs = [__get_url_path(x) for x in list_warcs]

    return list_warcs


def __callback_on_warc_completed(warc_path, counter_article_passed, counter_article_discarded, counter_article_error,
                                 counter_article_total):
    """
    Internal callback on completion of one WARC file. Calculating some statistics on processing speed.
    :param warc_path:
    :param counter_article_passed:
    :param counter_article_discarded:
    :param counter_article_error:
    :param counter_article_total:
    :return:
    """
    # have to use the global keyword in order to assign a value to a global variable (see https://stackoverflow.com/a/9936482)
    global __counter_article_passed
    global __counter_article_discarded
    global __counter_article_error
    global __counter_article_total
    global __counter_warc_processed
    # global __counter_warc_skipped

    elapsed_secs = time.time() - __start_time

    __counter_article_discarded += counter_article_discarded
    __counter_article_error += counter_article_error
    __counter_article_passed += counter_article_passed
    __counter_article_total += counter_article_total
    __counter_warc_processed += 1

    sec_per_article = elapsed_secs / counter_article_total
    h_per_warc = elapsed_secs / __counter_warc_processed / 3600
    remaining_warcs = __number_of_warc_files_on_cc - (__counter_warc_processed + __counter_warc_skipped)

    __logger.info("warc processing statistics")
    __logger.info("warc files skipped = %i, processed = %i, remaining = %i, total = %i", __counter_warc_skipped,
                  __counter_warc_processed, remaining_warcs, __number_of_warc_files_on_cc)
    __logger.info("global [s/article] = %f", sec_per_article)
    __logger.info("global [h/warc] = %.3f", h_per_warc)
    __logger.info("estimated remaining time [h] = %f", remaining_warcs * h_per_warc)

    # invoke the external callback
    __extern_callback_on_warc_completed(warc_path, __counter_article_passed, __counter_article_discarded,
                                        __counter_article_error, __counter_article_total, __counter_warc_processed)


def __start_commoncrawl_extractor(warc_path, callback_on_article_extracted=None,
                                  callback_on_warc_completed=None, valid_hosts=None,
                                  start_date=None, end_date=None,
                                  strict_date=True, reuse_previously_downloaded_files=True,
                                  local_download_dir_warc=None,
                                  continue_after_error=True, show_download_progress=False,
                                  log_level=logging.ERROR,
                                  delete_warc_after_extraction=True,
                                  continue_process=True,
                                  log_pathname_fully_extracted_warcs=None,
                                  extractor_cls=CommonCrawlExtractor,
                                  fetch_images=False,
                                  local_download_dir_article=None):
    """
    Starts a single CommonCrawlExtractor
    :param warc_path: path to the WARC file on s3://commoncrawl/ resp. https://data.commoncrawl.org/
    :param callback_on_article_extracted:
    :param callback_on_warc_completed:
    :param valid_hosts:
    :param start_date:
    :param end_date:
    :param strict_date:
    :param reuse_previously_downloaded_files:
    :param local_download_dir_warc:
    :param continue_after_error:
    :param show_download_progress:
    :param log_level:
    :param extractor_cls: A subclass of CommonCrawlExtractor, which can be used
        to add custom filtering by overriding .filter_record(...)
    :return:
    """
    commoncrawl_extractor = extractor_cls()
    commoncrawl_extractor.extract_from_commoncrawl(warc_path, callback_on_article_extracted,
                                                   callback_on_warc_completed=callback_on_warc_completed,
                                                   valid_hosts=valid_hosts,
                                                   start_date=start_date, end_date=end_date,
                                                   strict_date=strict_date,
                                                   reuse_previously_downloaded_files=reuse_previously_downloaded_files,
                                                   local_download_dir_warc=local_download_dir_warc,
                                                   continue_after_error=continue_after_error,
                                                   show_download_progress=show_download_progress,
                                                   log_level=log_level,
                                                   delete_warc_after_extraction=delete_warc_after_extraction,
                                                   log_pathname_fully_extracted_warcs=__log_pathname_fully_extracted_warcs,
                                                   fetch_images=fetch_images,
                                                   local_download_dir_article=local_download_dir_article)


def crawl_from_commoncrawl(callback_on_article_extracted, callback_on_warc_completed=None, valid_hosts=None,
                           start_date=None, end_date=None, warc_files_start_date=None, warc_files_end_date=None, strict_date=True,
                           reuse_previously_downloaded_files=True, local_download_dir_warc=None,
                           continue_after_error=True, show_download_progress=False,
                           number_of_extraction_processes=4, log_level=logging.ERROR,
                           delete_warc_after_extraction=True, continue_process=True,
                           extractor_cls=CommonCrawlExtractor, fetch_images=False,
                           dry_run=False, shuffle=__shufle, local_download_dir_article=None):
    """
    Crawl and extract articles form the news crawl provided by commoncrawl.org. For each article that was extracted
    successfully the callback function callback_on_article_extracted is invoked where the first parameter is the
    article object.
    :param continue_process:
    :param delete_warc_after_extraction:
    :param number_of_extraction_processes:
    :param callback_on_article_extracted:
    :param valid_hosts:
    :param start_date:
    :param end_date:
    :param warc_files_start_date
    :param warc_files_end_date
    :param strict_date:
    :param reuse_previously_downloaded_files:
    :param local_download_dir_warc:
    :param continue_after_error:
    :param show_download_progress:
    :param log_level:
    :param extractor_cls:
    :param dry_run: if True just list the WARC files to be processed but do not actually process them
    :return:
    """
    __setup(local_download_dir_warc, log_level)

    global __extern_callback_on_warc_completed
    __extern_callback_on_warc_completed = callback_on_warc_completed

    cc_news_crawl_names = __get_remote_index(warc_files_start_date, warc_files_end_date)
    global __number_of_warc_files_on_cc
    __number_of_warc_files_on_cc = len(cc_news_crawl_names)
    __logger.info('found %i files at commoncrawl.org', __number_of_warc_files_on_cc)

    if shuffle:
        random.seed(42)
        random.shuffle(cc_news_crawl_names)
        __logger.info('shuffled the list of WARC files')

    # multiprocessing (iterate the list of crawl_names, and for each: download and process it)
    __logger.info('creating extraction process pool with %i processes', number_of_extraction_processes)
    warc_paths = []
    fully_extracted_warc_paths = __get_list_of_fully_extracted_warc_paths()
    for warc_path in cc_news_crawl_names:
        if continue_process:
            # check if the current WARC has already been fully extracted (assuming that the filter criteria have not
            # been changed!)
            if warc_path in fully_extracted_warc_paths:
                __logger.info('skipping WARC because fully extracted: %s', warc_path)
                global __counter_warc_skipped
                __counter_warc_skipped += 1
                pass
            else:
                warc_paths.append(warc_path)

        else:
            # if not continue process, then always add
            warc_paths.append(warc_path)

    if dry_run:
        for warc_path in warc_paths:
            __logger.info('(Dry run) Selected WARC file for processing: %s', warc_path)

    # run the crawler in the current, single process if number of extraction processes is set to 1
    elif number_of_extraction_processes > 1:
        with Pool(number_of_extraction_processes) as extraction_process_pool:
            extraction_process_pool.map(partial(__start_commoncrawl_extractor,
                                                callback_on_article_extracted=callback_on_article_extracted,
                                                callback_on_warc_completed=__callback_on_warc_completed,
                                                valid_hosts=valid_hosts,
                                                start_date=start_date, end_date=end_date,
                                                strict_date=strict_date,
                                                reuse_previously_downloaded_files=reuse_previously_downloaded_files,
                                                local_download_dir_warc=local_download_dir_warc,
                                                continue_after_error=continue_after_error,
                                                show_download_progress=show_download_progress,
                                                log_level=log_level,
                                                delete_warc_after_extraction=delete_warc_after_extraction,
                                                log_pathname_fully_extracted_warcs=__log_pathname_fully_extracted_warcs,
                                                extractor_cls=extractor_cls,
                                                fetch_images=fetch_images,
                                                local_download_dir_article=local_download_dir_article),
                                        warc_paths)
    else:
        for warc_path in warc_paths:
            __start_commoncrawl_extractor(warc_path,
                                          callback_on_article_extracted=callback_on_article_extracted,
                                          callback_on_warc_completed=__callback_on_warc_completed,
                                          valid_hosts=valid_hosts,
                                          start_date=start_date, end_date=end_date,
                                          strict_date=strict_date,
                                          reuse_previously_downloaded_files=reuse_previously_downloaded_files,
                                          local_download_dir_warc=local_download_dir_warc,
                                          continue_after_error=continue_after_error,
                                          show_download_progress=show_download_progress,
                                          log_level=log_level,
                                          delete_warc_after_extraction=delete_warc_after_extraction,
                                          log_pathname_fully_extracted_warcs=__log_pathname_fully_extracted_warcs,
                                          extractor_cls=extractor_cls,
                                          fetch_images=fetch_images,
                                          local_download_dir_article=local_download_dir_article)