archival.ArchiveBox/archivebox/extractors

Truths about Extractors:

• Snapshot worker should handle:

  • opening chrome tab for the snapshot > ./cdp_ws.sock
  • waiting for the page to load
  • emitting the ARCHIVING events:
    • SNAPSHOT_SETUP
    • SNAPSHOT_STARTED
    • SNAPSHOT_BEFORE_BROWSER_LAUNCH
    • SNAPSHOT_AFTER_BROWSER_LAUNCH
    • SNAPSHOT_BEFORE_PAGE_LOAD
    • SNAPSHOT_AFTER_PAGE_LOAD
    • SNAPSHOT_AFTER_NETWORK_IDLE2
  • extracting the page title
  • extracting all the outlinks
  • extracting all the search texts

• Extractor Worker should handle:

  • making sure any binaries the extractor depends on are installed and loaded
  • creating a new temporary working directory under the snapshot dir to hold extractor output
  • setting up a timer signal to kill the extractor if it runs too long
  • passing the extractor the URLs, temporary working directory, and config dict of options
  • running the extractor in a shell subprocess and collecting stdout/stderr
  • capturing the extractor's exit code
  • if extractor exits with 29 (RetryError), it should set the status to 'BACKOFF' and set retry_at to a datetime in the future
  • if extractor exits with 50 (NotApplicable), it should set the status to 'SKIPPED', and set retry_at to None
  • setting the correct permissions and ownership on all the output files
  • generating the merkle tree of all the output files and their hashes
  • generating a thumbnail of the main output (or collecting one provided by the extractor)
  • detecting any special outputs files that need to be parsed for other parts of the system (content-types? )
    • metadata.json -> ArchiveResult.output_json
    • outlinks.jsonl -> ArchiveResult.output_links
    • search_texts.txt -> ArchiveResult.index_texts
    • .merkle.json -> ArchiveResult.output_files
    • videos.jsonl -> ArchiveResult.output_videos
    • audios.jsonl -> ArchiveResult.output_audios
    • images.jsonl -> ArchiveResult.output_images
    • htmls.jsonl -> ArchiveResult.output_htmls
  • saving all the result metadata to the ArchiveResult in the database

• extractor takes a URL as a CLI arg, a current working directory, and env var options (or config benedict)

  • extractor should be able to see outputs in snapshot dir from extractors that ran before it
  • extractor should exit 0 for success, or non-zero for failure
  • extractor should exit 29 (RetryError) if it should be retried later (e.g. expected input is not ready yet, or got ratelimited, etc.)
  • extractor should exit 50 (NotApplicable) if it is unable to handle the given URL (e.g. if url is a file:/// but extractor only accepts https://youtube.com/*)
  • extractor should save output binary data files to the current working directory
  • extractor should output any logs text / progress to stdout, and error text to stderr
  • extractor should append any events it wants to emit as JSONL to the snapshot_dir/events.jsonl file. e.g.:
    • EXTRACTED_OUTLINK {"url": "https://example.com", "title": "Example Domain", "selector": "a", "tags": ["link"], "timestamp": 1717305600}
    • EXTRACTED_SEARCH_TEXT {"path": "articletext.txt", "record": archiveresult.id}
    • EXTRACTED_HTML {"path": "index.html", "output_size": 123456, "mimetype": "text/html"}
    • EXTRACTED_SCREENSHOT {"path": "screenshot.png", "output_size": 123456, "mimetype": "image/png"}
    • EXTRACTED_IMAGE {"path": "favicon.ico", "output_size": 123456, "mimetype": "image/x-icon"}
    • EXTRACTED_VIDEO {"path": "media/mainvideo.mp4", "output_size": 123456, "mimetype": "video/mp4"}
    • EXTRACTED_READABILITY {"path": "readability.txt", "output_size": 123456, "mimetype": "text/plain"}
    • ...
  • extractor should save any JSON metadata detected to a special metadata.json file
  • extractor should create an index.html or symlink index.html to the main output file that the user will see
  • extractor should return the following str:
    • output_uri: str | None -> the URI of the main file or URL produced by the extractor (e.g. file:///path/to/index.html, https://web.archive.org/web/https:/..., file://./screenshot.png)
    • output_text: str | None -> the text content of the main output, if extractor primarily returns text
    • output_json: dict | None -> the structured Object returned by the extractor, if its main output is a JSON object
    • output_links: list[dict] -> a list of all the outlink URLs found during extraction {url, title, selector, tags, timestamp}
    • output_files: list[dict] -> the list of all the output files {path, hash_sha256, hash_blake3, size, mimetype}
    • output_thumbnail: str | None -> the URI of the thumbnail file, if any was created
    • output_html: str | None -> the path to the main HTML file if the extractor produces HTML

SNAPSHOT ARCHIVING EVENTS:

• SNAPSHOT_QUEUED
• SNAPSHOT_SETUP
• SNAPSHOT_STARTED
• SNAPSHOT_BEFORE_BROWSER_LAUNCH
• SNAPSHOT_AFTER_BROWSER_LAUNCH
• SNAPSHOT_BEFORE_PAGE_LOAD
• SNAPSHOT_AFTER_PAGE_LOAD
• SNAPSHOT_AFTER_NETWORK_IDLE2
• SNAPSHOT_BEFORE_SCREENSHOT
• SNAPSHOT_AFTER_SCREENSHOT
• SNAPSHOT_EXTRACT_ASYNC
• SNAPSHOT_EXTRACT_SYNC
• SNAPSHOT_EXTRACT_SHELL
• EXTRACTED_SCREENSHOT
• EXTRACTED_HEADERS
• EXTRACTED_HTML
• EXTRACTED_OUTLINKS
• EXTRACTED_DOWNLOADS
• EXTRACTED_AUDIO
• EXTRACTED_VIDEO
• EXTRACTED_IMAGE
• EXTRACTED_PDF
• EXTRACTED_TEXT
• EXTRACTED_SEARCH_TEXT
• SNAPSHOT_FINISHED
• SNAPSHOT_FAILED
• SNAPSHOT_RETRY

• SNAPSHOT_SKIPPED

• Standardized Output files:

  • .merkle.json -> ArchiveResult.output_files
  • outlinks.jsonl -> ArchiveResult.output_links
  • search_texts.txt -> ArchiveResult.index_texts
  • metadata.json -> ArchiveResult.output_json
  • thumbnail.png -> ArchiveResult.output_thumbnail
  • index.html -> ArchiveResult.output_html

class FaviconResult(ArchiveResult):

dependencies: ClassVar[list[str]] = ['yt-dlp', 'curl', 'ffmpeg']
context: ClassVar[str] = 'shell' | 'puppeteer'

# snapshot: Snapshot
# extractor: str
# start_ts: datetime
# end_ts: datetime
# exit_code: int
# stdout: str
# stderr: str
# cmd: list[str]
# cmd_version: str
# config: dict
# status: str
# retry_at: datetime | None

# iface: NetworkInterface | None
# machine: Machine | None
# persona: Persona | None

class Meta:
    verbose_name: str = 'Favicon'
    verbose_name_plural: str = 'Favicons'

def save(...):
    # if not self.output_files:
    #     self.output_files = self.get_output_files()

def get_cmd(self) -> list[str]:
    binary = archivebox.pm.hook.get_BINARY('curl')
    return [binary.name, '-fsSL', '-o', 'favicon.ico', domain_only(self.snapshot.url) + '/favicon.ico']

def get_cmd_version(self) -> str:
    binary = archivebox.pm.hook.get_BINARY('curl')
    return binary.version

def get_output_files(self) -> list[dict]:
    output_files = {}
    output_dirs = {}
    for path in self.OUTPUT_DIR.rglob('*'):
        if path.is_file():
            output_files[str(path.relative_to(self.OUTPUT_DIR))] = {
                'path': str(path.relative_to(self.OUTPUT_DIR)),
                'hash_sha256': hash_file(path, 'sha256'),
                'hash_blake3': hash_file(path, 'blake3'),
                'size': path.stat().st_size,
                'mimetype': detect_mimetype(path),
            })
        else:
            output_dirs[str(path.relative_to(self.OUTPUT_DIR))] = {
                'path': str(path.relative_to(self.OUTPUT_DIR)),
                'hash_sha256': None,
                'hash_blake3': None,
                'size': None,
                'mimetype': 'inode/directory',
            })

    for dir in output_dirs.values():
        subfiles = {path: file for path, file in output_files.items() if path.startswith(dir['path'])}
        dir['hash_sha256'] = hash_dir(dir['path'], 'sha256', subfiles)
        dir['hash_blake3'] = hash_dir(dir['path'], 'blake3', subfiles)
        dir['size'] = sum(file['size'] for file in subfiles.values())

    return {**output_files, **output_dirs}

def get_output_text(self) -> str | None:
    return 'favicon.ico'

def get_indexable_text(self) -> str | None:
    return ''

def get_thumbnail(self) -> str | None:
    width, height = get_image_dimensions(self.OUTPUT_DIR / 'favicon.png')
    return {
        'path': self.favicon_uri,
        'abspath': self.OUTPUT_DIR / self.favicon_uri,
        'width': width,
        'height': height,
        'mimetype': 'image/png',
        'extension': 'png',
    }

def get_icon(self) -> str | None:
    return self.get_thumbnail()


def migrate_from_0_7_2(self) -> None:
    """Migrate output_dir generated by ArchiveBox <= 0.7.2 to current version"""
    print(f'{type(self).__name__}[{self.ABID}].migrate_from_0_7_2()')
    # move favicon.png -> self.OUTPUT_DIR / favicon.png

Migration:

- For each ArchiveResult:
    - move it into subdir under name of the extractor + rename if needed
    - calculate merkle tree of all files in the output_dir
    - save the merkle tree to .merkle.json
    - symlink old location -> new location for backwards compatibility
- For each Snapshot:
    - move data/archive/<timestamp> -> data/archive/snapshots/<abid>
    - symlink old location -> new location        

class TitleResult(ArchiveResult):

dependencies: ClassVar[list[str]] = ['chrome', 'puppeteer']
context: ClassVar[str] = 'puppeteer'