commoncrawl_extractor.py

#!/usr/bin/env python
"""
Provides functionality to crawl and extract news articles from a single WARC file from commoncrawl.org. Filter criteria, such as publish date
and host list, can be defined. Currently, the WARC file will be downloaded to the path WORKINGDIR/cc_download_warc, if
not otherwise specified.
"""
import logging
import os
import sys
import time

from ago import human
import boto3
import botocore
from dateutil import parser
from hurry.filesize import size
from scrapy.utils.log import configure_logging
from six.moves import urllib
from warcio.archiveiterator import ArchiveIterator

from newsplease import NewsPlease, EmptyResponseError
import custom_commoncrawl_crawler as commoncrawl_crawler

from bs4.dammit import EncodingDetector
import tldextract

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


def extract_html_from_warc(warc_record, decode_errors="replace"):
    """
    Extracts relevant information from a WARC record. This function does not invoke scrapy but only uses the article
    extractor.
    :return:
    """
    if hasattr(warc_record, 'html'):
        return warc_record.html

    raw_stream = warc_record.raw_stream.read()
    encoding = None
    try:
        encoding = (
            warc_record.http_headers.get_header("Content-Type")
            .split(";")[1]
            .split("=")[1]
        )
    except:
        pass
    if not encoding:
        encoding = EncodingDetector.find_declared_encoding(raw_stream, is_html=True)
    if not encoding:
        # assume utf-8
        encoding = "utf-8"

    html = ""
    
    try:
        html = raw_stream.decode(encoding, errors=decode_errors)
    except LookupError:
        # non-existent encoding: fallback to utf-9
        html = raw_stream.decode("utf-8", errors=decode_errors)
    
    warc_record.html = html

    return html

class CustomNewsPlease(NewsPlease):
    @staticmethod
    def from_warc(warc_record, decode_errors="replace", fetch_images=True):
        """
        Extracts relevant information from a WARC record. This function does not invoke scrapy but only uses the article
        extractor.
        :return:
        """
        html = extract_html_from_warc(warc_record, decode_errors=decode_errors)
        if not html:
            raise EmptyResponseError()
        url = warc_record.rec_headers.get_header("WARC-Target-URI")
        download_date = warc_record.rec_headers.get_header("WARC-Date")
        article = NewsPlease.from_html(
            html, url=url, download_date=download_date, fetch_images=fetch_images
        )
        return article
    
class CommonCrawlExtractor:
    # remote url where we can download the warc file
    __warc_path = None
    # download dir for warc files
    __local_download_dir_warc = './cc_download_warc/'
    # hosts (if None or empty list, any host is OK)
    __filter_valid_hosts = []  # example: ['elrancaguino.cl']
    # start date (if None, any date is OK as start date), as datetime
    __filter_start_date = None
    # end date (if None, any date is OK as end date)
    __filter_end_date = None
    # if date filtering is string, e.g., if we could not detect the date of an article, we will discard the article
    __filter_strict_date = True
    # if True, the script checks whether a file has been downloaded already and uses that file instead of downloading
    # again. Note that there is no check whether the file has been downloaded completely or is valid!
    __reuse_previously_downloaded_files = True
    # continue after error
    __continue_after_error = False
    # ignore unicode errors
    __ignore_unicode_errors = False
    # fetch images
    __fetch_images = False
    # log level
    __log_level = logging.INFO
    __delete_warc_after_extraction = True
    __log_pathname_fully_extracted_warcs = None

    #output
    __local_download_dir_article = None

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

    # event handler called when an article was extracted successfully and passed all filter criteria
    __callback_on_article_extracted = None
    # event handler called when a warc file is fully processed
    __callback_on_warc_completed = None
    # if the download progress is shown
    __show_download_progress = False

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

    #Filter utils
    __html_lang_indicators = [
        ('http-equiv="content-language" content="pt', 1.0),
        ('property="og:locale" content="pt', 0.8),
        ('meta name="language" content="pt', 0.8),
        ('meta name="language" content="portugu', 0.8),
        ('lang="pt', 0.6),
        ('pt-br', 0.4),
        ('pt-pt', 0.4),
        ('pt_br', 0.4),
        ('pt_pt', 0.4),
    ]
    __html_lang_indicators.extend([(hi[0].replace('"', "'"), hi[1]) for hi in __html_lang_indicators if hi[0].replace('"', "'") != hi[0]])
    __html_lang_indicators = sorted(__html_lang_indicators, key=lambda d: d[1], reverse=True)
    

    def __setup(self):
        """
        Setup
        :return:
        """
        os.makedirs(self.__local_download_dir_warc, exist_ok=True)

        # 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)

        boto3.set_stream_logger('botocore', self.__log_level)
        boto3.set_stream_logger('boto3', self.__log_level)
        boto3.set_stream_logger('s3transfer', self.__log_level)

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

    def __register_fully_extracted_warc_file(self, warc_path):
        """
        Saves the URL warc_url in the log file for fully extracted WARC URLs
        :param warc_url:
        :return:
        """
        if self.__log_pathname_fully_extracted_warcs is not None:
            with open(self.__log_pathname_fully_extracted_warcs, 'a') as log_file:
                log_file.write(warc_path + '\n')

    def filter_record(self, warc_record, article=None):
        """
        Returns true if a record passes all tests: hosts, publishing date
        :param warc_record:
        :return: A tuple of (True or False) and an article (might be None)
        """
        data = {}

        language = warc_record.http_headers.get_header('Content-Language')
        data['content-language'] =  language
        if language is not None and 'pt' in language.lower():
            data['filter_pass'] = 'content-language'
            data['filter_pass_meta'] = {'content-language': language}
            return True, article, data

        url = warc_record.rec_headers.get_header('WARC-Target-URI') 
        # filter by url suffix
        #Domain extension of countries with portuguese spoken by the majority of the population as the mother language
        #Brazil, Portugual, Angola, São Tomé and Príncipe
        portuguese_majority_domains = {'br', 'pt', 'ao', 'st'}
        #Domain extension of other countries that speaks portuguese
        #Mozambique, Guinea-Bissau, Equatorial Guinea, East Timor, Macau, Cape Verde
        portuguese_maybe_domains = {'mz', 'gw', 'gq', 'tl', 'mo', 'cv'}
        url_suffixes = tldextract.extract(url).suffix.split('.')
        #valid_suffix = False
        for suffix in url_suffixes:
            if suffix in portuguese_majority_domains:
                #valid_suffix = True
                data['filter_pass'] = 'domain-extension'
                data['filter_pass_meta'] = {'domain-extension': suffix}
                return True, article, data
            if suffix in portuguese_maybe_domains:
                if not article:
                    article = self._from_warc(warc_record)
                    if article.language == 'pt':
                        data['filter_pass'] = 'domain-extension'
                        data['filter_pass_meta'] = {'domain-extension': suffix}
                        return True, article, data

        raw_html = extract_html_from_warc(warc_record).lower()
        for indicator, score in self.__html_lang_indicators:
            if indicator in raw_html:
                data['filter_pass'] = 'html-tag'
                data['filter_pass_meta'] = {'html-tag': indicator, 'score': round(score, 1)}
                if score < 0.61: # floating error
                    if not article:
                        article = self._from_warc(warc_record)
                        if article.language != 'pt':
                            return False, article, data
                return True, article, data

        return False, article, data
    
        #if not valid_suffix:
        #    return False, article

        # filter by host
        if self.__filter_valid_hosts:
            # very simple check, check if one of the required host names is contained in the url of the WARC transaction
            # better would be to extract the host name from the WARC transaction Target URI and then check for equality
            # because currently something like g.co?forward_url=facebook.com would yield a positive filter test for
            # facebook.com even though the actual host is g.co
            for valid_host in self.__filter_valid_hosts:
                if valid_host in url:
                    break
            else:
                return False, article

        # filter by date
        if self.__filter_start_date or self.__filter_end_date:
            if not article:
                article = self._from_warc(warc_record)

            publishing_date = self.__get_publishing_date(warc_record, article)
            if not publishing_date:
                if self.__filter_strict_date:
                    return False, article
            else:  # here we for sure have a date
                # is article published too early?
                if self.__filter_start_date and publishing_date < self.__filter_start_date:
                    return False, article
                if self.__filter_end_date and publishing_date > self.__filter_end_date:
                    return False, article

        return True, article

    def __get_publishing_date(self, warc_record, article):
        """
        Extracts the publishing date from the record
        :param warc_record:
        :return:
        """
        if hasattr(article, 'date_publish'):
            return parser.parse(article.date_publish) if isinstance(article.date_publish, str) else article.date_publish
        else:
            return None

    def __get_remote_index(self):
        """
        Gets the index of news crawl files from commoncrawl.org and returns an array of names
        :return:
        """
        return commoncrawl_crawler.__get_remote_index()

    def __on_download_progress_update(self, blocknum, blocksize, totalsize):
        """
        Prints some download progress information
        :param blocknum:
        :param blocksize:
        :param totalsize:
        :return:
        """
        if not self.__show_download_progress:
            return

        readsofar = blocknum * blocksize
        if totalsize > 0:
            s = "\r%s / %s" % (size(readsofar), size(totalsize))
            sys.stdout.write(s)
            if readsofar >= totalsize:  # near the end
                sys.stderr.write("\r")
        else:  # total size is unknown
            sys.stdout.write("\rread %s" % (size(readsofar)))

    def __download(self, path):
        """
        Download and save a file locally.
        :param url: Where to download from
        :return: File path name of the downloaded file
        """
        local_filename = urllib.parse.quote_plus(path)
        local_filepath = os.path.join(self.__local_download_dir_warc, local_filename)

        if os.path.isfile(local_filepath) and self.__reuse_previously_downloaded_files:
            self.__logger.info("found local file %s, not downloading again due to configuration", local_filepath)
            return local_filepath
        else:
            # cleanup
            try:
                os.remove(local_filepath)
            except OSError:
                pass

            # download
            if self.__s3_client:
                with open(local_filepath, 'wb') as file_obj:
                    self.__s3_client.download_fileobj(self.__cc_bucket, path, file_obj)
                return local_filepath
            else:
                url = self.__cc_base_url + path
                self.__logger.info('downloading %s (local: %s)', url, local_filepath)
                urllib.request.urlretrieve(url, local_filepath, reporthook=self.__on_download_progress_update)
                self.__logger.info('download completed, local file: %s', local_filepath)
                return local_filepath

    def _from_warc(self, record):
        return CustomNewsPlease.from_warc(record, decode_errors="replace" if self.__ignore_unicode_errors else "strict", fetch_images=self.__fetch_images)

    def __process_warc_gz_file(self, path_name):
        """
        Iterates all transactions in one WARC file and for each transaction tries to extract an article object.
        Afterwards, each article is checked against the filter criteria and if all are passed, the function
        on_valid_article_extracted is invoked with the article object.
        :param path_name:
        :return:
        """
        counter_article_total = 0
        counter_article_passed = 0
        counter_article_discarded = 0
        counter_article_error = 0
        start_time = time.time()

        with open(path_name, 'rb') as stream:
            for record in ArchiveIterator(stream):
                try:
                    if record.rec_type == 'response':
                        counter_article_total += 1
                        data = {}
                        # if the article passes filter tests, we notify the user
                        try:
                            filter_pass, article, data = self.filter_record(record)
                        except (UnicodeDecodeError, EmptyResponseError):
                            filter_pass = False
                        if filter_pass:
                            try:
                                if not article:
                                    article = self._from_warc(record)

                            except (UnicodeDecodeError, EmptyResponseError):
                                filter_pass = False
                        if filter_pass:
                            counter_article_passed += 1

                            self.__logger.debug('article pass (%s; %s; %s)', article.source_domain, article.date_publish,
                                               article.title)
                            self.__callback_on_article_extracted(article, self, extra_data = data)
                        else:
                            counter_article_discarded += 1

                            if article:
                                self.__logger.debug('article discard (%s; %s; %s)', article.source_domain,
                                                   article.date_publish,
                                                   article.title)
                            else:
                                self.__logger.debug('article discard (%s)',
                                                   record.rec_headers.get_header('WARC-Target-URI'))

                        if counter_article_total % 10000 == 0:
                            elapsed_secs = time.time() - start_time
                            secs_per_article = elapsed_secs / counter_article_total
                            self.__logger.info('statistics')
                            self.__logger.info('pass = %i, discard = %i, error = %i, total = %i',
                                               counter_article_passed,
                                               counter_article_discarded, counter_article_error, counter_article_total)
                            self.__logger.info('extraction from current WARC file started %s; %f s/article',
                                               human(start_time), secs_per_article)
                except:
                    if self.__continue_after_error:
                        self.__logger.error('Unexpected error: %s (%s)', *sys.exc_info()[0:2])
                        self.__logger.error(sys.exc_info()[2], exc_info=True)
                        counter_article_error += 1
                        pass
                    else:
                        raise

        # cleanup
        if self.__delete_warc_after_extraction:
            os.remove(path_name)

        self.__register_fully_extracted_warc_file(self.__warc_path)
        self.__callback_on_warc_completed(self.__warc_path, counter_article_passed, counter_article_discarded,
                                          counter_article_error, counter_article_total)

    def __cleanup_output_file(self):
        #Delete incomplete output file if exists
        if self.__local_download_dir_article is not None:
            warc_filename = os.path.basename(self.__warc_path).replace('.warc.gz', '')
            year = warc_filename[8:12]
            output_filepath = os.path.join(self.__local_download_dir_article, year, warc_filename + '.jsonl')
            if os.path.exists(output_filepath):
                self.__logger.info(f"Removing incomplete output file {output_filepath}")
                os.remove(output_filepath)

    def __run(self):
        """
        Main execution method, which consists of: get an up-to-date list of WARC files, and for each of them: download
        and extract articles. Each article is checked against a filter. Finally, for each valid article the method
        on_valid_article_extracted will be invoked after the extraction of the article has completed.
        :return:
        """
        self.__setup()

        self.__cleanup_output_file()
        local_path_name = self.__download(self.__warc_path)
        self.__process_warc_gz_file(local_path_name)

    def extract_from_commoncrawl(self, warc_path, callback_on_article_extracted,
                                 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, ignore_unicode_errors=False,
                                 show_download_progress=False, log_level=logging.ERROR, delete_warc_after_extraction=True,
                                 log_pathname_fully_extracted_warcs=None, fetch_images=False, 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 log_pathname_fully_extracted_warcs:
        :param delete_warc_after_extraction:
        :param warc_path:
        :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:
        :return:
        """
        self.warc_path = warc_path
        self.__warc_path = warc_path
        self.__filter_valid_hosts = valid_hosts
        self.__filter_start_date = start_date
        self.__filter_end_date = end_date
        self.__filter_strict_date = strict_date
        if local_download_dir_warc:
            self.__local_download_dir_warc = local_download_dir_warc
        self.__reuse_previously_downloaded_files = reuse_previously_downloaded_files
        self.__continue_after_error = continue_after_error
        self.__ignore_unicode_errors = ignore_unicode_errors
        self.__fetch_images = fetch_images
        self.__callback_on_article_extracted = callback_on_article_extracted
        self.__callback_on_warc_completed = callback_on_warc_completed
        self.__show_download_progress = show_download_progress
        self.__log_level = log_level
        self.__delete_warc_after_extraction = delete_warc_after_extraction
        self.__log_pathname_fully_extracted_warcs = log_pathname_fully_extracted_warcs
        self.__local_download_dir_article = local_download_dir_article

        self.__s3_client = None

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


        self.__run()