Code and amendments to the README

.gitignore

@@ -0,0 +1,12 @@
+.DS_Store
+.scrapy/
+venv/
+*.csv
+*.xml
+*.json
+*.jsonlines
+*.jsonl
+*.pyc
+test_spiders/
+.hg/
+.hgignore

README.md

@@ -14,7 +14,7 @@ Every Prompt is a data-driven approach to mining instructions from the web.
 It contains over a million FAQs and HowTos from around the world in a structured format.
 It also has basic pre-processing to calculate the length of the useful text and identify the language of that text with the help of [GCLD3](https://github.com/google/cld3)
 
-It relies on the [Web Data Commons](http://webdatacommons.org) dataset to find the seed list of sites with [**HowTo**](https://schema.org/HowTo) and [**FAQPage**](https://schema.org/FAQPage) items.
+It relies on the [Web Data Commons](http://webdatacommons.org) dataset (from October 2022) to find the seed list of sites with [**HowTo**](https://schema.org/HowTo) and [**FAQPage**](https://schema.org/FAQPage) items.
 The general pipeline looks like this:
 * Download 1.6TB of structured data from webdatacommons to identify the pages with the structured data we need (wget/parallel). That gives us 1,985,925 seed pages
 * Crawls the seed pages and tries to extract structured data using [extruct](https://pypi.org/project/extruct/#description) package. That left around 1,358,638 pages which are alive and well-formed.
@@ -24,5 +24,14 @@ The general pipeline looks like this:
 You can use the resulting dataset by filtering for the language and amount of the text. You need to convert the structured data into instructions yourself.
 You'll need to apply extra cleansing/evaluation of the instructions you've got because, you know, the internet is still full of crap.
 
+## Recreating the results
+1. Clone the repo without the LFS files
+2. Install requirements from `requirements.txt`
+3. Install `pv` and `parallel`
+4. Run `bin/get_seed_urls.sh` to filter urls of interest out of 1.6TB of compressed data. Don't worry about disk space. Worry about the traffic
+5. Run scrapy spider like this `scrapy crawl webdatacommons_org -s WEB_DATA_COMMONS=web_data_commons_urls_sample.txt -L INFO -o webdatacommons.jsonlines` with `WEB_DATA_COMMONS` pointing to the list of seed URLs from step 4.
+6. Run `python extract_relevant_structured_data.py --num-threads 12 webdatacommons.jsonlines relevant.jsonlines.bz2`
+7. Run `python export_structured_data.py relevant.jsonlines.bz2 extruct_out.jsonlines.bz2` to obtain the final version of the dataset
+
 ## License
 **Code** of the project has an MIT license.

bin/export_structured_data.py

@@ -0,0 +1,124 @@
+from typing import Iterator, List, Dict, TypeVar
+import json
+import argparse
+from concurrent.futures import ThreadPoolExecutor
+from itertools import islice
+
+import smart_open
+from tqdm import tqdm
+import jmespath
+import gcld3
+
+T = TypeVar("T")
+
+
+detector = gcld3.NNetLanguageIdentifier(min_num_bytes=20, max_num_bytes=1000)
+
+def batch_iterator(iterator: Iterator[T], batch_size: int = 50) -> Iterator[List[T]]:
+    """
+    Batch an iterator into an iterator over lists of batch size.
+    """
+    iterator = iter(iterator)
+    while True:
+        batch = list(islice(iterator, batch_size))
+        if not batch:
+            return
+        yield batch
+
+
+def process_chunk(chunk: List, extractor: jmespath.parser.ParsedResult) -> List[Dict]:
+    """
+    Apply JMESPath to a chunk of JSONL data.
+    """
+    results: List[Dict] = []
+    for line in chunk:
+        data = json.loads(line)
+        extracted = extractor.search(data)
+        if extracted is not None:
+            if not isinstance(extracted, list):
+                extracted = [extracted]
+
+            try:
+                extracted_str = " ".join(set([ex for ex in extracted if isinstance(ex, str)])).strip()
+            except:
+                print(json.dumps(data, ensure_ascii=False))
+                raise
+
+            lang = detector.FindLanguage(extracted_str)
+            data["language"] = lang.language
+            data["language_is_reliable"] = lang.is_reliable
+            data["text_length"] = len(extracted_str)
+            data["data_length"] = len(line)
+            data["text_to_data_ratio"] = len(extracted_str) / len(line)
+
+            results.append(data)
+
+    return results
+
+
+def process_file(
+    input_files: str,
+    output_file: str,
+    chunk_size: int,
+    num_threads: int,
+    extractor: jmespath.parser.ParsedResult,
+):
+    """
+    Apply JMESPath to a large JSONL file in parallel.
+    input_file: path to input JSONL file
+    output_file: path to output JSONL file
+    chunk_size: number of lines to process at a time
+    num_threads: number of threads to use
+    extractor: compiled JMESPath expression to apply
+    """
+    with smart_open.open(output_file, "wt", encoding="utf-8") as writer:
+        for input_file in input_files:
+            with smart_open.open(
+                input_file, "rt", encoding="utf-8"
+            ) as reader:
+                with ThreadPoolExecutor(max_workers=num_threads) as executor:
+                    for chunk in batch_iterator(tqdm(reader), batch_size=chunk_size):
+                        if not chunk:
+                            break
+
+                        results = executor.map(process_chunk, [chunk], [extractor])
+                        for result in results:
+                            for item in result:
+                                writer.write(json.dumps(item, ensure_ascii=False))
+                                writer.write("\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Apply JMESPath to a large JSONL files in parallel."
+    )
+    parser.add_argument("input_files", help="path to input JSONL files", nargs="+")
+    parser.add_argument("output_file", help="path to output JSONL file")
+    parser.add_argument(
+        "--chunk-size",
+        type=int,
+        default=10000,
+        help="number of lines to process at a time (default: 10000)",
+    )
+    parser.add_argument(
+        "--num-threads",
+        type=int,
+        default=4,
+        help="number of threads to use (default: 4)",
+    )
+    args = parser.parse_args()
+    # TODO: itemListElement as text or Thing?
+    jmespath_expression: jmespath.parser.ParsedResult = jmespath.compile(
+        "[name, description, headline, about, tool, supply, keywords, step[].name, step[].text, step[].itemListElement[].text, "
+        + "step[].itemListElement[].itemListElement[].text, mainEntity[].name, mainEntity[].acceptedAnswer.text, "
+        + "mainEntity[].acceptedAnswer.name, mainEntity.name, mainEntity.acceptedAnswer.text, "
+        + "mainEntity.*.acceptedAnswer[].text, mainEntity[].acceptedAnswer[].text, step.itemListElement[].text, step.itemListElement[].itemListElement[].text][][]"
+    )
+
+    process_file(
+        args.input_files,
+        args.output_file,
+        args.chunk_size,
+        args.num_threads,
+        jmespath_expression,
+    )

bin/extract_relevant_structured_data.py

@@ -0,0 +1,102 @@
+from typing import Iterator, List, Dict, TypeVar
+import json
+import argparse
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+from itertools import islice
+
+import smart_open
+from tqdm import tqdm
+import jmespath
+
+T = TypeVar("T")
+
+
+def batch_iterator(iterator: Iterator[T], batch_size: int = 50) -> Iterator[List[T]]:
+    iterator = iter(iterator)
+    while True:
+        batch = list(islice(iterator, batch_size))
+        if not batch:
+            return
+        yield batch
+
+
+def process_chunk(chunk: List, extractor: jmespath.parser.ParsedResult) -> List[Dict]:
+    """
+    Apply JMESPath to a chunk of JSONL data.
+    """
+    results: List[Dict] = []
+    for line in chunk:
+        data = json.loads(line)
+        extracted = extractor.search(data)
+        if extracted is not None:
+            if not isinstance(extracted, list):
+                extracted = [extracted]
+
+            for item in extracted:
+                item["url"] = data["url"]
+                item["schema_type"] = data["schema_type"]
+                results.append(item)
+    return results
+
+
+def process_file(
+    input_file: str,
+    output_file: str,
+    chunk_size: int,
+    num_threads: int,
+    extractor: jmespath.parser.ParsedResult,
+):
+    """
+    Apply JMESPath to a large JSONL file in parallel.
+    input_file: path to input JSONL file
+    output_file: path to output JSONL file
+    chunk_size: number of lines to process at a time
+    num_threads: number of threads to use
+    extractor: compiled JMESPath expression to apply
+    """
+    with smart_open.open(input_file, "rt", encoding="utf-8") as reader, smart_open.open(
+        output_file, "wt", encoding="utf-8"
+    ) as writer:
+        with ThreadPoolExecutor(max_workers=num_threads) as executor:
+            for chunk in batch_iterator(tqdm(reader), batch_size=chunk_size):
+                if not chunk:
+                    break
+
+                results = executor.map(process_chunk, [chunk], [extractor])
+                for result in results:
+                    for item in result:
+                        writer.write(json.dumps(item, ensure_ascii=False))
+                        writer.write("\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Apply JMESPath to a large JSONL file in parallel."
+    )
+    parser.add_argument("input_file", help="path to input JSONL file")
+    parser.add_argument("output_file", help="path to output JSONL file")
+    parser.add_argument(
+        "--chunk-size",
+        type=int,
+        default=10000,
+        help="number of lines to process at a time (default: 10000)",
+    )
+    parser.add_argument(
+        "--num-threads",
+        type=int,
+        default=4,
+        help="number of threads to use (default: 4)",
+    )
+    args = parser.parse_args()
+
+    jmespath_expression: jmespath.parser.ParsedResult = jmespath.compile(
+        """metadata.*[?"@type"=='FAQPage' || "@type"=='HowTo'][]"""
+    )
+
+    process_file(
+        args.input_file,
+        args.output_file,
+        args.chunk_size,
+        args.num_threads,
+        jmespath_expression,
+    )

bin/get_seed_urls.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# download file containing urls
+curl http://webdatacommons.org/structureddata/2022-12/files/file.list > urls.txt
+
+# create output file
+touch output.txt
+
+# use parallel command to download/grep in parallel
+cat urls.txt | pv -cN Input | parallel -j 4 "curl -s {} | zcat | grep -e '<http://schema.org/FAQPage>' -e '<http://schema.org/HowTo>'" | pv -cN Output > output.txt

requirements.txt

@@ -0,0 +1,6 @@
+smart-open
+jmespath
+tqdm
+Scrapy
+extruct
+gcld3

scraper/scraper/items.py

@@ -0,0 +1,12 @@
+# Define here the models for your scraped items
+#
+# See documentation in:
+# https://docs.scrapy.org/en/latest/topics/items.html
+
+import scrapy
+
+
+class ScraperItem(scrapy.Item):
+    # define the fields for your item here like:
+    # name = scrapy.Field()
+    pass

scraper/scraper/middlewares.py

@@ -0,0 +1,103 @@
+# Define here the models for your spider middleware
+#
+# See documentation in:
+# https://docs.scrapy.org/en/latest/topics/spider-middleware.html
+
+from scrapy import signals
+
+# useful for handling different item types with a single interface
+from itemadapter import is_item, ItemAdapter
+
+
+class ScraperSpiderMiddleware:
+    # Not all methods need to be defined. If a method is not defined,
+    # scrapy acts as if the spider middleware does not modify the
+    # passed objects.
+
+    @classmethod
+    def from_crawler(cls, crawler):
+        # This method is used by Scrapy to create your spiders.
+        s = cls()
+        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
+        return s
+
+    def process_spider_input(self, response, spider):
+        # Called for each response that goes through the spider
+        # middleware and into the spider.
+
+        # Should return None or raise an exception.
+        return None
+
+    def process_spider_output(self, response, result, spider):
+        # Called with the results returned from the Spider, after
+        # it has processed the response.
+
+        # Must return an iterable of Request, or item objects.
+        for i in result:
+            yield i
+
+    def process_spider_exception(self, response, exception, spider):
+        # Called when a spider or process_spider_input() method
+        # (from other spider middleware) raises an exception.
+
+        # Should return either None or an iterable of Request or item objects.
+        pass
+
+    def process_start_requests(self, start_requests, spider):
+        # Called with the start requests of the spider, and works
+        # similarly to the process_spider_output() method, except
+        # that it doesn’t have a response associated.
+
+        # Must return only requests (not items).
+        for r in start_requests:
+            yield r
+
+    def spider_opened(self, spider):
+        spider.logger.info('Spider opened: %s' % spider.name)
+
+
+class ScraperDownloaderMiddleware:
+    # Not all methods need to be defined. If a method is not defined,
+    # scrapy acts as if the downloader middleware does not modify the
+    # passed objects.
+
+    @classmethod
+    def from_crawler(cls, crawler):
+        # This method is used by Scrapy to create your spiders.
+        s = cls()
+        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
+        return s
+
+    def process_request(self, request, spider):
+        # Called for each request that goes through the downloader
+        # middleware.
+
+        # Must either:
+        # - return None: continue processing this request
+        # - or return a Response object
+        # - or return a Request object
+        # - or raise IgnoreRequest: process_exception() methods of
+        #   installed downloader middleware will be called
+        return None
+
+    def process_response(self, request, response, spider):
+        # Called with the response returned from the downloader.
+
+        # Must either;
+        # - return a Response object
+        # - return a Request object
+        # - or raise IgnoreRequest
+        return response
+
+    def process_exception(self, request, exception, spider):
+        # Called when a download handler or a process_request()
+        # (from other downloader middleware) raises an exception.
+
+        # Must either:
+        # - return None: continue processing this exception
+        # - return a Response object: stops process_exception() chain
+        # - return a Request object: stops process_exception() chain
+        pass
+
+    def spider_opened(self, spider):
+        spider.logger.info('Spider opened: %s' % spider.name)

scraper/scraper/pipelines.py

@@ -0,0 +1,13 @@
+# Define your item pipelines here
+#
+# Don't forget to add your pipeline to the ITEM_PIPELINES setting
+# See: https://docs.scrapy.org/en/latest/topics/item-pipeline.html
+
+
+# useful for handling different item types with a single interface
+from itemadapter import ItemAdapter
+
+
+class ScraperPipeline:
+    def process_item(self, item, spider):
+        return item

scraper/scraper/settings.py

@@ -0,0 +1,92 @@
+# Scrapy settings for scraper project
+#
+# For simplicity, this file contains only settings considered important or
+# commonly used. You can find more settings consulting the documentation:
+#
+#     https://docs.scrapy.org/en/latest/topics/settings.html
+#     https://docs.scrapy.org/en/latest/topics/downloader-middleware.html
+#     https://docs.scrapy.org/en/latest/topics/spider-middleware.html
+
+BOT_NAME = 'scraper'
+
+SPIDER_MODULES = ['scraper.spiders']
+NEWSPIDER_MODULE = 'scraper.spiders'
+
+
+# Crawl responsibly by identifying yourself (and your website) on the user-agent
+#USER_AGENT = 'scraper (+http://www.yourdomain.com)'
+
+# Obey robots.txt rules
+ROBOTSTXT_OBEY = True
+
+# Configure maximum concurrent requests performed by Scrapy (default: 16)
+#CONCURRENT_REQUESTS = 32
+
+# Configure a delay for requests for the same website (default: 0)
+# See https://docs.scrapy.org/en/latest/topics/settings.html#download-delay
+# See also autothrottle settings and docs
+#DOWNLOAD_DELAY = 3
+# The download delay setting will honor only one of:
+#CONCURRENT_REQUESTS_PER_DOMAIN = 16
+#CONCURRENT_REQUESTS_PER_IP = 16
+
+# Disable cookies (enabled by default)
+#COOKIES_ENABLED = False
+
+# Disable Telnet Console (enabled by default)
+#TELNETCONSOLE_ENABLED = False
+
+# Override the default request headers:
+#DEFAULT_REQUEST_HEADERS = {
+#   'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+#   'Accept-Language': 'en',
+#}
+
+# Enable or disable spider middlewares
+# See https://docs.scrapy.org/en/latest/topics/spider-middleware.html
+#SPIDER_MIDDLEWARES = {
+#    'scraper.middlewares.ScraperSpiderMiddleware': 543,
+#}
+
+# Enable or disable downloader middlewares
+# See https://docs.scrapy.org/en/latest/topics/downloader-middleware.html
+#DOWNLOADER_MIDDLEWARES = {
+#    'scraper.middlewares.ScraperDownloaderMiddleware': 543,
+#}
+
+# Enable or disable extensions
+# See https://docs.scrapy.org/en/latest/topics/extensions.html
+#EXTENSIONS = {
+#    'scrapy.extensions.telnet.TelnetConsole': None,
+#}
+
+# Configure item pipelines
+# See https://docs.scrapy.org/en/latest/topics/item-pipeline.html
+#ITEM_PIPELINES = {
+#    'scraper.pipelines.ScraperPipeline': 300,
+#}
+
+# Enable and configure the AutoThrottle extension (disabled by default)
+# See https://docs.scrapy.org/en/latest/topics/autothrottle.html
+#AUTOTHROTTLE_ENABLED = True
+# The initial download delay
+#AUTOTHROTTLE_START_DELAY = 5
+# The maximum download delay to be set in case of high latencies
+#AUTOTHROTTLE_MAX_DELAY = 60
+# The average number of requests Scrapy should be sending in parallel to
+# each remote server
+#AUTOTHROTTLE_TARGET_CONCURRENCY = 1.0
+# Enable showing throttling stats for every response received:
+#AUTOTHROTTLE_DEBUG = False
+
+# Enable and configure HTTP caching (disabled by default)
+# See https://docs.scrapy.org/en/latest/topics/downloader-middleware.html#httpcache-middleware-settings
+#HTTPCACHE_ENABLED = True
+#HTTPCACHE_EXPIRATION_SECS = 0
+#HTTPCACHE_DIR = 'httpcache'
+#HTTPCACHE_IGNORE_HTTP_CODES = []
+#HTTPCACHE_STORAGE = 'scrapy.extensions.httpcache.FilesystemCacheStorage'
+
+# Set settings whose default value is deprecated to a future-proof value
+REQUEST_FINGERPRINTER_IMPLEMENTATION = '2.7'
+TWISTED_REACTOR = 'twisted.internet.asyncioreactor.AsyncioSelectorReactor'

scraper/scraper/spiders/__init__.py

@@ -0,0 +1,4 @@
+# This package will contain the spiders of your Scrapy project
+#
+# Please refer to the documentation for information on how to create and manage
+# your spiders.

scraper/scraper/spiders/webdatacommons_org.py

@@ -0,0 +1,81 @@
+from typing import Dict
+import pathlib
+import logging
+
+import scrapy
+import extruct
+from w3lib.html import get_base_url
+
+
+class WebDataCommonsSpider(scrapy.spiders.Spider):
+    """
+    Spider for crawling pages with structured data found in the web-data-commons project.
+    http://webdatacommons.org
+
+    You can later extract the required structured information using 
+    metadata.*[?"@type"=='FAQPage' || "@type"=='HowTo'][] code in jmespath
+    """
+
+    allowed_domains = ["*"]
+    name = "webdatacommons_org"
+    custom_settings = {
+        "HTTPCACHE_ENABLED": True,
+        "CONCURRENT_REQUESTS": 100,
+        "CONCURRENT_ITEMS": 100,
+        "CONCURRENT_REQUESTS_PER_DOMAIN": 3,
+        "AUTOTHROTTLE_ENABLED": False,
+        "RETRY_TIMES": 1,
+        "DOWNLOAD_DELAY": 0,
+    }
+
+    def parse(self, response):
+        base_url: str = get_base_url(response.text, response.url)
+        try:
+            metadata: Dict = extruct.extract(
+                htmlstring=response.text, base_url=base_url, uniform=True
+            )
+            yield {
+                "url": response.url,
+                "metadata": metadata,
+                "schema_type": response.meta["schema_type"],
+            }
+        except Exception as e:
+            logging.error(f"Error while parsing {response.url}: {e}")
+
+    def start_requests(self):
+        """
+        Start crawling from the index file, created with the following command (be careful, this command downloads 1.6TB of data):
+        #!/bin/bash
+
+        # download file containing urls
+        curl http://webdatacommons.org/structureddata/2022-12/files/file.list > urls.txt
+
+        # create output file
+        touch output.txt
+
+        # use parallel command to download/grep in parallel
+        cat urls.txt | pv -cN Input | parallel -j 4 "curl -s {} | zcat | grep -e '<http://schema.org/FAQPage>' -e '<http://schema.org/HowTo>'" | pv -cN Output > output.txt
+
+        """
+
+        assert self.settings.get(
+            "WEB_DATA_COMMONS"
+        ), "You should specify WEB_DATA_COMMONS setting as a path to a file or url in order run that spider"
+
+        index_file = pathlib.Path(self.settings["WEB_DATA_COMMONS"])
+
+        assert (
+            index_file.exists()
+        ), f"Local file with index '{index_file}' doesn't exist"
+
+        with index_file.open("r") as fp:
+            for l in map(str.strip, fp):
+                _, _, schema_type, url, _ = l.split(" ", 4)
+                schema_type = schema_type.strip("<>")
+                url = url.strip("<>")
+                if "://" not in url:
+                    url = "https://" + url
+
+                yield scrapy.Request(
+                    url, callback=self.parse, meta={"schema_type": schema_type}
+                )

scraper/scrapy.cfg

@@ -0,0 +1,11 @@
+# Automatically created by: scrapy startproject
+#
+# For more information about the [deploy] section see:
+# https://scrapyd.readthedocs.io/en/latest/deploy.html
+
+[settings]
+default = scraper.settings
+
+[deploy]
+#url = http://localhost:6800/
+project = scraper