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