First commit test

.gitignore

@@ -0,0 +1,2 @@
+*.ipynb
+*/

README.MD

@@ -0,0 +1,36 @@
+### Dataset Summary
+
+CC-News-PT is a curation of news articles from CommonCrawl News in the Portuguese language.  
+CommonCrawl News is a dataset containing news articles from news sites all over the world.  
+The data is available on AWS S3 in the Common Crawl bucket at /crawl-data/CC-NEWS/.  
+This version of the dataset is the portuguese subset from [CloverSearch/cc-news-mutlilingual](https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual).
+
+### Data Fields
+
+- `title`: a `string` feature.
+- `text`: a `string` feature.
+- `authors`: a `string` feature.
+- `domain`: a `string` feature.
+- `date`: a `string` feature.
+- `description`: a `string` feature.
+- `url`: a `string` feature.
+- `image_url`: a `string` feature.
+- `date_download`: a `string` feature.
+
+### How to use this dataset
+
+```python
+from datasets import load_dataset
+dataset = load_dataset("eduagarcia/cc_news_pt", split="train")
+```
+
+### Cite
+
+```
+@misc{Acerola2023,
+    author = {Garcia, E.A.S.},
+    title = {Acerola Corpus: Towards Better Portuguese Language Models},
+    year = {2023},
+    doi = {10.57967/hf/0814}
+}
+```

cc_news_pt.py

@@ -0,0 +1,128 @@
+import json
+import os
+from fnmatch import fnmatch
+
+import datasets
+from typing import Dict, List, Optional, Union, Callable
+import textwrap
+import gzip
+
+
+logger = datasets.logging.get_logger(__name__)
+
+_CC_NEWS_PT_KWARGS = dict(
+    name = "cc_news_pt",
+    description=textwrap.dedent(
+        """\
+        CC-News-PT is a curation of news articles from CommonCrawl News in the Portuguese language.
+        CommonCrawl News is a dataset containing news articles from news sites all over the world
+        The data is available on AWS S3 in the Common Crawl bucket at /crawl-data/CC-NEWS/.
+        This version of the dataset is the portuguese subset from
+        https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual"""
+    ),
+    data_urls=[
+        'https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual/resolve/main/2016/pt.jsonl.gz',
+        #'https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual/resolve/main/2017/pt.jsonl.gz',
+        #'https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual/resolve/main/2018/pt.jsonl.gz',
+        #'https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual/resolve/main/2019/pt.jsonl.gz',
+        #'https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual/resolve/main/2020/pt.jsonl.gz',
+        #'https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual/resolve/main/2021/pt.jsonl.gz',
+    ],  
+    citation=textwrap.dedent(
+        """\
+        @misc{Acerola2023,
+            author     = {Garcia, E.A.S.},
+            title      = {Acerola Corpus: Towards Better Portuguese Language Models},
+            year       = {2023},
+            doi        = {10.57967/hf/0814}
+        }"""
+    ),
+    url="https://huggingface.co/datasets/eduagarcia/cc_news_pt",
+)
+
+
+class AcerolaConfig(datasets.BuilderConfig):
+    """BuilderConfig for Acerola."""
+
+    def __init__(
+        self,
+        data_urls: Dict[str, str],
+        citation: str,
+        url: str,
+        file_type: Optional[str] = None, #filetype (csv, tsc, jsonl)
+        **kwargs
+    ):
+        """BuilderConfig for Acerola.
+        Args:
+        **kwargs: keyword arguments forwarded to super.
+        """
+        super(AcerolaConfig, self).__init__(version=datasets.Version("1.0.3", ""), **kwargs)
+        self.data_urls = data_urls
+        self.citation = citation
+        self.url = url
+        self.file_type = file_type
+
+
+def _get_ccnews_features(config: AcerolaConfig):
+    return datasets.Features(
+        {
+            "title": datasets.Value("string"),
+            "text": datasets.Value("string"),
+            "authors": datasets.Value("string"),
+            "domain": datasets.Value("string"),
+            "date": datasets.Value("string"),
+            "description": datasets.Value("string"),
+            "url": datasets.Value("string"),
+            "image_url": datasets.Value("string"),
+            "date_download": datasets.Value("string")
+        }
+    )
+
+class Acerola(datasets.GeneratorBasedBuilder):
+    """CC-News dataset."""
+
+    BUILDER_CONFIGS = [
+        AcerolaConfig(
+            **_CC_NEWS_PT_KWARGS
+        )
+    ]
+
+    def _info(self) -> datasets.DatasetInfo:
+        features = _get_ccnews_features(self.config)
+        
+        return datasets.DatasetInfo(
+            description=self.config.description,
+            homepage=self.config.url,
+            citation=self.config.citation,
+            supervised_keys=None,
+            features=features
+        )
+
+    def _split_generators(self, dl_manager):
+        data_urls = self.config.data_urls.copy()
+        filepaths = dl_manager.download(data_urls)
+
+        return [
+            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"filepaths": filepaths}),
+        ]
+
+    def _generate_examples(self, filepaths):
+        id_ = 0
+        for filepath in filepaths:
+            with gzip.open(filepath, "rt", encoding="utf-8") as f:
+                for line in f:
+                    if line:
+                        article = json.loads(line)
+                        yield id_, {
+                            "title": article["title"].strip() if article["title"] is not None else "",
+                            "text": article["maintext"].strip() if article["maintext"] is not None else "",
+                            "authors": "; ".join([a.strip() for a in article["authors"]]) if len(article["authors"]) > 0 else "",
+                            "domain": article["source_domain"].strip() if article["source_domain"] is not None else "",
+                            "date": article["date_publish"].strip() if article["date_publish"] is not None else "",
+                            "description": article["description"].strip() if article["description"] is not None else "",
+                            "url": article["url"].strip() if article["url"] is not None else "",
+                            "image_url": article["image_url"].strip() if article["image_url"] is not None else "",
+                            "date_download": article["date_download"].strip() if article["date_download"] is not None else "",
+                        }
+                        id_ += 1
+                    

commoncrawl.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python
+"""
+This scripts downloads WARC files from commoncrawl.org's news crawl and extracts articles from these files. You can
+define filter criteria that need to be met (see YOUR CONFIG section), otherwise an article is discarded. Currently, the
+script stores the extracted articles in JSON files, but this behaviour can be adapted to your needs in the method
+on_valid_article_extracted. To speed up the crawling and extraction process, the script supports multiprocessing. You can
+control the number of processes with the parameter my_number_of_extraction_processes.
+
+You can also crawl and extract articles programmatically, i.e., from within
+your own code, by using the class CommonCrawlCrawler or the function
+commoncrawl_crawler.crawl_from_commoncrawl(...) provided in
+newsplease.crawler.commoncrawl_crawler.py. In this case there is also the
+possibility of passing in a your own subclass of CommonCrawlExtractor as
+extractor_cls=... . One use case here is that your subclass can customise
+filtering by overriding `.filter_record(...)`.
+
+This script uses relative imports to ensure that the latest, local version of news-please is used, instead of the one
+that might have been installed with pip. Hence, you must run this script following this workflow.
+git clone https://github.com/fhamborg/news-please.git
+cd news-please
+python3 -m newsplease.examples.commoncrawl
+
+Note that by default the script does not extract main images since they are not contained
+WARC files. You can enable extraction of main images by setting `my_fetch_images=True`
+"""
+import hashlib
+import json
+import logging
+import os
+import sys
+import datetime
+from datetime import date
+
+#import newsplease
+
+import custom_commoncrawl_crawler
+#from newsplease.crawler import commoncrawl_crawler as custom_commoncrawl_crawler
+#from newsplease.crawler.commoncrawl_extractor import CommonCrawlExtractor
+
+__author__ = "Felix Hamborg"
+__copyright__ = "Copyright 2017"
+__credits__ = ["Sebastian Nagel"]
+
+
+############ YOUR CONFIG ############
+# download dir for warc files
+my_local_download_dir_warc = './cc_download_warc/'
+# download dir for articles
+my_local_download_dir_article = './cc_download_articles/'
+# hosts (if None or empty list, any host is OK)
+my_filter_valid_hosts = []  # example: ['elrancaguino.cl']
+# start date (if None, any date is OK as start date), as datetime
+my_filter_start_date = None  # datetime.datetime(2016, 1, 1)
+# end date (if None, any date is OK as end date), as datetime
+my_filter_end_date = None  # datetime.datetime(2016, 12, 31)
+# Only .warc files published within [my_warc_files_start_date, my_warc_files_end_date) will be downloaded.
+# Note that the date a warc file has been published does not imply it contains only news
+# articles from that date. Instead, you must assume that the warc file can contain articles
+# from ANY time before the warc file was published, e.g., a warc file published in August 2020
+# may contain news articles from December 2016.
+my_warc_files_start_date = datetime.datetime(2022, 1, 1) # example: datetime.datetime(2020, 3, 1)
+my_warc_files_end_date = None #datetime.datetime(2023, 1, 1) # example: datetime.datetime(2020, 3, 2)
+# if date filtering is strict and news-please could not detect the date of an article, the article will be discarded
+my_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!
+my_reuse_previously_downloaded_files = False
+# continue after error
+my_continue_after_error = True
+# show the progress of downloading the WARC files
+my_show_download_progress = True
+# log_level
+my_log_level = logging.INFO
+# json export style
+my_json_export_style = 2  # 0 (minimize), 1 (pretty), 2 (jsonl)
+# number of extraction processes
+my_number_of_extraction_processes = 10
+# if True, the WARC file will be deleted after all articles have been extracted from it
+my_delete_warc_after_extraction = True
+# if True, will continue extraction from the latest fully downloaded but not fully extracted WARC files and then
+# crawling new WARC files. This assumes that the filter criteria have not been changed since the previous run!
+my_continue_process = True
+# if True, will crawl and extract main image of each article. Note that the WARC files
+# do not contain any images, so that news-please will crawl the current image from
+# the articles online webpage, if this option is enabled.
+my_fetch_images = False
+# if True, just list the WARC files to be processed, but do not actually download and process them
+my_dry_run=False
+#Shuffle list of warc files to download
+shuffle=False
+############ END YOUR CONFIG #########
+
+
+# logging
+logging.basicConfig(level=my_log_level)
+__logger = logging.getLogger(__name__)
+
+
+def __setup__():
+    """
+    Setup
+    :return:
+    """
+    os.makedirs(my_local_download_dir_article, exist_ok=True)
+
+
+def __get_pretty_filepath(path, article):
+    """
+    Pretty might be an euphemism, but this function tries to avoid too long filenames, while keeping some structure.
+    :param path:
+    :param name:
+    :return:
+    """
+    short_filename = hashlib.sha256(article.filename.encode()).hexdigest()
+    sub_dir = article.source_domain
+    final_path = os.path.join(path, sub_dir)
+    os.makedirs(final_path, exist_ok=True)
+    return os.path.join(final_path, short_filename + '.json')
+
+
+def on_valid_article_extracted(article, extractor, extra_data = {}):
+    """
+    This function will be invoked for each article that was extracted successfully from the archived data and that
+    satisfies the filter criteria.
+    :param article:
+    :return:
+    """
+    # do whatever you need to do with the article (e.g., save it to disk, store it in ElasticSearch, etc.)
+    data = article.__dict__
+    data.update(extra_data)
+    if my_json_export_style != 2:
+        with open(__get_pretty_filepath(my_local_download_dir_article, article), 'w', encoding='utf-8') as outfile:
+            if my_json_export_style == 0:
+                json.dump(data, outfile, default=str, separators=(',', ':'), ensure_ascii=False)
+            elif my_json_export_style == 1:
+                json.dump(data, outfile, default=str, indent=4, sort_keys=True, ensure_ascii=False)
+    else:
+        warc_filename = os.path.basename(extractor.warc_path).replace('.warc.gz', '')
+        year = warc_filename[8:12]
+        os.makedirs(os.path.join(my_local_download_dir_article, year), exist_ok=True)
+        with open(os.path.join(my_local_download_dir_article, year, warc_filename + '.jsonl'), 'a', encoding='utf-8') as outfile:
+            outfile.write(json.dumps(data, default=str, separators=(',', ':'), ensure_ascii=False) + '\n')
+        # ...
+
+
+def callback_on_warc_completed(warc_path, counter_article_passed, counter_article_discarded,
+                               counter_article_error, counter_article_total, counter_warc_processed):
+    """
+    This function will be invoked for each WARC file that was processed completely. Parameters represent total values,
+    i.e., cumulated over all all previously processed WARC files.
+    :param warc_path:
+    :param counter_article_passed:
+    :param counter_article_discarded:
+    :param counter_article_error:
+    :param counter_article_total:
+    :param counter_warc_processed:
+    :return:
+    """
+    pass
+
+"""
+class CustomExtractor(CommonCrawlExtractor):
+    
+    def filter_record(self, warc_record, article=None):
+        
+        url = warc_record.rec_headers.get_header('WARC-Target-URI')
+        
+        # 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 url suffix
+        valid_suffixes = {'br', 'pt'}
+        url_suffixes = tldextract.extract(url).suffix.split('.')
+        valid_suffix = False
+        for suffix in url_suffixes:
+            if suffix in valid_suffixes:
+                valid_suffix = True
+                break
+        
+        if not valid_suffix:
+            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 main():
+    global my_local_download_dir_warc
+    global my_local_download_dir_article
+    global my_delete_warc_after_extraction
+    global my_number_of_extraction_processes
+
+    if len(sys.argv) >= 2:
+        my_local_download_dir_warc = sys.argv[1]
+    if len(sys.argv) >= 3:
+        my_local_download_dir_article = sys.argv[2]
+    if len(sys.argv) >= 4:
+        my_delete_warc_after_extraction = sys.argv[3] == "delete"
+    if len(sys.argv) >= 5:
+        my_number_of_extraction_processes = int(sys.argv[4])
+
+    print("my_local_download_dir_warc=" + my_local_download_dir_warc)
+    print("my_local_download_dir_article=" + my_local_download_dir_article)
+    print("my_delete_warc_after_extraction=" + str(my_delete_warc_after_extraction))
+    print("my_number_of_extraction_processes=" + str(my_number_of_extraction_processes))
+
+    __setup__()
+    custom_commoncrawl_crawler.crawl_from_commoncrawl(on_valid_article_extracted,
+                                               callback_on_warc_completed=callback_on_warc_completed,
+                                               valid_hosts=my_filter_valid_hosts,
+                                               start_date=my_filter_start_date,
+                                               end_date=my_filter_end_date,
+                                               warc_files_start_date=my_warc_files_start_date,
+                                               warc_files_end_date=my_warc_files_end_date,
+                                               strict_date=my_filter_strict_date,
+                                               reuse_previously_downloaded_files=my_reuse_previously_downloaded_files,
+                                               local_download_dir_warc=my_local_download_dir_warc,
+                                               continue_after_error=my_continue_after_error,
+                                               show_download_progress=my_show_download_progress,
+                                               number_of_extraction_processes=my_number_of_extraction_processes,
+                                               log_level=my_log_level,
+                                               delete_warc_after_extraction=my_delete_warc_after_extraction,
+                                               continue_process=True,
+                                               fetch_images=my_fetch_images,
+                                               dry_run=my_dry_run,
+                                               shuffle=shuffle,
+                                               local_download_dir_article=my_local_download_dir_article)
+
+
+if __name__ == "__main__":
+    main()

commoncrawl_extractor.py

@@ -0,0 +1,500 @@
+#!/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()

custom_commoncrawl_crawler.py

@@ -0,0 +1,453 @@
+#!/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)

download.sh

@@ -0,0 +1,6 @@
+wget https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual/resolve/main/2016/pt.jsonl.gz -O 2016_pt.jsonl.gz
+wget https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual/resolve/main/2017/pt.jsonl.gz -O 2017_pt.jsonl.gz
+wget https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual/resolve/main/2018/pt.jsonl.gz -O 2018_pt.jsonl.gz
+wget https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual/resolve/main/2019/pt.jsonl.gz -O 2019_pt.jsonl.gz
+wget https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual/resolve/main/2020/pt.jsonl.gz -O 2020_pt.jsonl.gz
+wget https://huggingface.co/datasets/CloverSearch/cc-news-mutlilingual/resolve/main/2021/pt.jsonl.gz -O 2021_pt.jsonl.gz