The_Great_Archive/ArchiveBox
1
0
Fork 0
mirror of https://github.com/ArchiveBox/ArchiveBox.git synced 2026-09-12 19:50:57 +05:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

chore: remove docs/ in prep for git subtree bootstrap from wiki repo

Browse Source 
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Nick Sweeting 2026-05-31 02:23:13 -07:00
parent 6230d0297b
commit da5d6d6bdd
No known key found for this signature in database
193 changed files with 0 additions and 51149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
docs/.gitignore vendored
View File

@ -1,8 +0,0 @@
_build/
.venv
venv/
.env
.DS_Store
queue.sqlite3
index.sqlite3

50
docs/.mkdocs.unused/gen_docs_refs.py
View File

@ -1,50 +0,0 @@
"""Generate the code reference pages and navigation."""
from pathlib import Path
import mkdocs_gen_files
nav = mkdocs_gen_files.Nav()
mod_symbol = '<code class="doc-symbol doc-symbol-nav doc-symbol-module"></code>'
packages_dir = Path(__file__).parent
doc_root = packages_dir / "docs"
for path in sorted((packages_dir / "archivebox").rglob("*.py")):
module_path = path.relative_to(packages_dir).with_suffix("")
doc_path = path.relative_to(packages_dir).with_suffix(".md")
full_doc_path = doc_root / "reference" / doc_path
if (
"management" in str(module_path)
or "vendor" in str(module_path)
or "machine" in str(module_path)
or "migrations" in str(module_path)
or "plugins" in str(module_path)
):
continue
parts = tuple(module_path.parts)
if parts[-1] == "__init__":
parts = parts[:-1]
doc_path = doc_path.with_name("index.md")
full_doc_path = full_doc_path.with_name("index.md")
elif parts[-1].startswith("_"):
continue
full_doc_path = full_doc_path.relative_to(packages_dir)
# import ipdb; ipdb.set_trace()
nav_parts = [f"{mod_symbol} {part}" for part in parts]
nav[tuple(nav_parts)] = doc_path.as_posix()
with mkdocs_gen_files.open(full_doc_path, "w") as fd:
ident = ".".join(parts)
fd.write(f"---\ntitle: {ident}\n---\n\n::: {ident}")
mkdocs_gen_files.set_edit_path(full_doc_path, path.relative_to(packages_dir))
with mkdocs_gen_files.open(doc_root / "reference" / "SUMMARY.md", "w") as nav_file:
nav_file.writelines(nav.build_literate_nav())

32
docs/.mkdocs.unused/mkdocs.yml
View File

@ -1,32 +0,0 @@
site_name: ArchiveBox
site_url: https://github.com/ArchiveBox/ArchiveBox
theme:
name: material
plugins:
- exclude:
glob:
- archivebox/vendor
- data/
- data*/
- '*.sqlite3'
- deb_dist/
- brew_dist/
- dist/
- search
- autorefs
- mkdocstrings:
handlers:
python:
options:
show_submodules: true
import:
- url: https://docs.python-requests.org/en/master/objects.inv
domains: [std, py]
- gen-files:
scripts:
- gen_docs_refs.py

45
docs/.readthedocs.yaml
View File

@ -1,45 +0,0 @@
# Read the Docs configuration file for ArchiveBox docs
# See https://docs.readthedocs.io/en/stable/config-file/v2.html
#
# RTD Version Strategy:
# - "stable" alias -> latest tag with no pre-release suffix (PEP 440)
# - "latest" alias -> default branch (master) = current dev docs
# - Tagged versions (v0.9.10, v0.8.6, v0.7.3, etc.) build from git tags
#
# This is fully automatic via PEP 440 version detection:
# - pyproject.toml version = "0.9.10" -> stable release
# - pyproject.toml version = "0.9.10rc1" -> pre-release (dev)
# - pyproject.toml version = "0.9.10.dev1" -> dev release
# - RTD "latest" from master branch -> always dev
#
# RTD Admin Settings (configure in RTD dashboard once):
# - Default version: "stable"
# - "latest" version: visible, shows dev docs with warning banner
# - Enable "build on tag push" for automatic versioned releases
#
# To publish a new stable release:
# 1. Set version = "0.9.10" in pyproject.toml (no rc/dev/alpha suffix)
# 2. git tag v0.9.10 && git push wiki v0.9.10
# 3. RTD auto-builds and "stable" alias updates to this version
#
# To access dev docs:
# https://archivebox.readthedocs.io/en/latest/
version: 2
build:
os: ubuntu-24.04
tools:
python: "3.13"
sphinx:
configuration: conf.py
python:
install:
- requirements: requirements.txt
# Install archivebox so autodoc2 can introspect the source
- method: pip
path: ..
extra_requirements:
- dev

200
docs/ArchiveBox-Architecture-Diagrams.md
View File

@ -1,200 +0,0 @@
# ArchiveBox Architecture Diagrams
## High-Level System Execution Flow
```mermaid
stateDiagram-v2
archivebox.cli.main(sys.argv)
state Supervisord {
Scheduler
state Orchestrator {
[*] --> TICK
TICK --> SPAWN_ACTORS: queued > 0
SPAWN_ACTORS --> TICK
TICK --> IDLE: queued == 0
IDLE --> TICK: 1s
}
}
note left of archivebox.cli.main(sys.argv)
archivebox entrypoint
end note
state "archivebox.cli.SUBCOMMAND" as MAIN_THREAD
archivebox.cli.main(sys.argv) --> run_subcommand(sys.argv)
run_subcommand(sys.argv) --> setup_django()
setup_django() --> Supervisord: spawns in background
setup_django() --> MAIN_THREAD: runs in foreground
MAIN_THREAD --> archivebox.main.SUBCOMMAND
archivebox.main.SUBCOMMAND --> Storage: add_to_queue()
state Actors {
CrawlActor --> Crawl: tick()
SnapshotActor --> Snapshot: tick()
ArchiveResultActors --> ArchiveResult: tick()
}
state "State Machines" as JOBS {
state Crawl {
state "QUEUED" as CRAWL_QUEUED
state "STARTED" as CRAWL_STARTED
state "SEALED" as CRAWL_SEALED
CRAWL_QUEUED --> CRAWL_STARTED: create_root_snapshot()
CRAWL_STARTED --> CRAWL_SEALED: is_finished
}
state Snapshot {
state "QUEUED" as SNAP_QUEUED
state "STARTED" as SNAP_STARTED
state "SEALED" as SNAP_SEALED
SNAP_QUEUED --> SNAP_STARTED: create_pending_archiveresults()
SNAP_STARTED --> SNAP_SEALED: is_finished
}
state ArchiveResult {
QUEUED --> STARTED: run_extractor()
STARTED --> BACKOFF: is_temp_error
BACKOFF --> STARTED: is_retry_past
STARTED --> FAILED: is_fatal_error
STARTED --> SUCCEEDED: is_succeded
}
note right of ArchiveResult
exec_crome()
end note
note right of ArchiveResult
exec_wget()
end note
note right of ArchiveResult
exec_curl()
end note
note right of ArchiveResult
... other extractor subprocesses ...
end note
}
state Storage {
state "DB" as SQLITE_DB
sources/
archive/
state "index.json" as INDEX_JSONS
}
Storage: Storage
Orchestrator --> Actors: spawns subprocesses
Crawl --> Snapshot: create_root_snapshot()
Snapshot --> ArchiveResult: create_pending_archiveresults()
Crawl --> Storage: .save()
Snapshot --> Storage: .save()
ArchiveResult --> Storage: .save()
Storage --> Actors: get_queue()
```
---
## State Diagrams for Main Models
### `Crawl`
- `crawls/models.py`: `Crawl`
- `crawls/statemachines.py`: `CrawlMachine`
```mermaid
stateDiagram-v2
STARTED --> SEALED: tick [is_finished]
STARTED --> STARTED: tick [!is_finished]
QUEUED --> STARTED: tick [can_start]
QUEUED --> QUEUED: tick [!can_start]
note left of QUEUED
Crawl created
end note
note right of STARTED
create_root_snapshot()
crawl.retry_at = now + 5s
end note
```
## `Snapshot`
- `core/models.py`: `Snapshot`
- `core/statemachines.py`: `SnapshotMachine`
```mermaid
stateDiagram-v2
STARTED --> SEALED: tick [is_finished]
STARTED --> STARTED: tick [!is_finished]
QUEUED --> STARTED: tick [can_start]
QUEUED --> QUEUED: tick [!can_start]
note left of QUEUED
Snapshot created
end note
note right of STARTED
create_pending_archiveresults(extractors)
snapshot.retry_at = now + 60s
end note
```
### `ArchiveResult`
- `core/models.py`: `ArchiveResult`
- `core/statemachines.py`: `ArchiveResultMachine`
<img width="1740" alt="image" src="https://github.com/user-attachments/assets/23d596ab-6c8a-440a-b49b-a2432f37abb3">
```mermaid
stateDiagram-v2
QUEUED --> QUEUED: tick [!can_start]
QUEUED --> STARTED: tick [can_start]
STARTED --> STARTED: tick [!is_finished]
STARTED --> BACKOFF: tick [is_backoff]
STARTED --> FAILED: tick [is_failed]
STARTED --> SUCCEEDED: tick [is_succeeded]
BACKOFF --> BACKOFF: tick [!can_start]
BACKOFF --> STARTED: tick [can_start]
note left of QUEUED
ArchiveResult created
end note
note left of STARTED
start_ts = now
retry_at = now + 60s
create_output_dir()
run_extractor()
end note
note right of BACKOFF
retry_at = now + 60s
end note
note right of SUCCEEDED
end_ts = now
retry_at = None
end note
note right of FAILED
end_ts = now
retry_at = None
end note
```

122
docs/Changelog.md
View File

@ -1,122 +0,0 @@
# Changelog
▶️ *If you're having an issue with a breaking change, or migrating your data between versions, open an [issue](https://github.com/ArchiveBox/ArchiveBox/issues) to get help.*
**`ArchiveBox` was previously named `Pocket Archive Stream` and then `Bookmark Archiver`.**
<br/>
<div align="center">
**`THIS PAGE HAS BEEN MOVED:` See the [releases](https://github.com/ArchiveBox/ArchiveBox/releases) page for versioned source downloads and full changelog.**
🍰 Many thanks to our 100+ contributors and everyone in the web archiving community! 🏛
</div>
<details>
<summary>Expand old release notes...</summary>
---
- v0.4.9 released
- `pip install archivebox` https://pypi.org/project/archivebox/
- `docker run archivebox/archivebox` https://hub.docker.com/r/archivebox/archivebox
- https://archivebox.readthedocs.io/en/latest/
- https://github.com/ArchiveBox/ArchiveBox/releases
- easy migration from previous versions
```bash
cd path/to/your/archive/folder
archivebox init
archviebox add 'https://example.com'
archviebox add 'https://getpocket.com/users/USERNAME/feed/all' --depth=1
```
- full transition to Django Sqlite DB with migrations (making upgrades between versions much safer now)
- maintains an intuitive and helpful CLI that's backwards-compatible with all previous archivebox data versions
- uses argparse instead of hand-written CLI system: see `archivebox/cli/archivebox.py`
- new subcommands-based CLI for `archivebox` (see below)
- new Web UI with pagination, better search, filtering, permissions, and more
- 30+ assorted bugfixes, new features, and tickets closed
- for more info, see: https://github.com/ArchiveBox/ArchiveBox/releases/tag/v0.4.9
---
- v0.2.4 released
- better archive corruption guards (check structure invariants on every parse & save)
- remove title prefetching in favor of new FETCH_TITLE archive method
- slightly improved CLI output for parsing and remote url downloading
- re-save index after archiving completes to update titles and urls
- remove redundant derivable data from link json schema
- markdown link parsing support
- faster link parsing and better symbol handling using a new compiled URL_REGEX
---
- v0.2.3 released
- fixed issues with parsing titles including trailing tags
- fixed issues with titles defaulting to URLs instead of attempting to fetch
- fixed issue where bookmark timestamps from RSS would be ignored and current ts used instead
- fixed issue where ONLY_NEW would overwrite existing links in archive with only new ones
- fixed lots of issues with URL parsing by using `urllib.parse` instead of hand-written lambdas
- ignore robots.txt when using wget (ssshhh don't tell anyone 😁)
- fix RSS parser bailing out when there's whitespace around XML tags
- fix issue with browser history export trying to run ls on wrong directory
---
- v0.2.2 released
- Shaarli RSS export support
- Fix issues with plain text link parsing including quotes, whitespace, and closing tags in URLs
- add USER_AGENT to archive.org submissions so they can track archivebox usage
- remove all icons similar to archive.org branding from archive UI
- hide some of the noisier youtubedl and wget errors
- set permissions on youtubedl media folder
- fix chrome data dir incorrect path and quoting
- better chrome binary finding
- show which parser is used when importing links, show progress when fetching titles
---
- v0.2.1 released with new logo
- ability to import plain lists of links and almost all other raw filetypes
- WARC saving support via wget
- Git repository downloading with git clone
- Media downloading with youtube-dl (video, audio, subtitles, description, playlist, etc)
---
- v0.2.0 released with new name
- [renamed](https://github.com/ArchiveBox/ArchiveBox/issues/108) from **Bookmark Archiver** -> **ArchiveBox**
---
- v0.1.0 released
- support for browser history exporting added with `./bin/archivebox-export-browser-history`
- support for chrome `--dump-dom` to output full page HTML after JS executes
---
- v0.0.3 released
- support for chrome `--user-data-dir` to archive sites that need logins
- fancy individual html & json indexes for each link
- smartly append new links to existing index instead of overwriting
---
- v0.0.2 released
- proper HTML templating instead of format strings (thanks to https://github.com/bardisty!)
- refactored into separate files, wip audio & video archiving
---
- v0.0.1 released
- Index links now work without nginx url rewrites, archive can now be hosted on github pages
- added setup.sh script & docstrings & help commands
- made Chromium the default instead of Google Chrome (yay free software)
- added [env-variable](https://github.com/ArchiveBox/ArchiveBox/pull/25) configuration (thanks to https://github.com/hannah98!)
- renamed from **Pocket Archive Stream** -> **Bookmark Archiver**
- added [Netscape-format](https://github.com/ArchiveBox/ArchiveBox/pull/20) export support (thanks to https://github.com/ilvar!)
- added [Pinboard-format](https://github.com/ArchiveBox/ArchiveBox/pull/7) export support (thanks to https://github.com/sconeyard!)
- front-page of HN, oops! apparently I have users to support now :grin:?
- added Pocket-format export support
---
- v0.0.0 released: created Pocket Archive Stream 2017/05/05
</details>

207
docs/Chromium-Install.md
View File

@ -1,207 +0,0 @@
# Chrome / Chromium Setup
By default, ArchiveBox looks for any existing installed version of Chrome/Chromium and uses it if found. You can optionally install a specific version and set the environment variable `CHROME_BINARY` to force ArchiveBox to use that one, e.g.:
- `CHROME_BINARY=google-chrome-beta`
- `CHROME_BINARY=/usr/bin/chromium-browser`
- `CHROME_BINARY='/Applications/Chromium.app/Contents/MacOS/Chromium'`
- `CHROME_BINARY='~/Library/Caches/ms-playwright/chromium-857950/chrome-mac/Chromium.app/Contents/MacOS/Chromium'`
If you don't already have Chrome installed, I recommend installing Chromium instead of Google Chrome, as it's the open-source fork of Chrome that doesn't send as much tracking data to Google.
**Check for existing Chrome/Chromium install:**
<img src="https://imgur.zervice.io/FxFoIMH.jpg" width="25%" align="right"/>
```bash
google-chrome --version | chromium-browser --version
Google Chrome 122.0.6261.49 beta # should be >v111
```
## Installing Chromium
### ⭐️ Any OS (recommended)
[`playwright`](https://playwright.dev/python/docs/browsers) (by the Microsoft team) and [`puppeteer`](https://github.com/puppeteer/puppeteer) (by the Google team) are two options to get stable, repeatable Chromium distributions on many OSs.
```bash
pip install --upgrade --ignore-installed playwright
playwright install --with-deps chromium
# alternatively use puppeteer to get Chromium instead of playwright:
npm install puppeteer
```
### macOS
If you already have a Chrome app installed like `/Applications/Chromium.app`, you don't need to run this.
```bash
brew install --cask chromium
```
### Ubuntu/Debian
If you already have `chromium-browser` >= v111 installed (run `chromium-browser --version`, you don't need to run this.
```bash
sudo apt update
sudo apt install chromium-browser
# or on some systems:
sudo apt install chromium
```
## Installing Google Chrome
### macOS
If you already have `/Applications/Google Chrome.app`, you don't need to run this.
```bash
brew install --cask google-chrome
```
### Ubuntu/Debian
If you already have `google-chrome` >= v111 installed (run `google-chrome --version`, you don't need to run this.
```bash
wget -q -O - 'https://dl-ssl.google.com/linux/linux_signing_key.pub' | sudo apt-key add -
echo 'deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main' | sudo tee /etc/apt/sources.list.d/google-chrome.list
sudo apt update
sudo apt install -y google-chrome
```
## Troubleshooting Chromium Install
If you encounter problems setting up Google Chrome or Chromium, see the [Troubleshooting](https://github.com/ArchiveBox/ArchiveBox/wiki/Troubleshooting#chromiumgoogle-chrome) page.
---
# Setting Up a Chromium User Profile
You may choose to set up a Chrome/Chromium user profile in order to use your cookies/sessions to log into sites behind authentication/paywall during archiving.
*Note: not all extractors use Chrome (e.g. `wget`, `mercury`, `media`), so [`COOKIES_FILE`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration/#cookies_file) should be set up as well after this.*
> [!WARNING]
> **We strongly recommend you use [separate burner credentials dedicated to archiving](https://docs.sweeting.me/s/cookie-dilemma),** e.g. don't provide cookies for your normal daily Facebook/Instagram/Google/etc. accounts as server responses and page content will often contain your name/email/PII, session cookies, private tokens, etc. which then get preserved in your snapshots for eternity.
>
> Future viewers of your archive may be able to use any reflected archived session tokens to log in as you, or at the very least, associate the content with your real identity. Even if this tradeoff seems acceptable now or you plan to keep your archive data private, you may want to share a snapshot with others in the future, and snapshots are very hard to sanitize/anonymize after-the-fact!
>
> For this reason, it's best to set up dedicated fake profile accounts for each site you want to archive, and consider them burned if you ever share any of your archived snapshots of those sites with untrusted people.
<a name="docker-setup"></a>
<a name="Docker-Setup"></a>
### Docker VNC Setup
If using ArchiveBox in Docker, the easiest way to set up session credentials is by remote controlling the ArchiveBox Chrome browser over VNC, and using it to log in to the sites you want to save.
1. Enable the `novnc` server using these settings in your `docker-compose.yml`:
`docker-compose.yml`:
```yaml
services:
archivebox:
...
volumes:
...
- ./data/personas/Default:/data/personas/Default
environment:
- CHROME_USER_DATA_DIR=/data/personas/Default/chrome_profile
- DISPLAY=novnc:0.0
novnc:
image: theasp/novnc:latest
environment:
- DISPLAY_WIDTH=1920
- DISPLAY_HEIGHT=1080
- RUN_XTERM=no
ports:
- "8080:8080"
```
2. Start the `novnc` window server container
```bash
docker compose up -d novnc
# wait a few seconds for novnc to start...
```
3. Start ArchiveBox's Chrome inside Docker
```bash
docker compose run archivebox /usr/bin/chromium-browser --user-data-dir=/data/personas/Default/chrome_profile --profile-directory=Default --disable-gpu --disable-features=dbus --disable-dev-shm-usage --start-maximized --no-sandbox --disable-setuid-sandbox --no-zygote --disable-sync --no-first-run
```
<small>(make sure you set `DISPLAY` & `CHROME_USER_DATA_DIR` and added the line to `volumes:` above first!)</small>
4. Open [`http://localhost:8080/vnc.html`](http://localhost:8080/vnc.html) in your browser. You should see a remote linux desktop shown with Chrome open, allowing you to remote-control ArchiveBox's browser. Use it to log into any sites where you want to save credentials.
5. ✅ Close the browser, stop & remove novnc, and then run archivebox normally. It will use the profile stored in `CHROME_USER_DATA_DIR=/data/personas/Default/chrome_profile` going forward, you should now be able to archive sites as if you were logged in!
```bash
# stop the archivebox and novnc containers
docker compose down
docker compose down --remove-orphans
# edit docker-compose.yml to remove/comment out the novnc: section
# test it all out by archiving something hosted on one of the domains you logged in to
docker compose run archivebox add 'https://private.example.com/some/site/requiring/login.html'
# check the SingleFile, Screenshot, DOM, or PDF snapshot output (only these use the Chrome profile)
# make sure the content appears as your logged-in user would see it
```
Under the hood this uses [Xvfb](https://www.x.org/releases/X11R7.6/doc/man/man1/Xvfb.1.xhtml) + [Fluxbox](http://www.fluxbox.org/) + [`novnc`](https://github.com/theasp/docker-novnc) to provide a virtual display, window manager, and VNC server + novnc websocket viewer.
<br/>
### Non-Docker Setup (Local Host)
If running ArchiveBox on your local machine without Docker, this process is fairly easy.
First, tell archivebox where you want to store your Chrome profile.
```bash
# replace /Users/alice/.archivebox_chrome with a path to store your profile in
archivebox config --set CHROME_USER_DATA_DIR=/Users/alice/.archivebox_chrome
```
Then run Chrome (with that profile dir) to open a visible browser window where you can log into things, e.g.:
```bash
# find your CHROME_BINARY path by running
archivebox version | grep -i chrome
# macOS example (using Google Chrome.app)
/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --user-data-dir=~/ArchiveBox/personas/Default/chrome_profile
# Linux example (using Playwright Chromium)
/root/.cache/ms-playwright/chromium-1105/chrome-linux/chrome --user-data-dir=~/archivebox/data/personas/Default/chrome_profile
```
Once it's open, log in to all the sites you want to be logged in to for archiving, then close/quit Chrome.
✅ All ArchiveBox extractors that use Chrome (e.g. Screenshot, PDF, DOM, Singlefile) should now use that profile.
*Don't forget to set up [`COOKIES_FILE`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration/#cookies_file) for the rest!*
<br/>
### Non-Docker Setup (Remote Host)
You must set up the profile using the exact same version of chrome that ArchiveBox is running (which can be found with `archivebox version`).
You can download the latest chromium with `pip install playwright && playwright install --with-deps chromium`, or get older versions of Chrome from https://chromium.cypress.io.
**General steps:**
1. Make sure you are running the same OS and have the same version of Chrome installed as the host running ArchiveBox
2. Follow the `Non-Docker Setup (Local Host)` setups above to create a Chrome profile locally
3. Rsync your chrome profile from your local machine to the remote archivebox host
`rsync --archive /path/to/profile remotehost:/path/to/profile/on/remote/host`
4. Configure ArchiveBox on the remote host to use the `rsync`'ed Chrome profile
`archivebox config --set CHROME_USER_DATA_DIR=/path/to/profile/on/remote/host`
You may need to run `chown -R archivebox /path/to/profile/on/remote/host` on the remote host to make the profile editable by the `archivebox` user on that machine.
✅ All ArchiveBox extractors that use Chrome (e.g. Screenshot, PDF, DOM, Singlefile) should now use that profile.
*Don't forget to set up [`COOKIES_FILE`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration/#cookies_file) for the rest!*
---
## More Info & Troubleshooting
- https://github.com/ArchiveBox/ArchiveBox/issues/952
- https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#archiving-private-content
- https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#%EF%B8%8F-things-to-watch-out-for-%EF%B8%8F
- https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#publishing
- https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#chrome_user_data_dir
- https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#chrome_binary
- https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#cookies_file

1175
docs/Configuration.md
View File

File diff suppressed because it is too large Load Diff

82
docs/Contents.rst
View File

@ -1,82 +0,0 @@
Contents
########
Overview
########
.. toctree::
:maxdepth: 1
Home.md
README.md
Getting Started
###############
.. toctree::
:maxdepth: 1
Quickstart.md
Install.md
Docker.md
Configuration.md
Security-Overview.md
.. toctree::
:maxdepth: 2
Usage.md
Guides
######
.. toctree::
:maxdepth: 1
Setting-Up-Storage.md
Setting-up-Authentication.md
Setting-up-Search.md
Publishing-Your-Archive.md
Scheduled-Archiving.md
Chromium-Install.md
Upgrading.md
Upgrading-or-Merging-Archives.md
Merging-Collections.md
Troubleshooting.md
Architecture
############
.. toctree::
:maxdepth: 1
ArchiveBox-Architecture-Diagrams.md
API Reference
#############
.. toctree::
:maxdepth: 3
Filesystem <https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#disk-layout>
SQL API <https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#sql-shell-usage>
REST API <https://demo.archivebox.io/api>
Python API <apidocs/index>
Meta
####
.. toctree::
:maxdepth: 1
Roadmap.md
Changelog.md
Donations.md
.. toctree::
:maxdepth: 3
Web-Archiving-Community.md

281
docs/Docker.md
View File

@ -1,281 +0,0 @@
# Docker
## Overview
Running ArchiveBox with Docker allows you to manage it in a container without exposing it to the rest of your system. ArchiveBox generally works the same in Docker as it does outside Docker. You can even use `pip`-installed ArchiveBox and Docker ArchiveBox in tandem, as they both share the same data directory format.
<img src="https://imgur.zervice.io/qFAPRwC.png" width="20%" align="right"/>
- [Overview](#Overview)
- [Docker Compose](#docker-compose) ⭐️ (recommended)
- [Setup](#setup)
- [Upgrading](https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#upgrading-with-docker-compose-%EF%B8%8F)
- [Usage](#usage)
- [Accessing the data](#accessing-the-data)
- [Configuration](#configuration)
- [Plain Docker](#docker)
- [Setup](#setup-1)
- [Upgrading](https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#upgrading-with-plain-docker)
- [Usage](#usage-1)
- [Accessing the data](#accessing-the-data-1)
- [Configuration](#configuration-1)
<br/>
**Official Docker Hub image: [`hub.docker.com/r/archivebox/archivebox`](https://hub.docker.com/r/archivebox/archivebox)**
```bash
docker pull archivebox/archivebox:latest
```
- [`Dockerfile`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/Dockerfile)
- [`docker-compose.yml`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/docker-compose.yml)
- [`archivebox-kubernetes.yml`](https://github.com/ArchiveBox/docker-archivebox/blob/master/archivebox.yml)
Published [Docker tags](https://hub.docker.com/r/archivebox/archivebox/tags):
- `:latest`, `:stable` (latest stable release, the default)
- `:x.x` and `:x.x.x` for specific versions (e.g. `:0.7` or `:0.7.2`)
- `:dev` for unstable alpha builds (breaks often, only for developers and willing beta testers)
- `:sha-xxxxxxx` for builds of specific git commits (to test or pin specific PRs or commits)
<br/>
> [!IMPORTANT]
> *Make sure Docker is **[installed](https://docs.docker.com/install/#supported-platforms)** and up-to-date before following any instructions below!* ➡️
> To check installed version, run: `docker --version` (must be `>=17.04.0`)
<br/>
<img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/9e8658f7-7d00-452e-a10e-f7d22ef9365a" height="40px" align="right"/>
## Docker Compose
<br/>
### Setup
A full [`docker-compose.yml`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/docker-compose.yml) file is provided with all the extras included.
You can uncomment sections within it to enable extra features, or run the basic version as-is.
```bash
# create a folder to store your data (can be anywhere)
mkdir -p ~/archivebox/data && cd ~/archivebox
# download the compose file into the directory
curl -fsSL 'https://docker-compose.archivebox.io' > docker-compose.yml
# (shortcut for getting https://raw.githubusercontent.com/ArchiveBox/ArchiveBox/stable/docker-compose.yml)
# initialize your collection and create an admin user for the Web UI (or set ADMIN_USERNAME/ADMIN_PASSWORD env vars)
docker compose run archivebox init
docker compose run archivebox manage createsuperuser
```
To use [Sonic](https://github.com/valeriansaliou/sonic) for improved full-text search, download this config & uncomment the sonic service in `docker-compose.yml`:
```bash
# download the sonic config file into your data folder (e.g. ~/archivebox)
curl -fsSL 'https://raw.githubusercontent.com/ArchiveBox/ArchiveBox/dev/etc/sonic.cfg' > sonic.cfg
# then uncomment the sonic-related sections in docker-compose.yml
nano docker-compose.yml
# to backfill any existing archive data into the search index, run:
docker compose run archivebox update --index-only
```
<br/>
### Upgrading
See the wiki page on [Upgrading or Merging Archives: Upgrading with Docker Compose](https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#upgrading-with-docker-compose-%EF%B8%8F) for instructions. ➡️
<br/>
### Usage
You can use `docker compose run archivebox [subcommand]` just like the non-Docker `archivebox [subcommand]` CLI.
First, make sure you're `cd`'ed into the same folder as your `docker-compose.yml` file (e.g. `~/archivebox`):
```bash
docker compose run archivebox help
```
To add an individual URL, pass it in as an arg or via stdin:
```bash
docker compose run archivebox add 'https://example.com'
# OR
echo 'https://example.com' | docker compose run -T archivebox add
```
To add multiple URLs at once, pipe them in via stdin, or place them in a file inside `./data/sources` so that ArchiveBox can access it from within the container:
```bash
# pipe URLs in from a file outside Docker
docker compose run -T archivebox add < ~/Downloads/example_urls.txt
# OR ingest URLs from a file mounted inside Docker
docker compose run archivebox add --depth=1 /data/sources/example_urls.txt
# OR pipe in URLs from a remote source
curl 'https://example.com/some/rss/feed.xml' | docker compose run archivebox add
docker compose run archivebox add --depth=1 'https://example.com/some/rss/feed.xml'
```
The `--depth=1` flag tells ArchiveBox to look inside the provided source and archive all the URLs within:
```bash
# this archives just the RSS file itself (probably not what you want)
docker compose run archivebox add 'https://example.com/some/feed.rss'
# this archives the RSS feed file + all the URLs mentioned inside of it
docker compose run archivebox add --depth=1 'https://example.com/some/feed.rss'
```
<br/>
### Accessing the data
The outputted archive data is stored in `data/` (relative to the project root), or whatever folder path you specified in the `docker-compose.yml` `volumes:` section. Make sure the `data/` folder on the host has permissions initially set to `777` so that the ArchiveBox command is able to set it to the specified `OUTPUT_PERMISSIONS` config setting on the first run.
To access the results directly via the filesystem, open `./data/archive/<timestamp>/index.html` (timestamp is shown in output of previous command).
Alternatively, to use the web UI, start the server with:
```bash
docker compose up # add -d to run in the background
```
Then open [`http://127.0.0.1:8000`](http://127.0.0.1:8000).
<br/>
### Configuration
ArchiveBox running with `docker compose` accepts all the same config options as other ArchiveBox distributions, see the full list of options available on the [[Configuration]] page.
The recommended way configure ArchiveBox in Docker Compose is using `archivebox config --set ...` or by editing `ArchiveBox.conf`.
```bash
docker compose run archivebox config --set MEDIA_MAX_SIZE=750mb
# OR
echo 'MAX_MEDIA_SIZE=750mb' >> ./data/ArchiveBox.conf
```
This will apply the config to all containers or archivebox instances that access the collection.
If you're only running one container, or if you want to scope config options to only apply to a particular container, you can set them in that container's `environment:` section:
```yaml
...
services:
archivebox:
...
environment:
- USE_COLOR=False
- SHOW_PROGRESS=False
- CHECK_SSL_VALIDITY=False
- RESOLUTION=1900,1820
- MEDIA_TIMEOUT=512000
...
```
You can also specify an env file via CLI when running compose using `docker compose --env-file=/path/to/config.env ...` although you must specify the variables in the `environment:` section that you want to have passed down to the ArchiveBox container from the passed env file.
If you want to access your archive server with HTTPS, put a reverse proxy like Nginx or Caddy in front of `http://127.0.0.1:8000` to do SSL termination. Here is an example [ArchiveBox nginx container](https://github.com/ArchiveBox/ArchiveBox/blob/dev/docker-compose.yml#:~:text=nginx) + [`nginx.conf`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/etc/nginx.conf) that you can modify to add your preferred TLS settings.
<br/>
---
<br/>
## Docker
<br/>
### Setup
Fetch and run the ArchiveBox Docker image to create your initial archive.
```bash
docker pull archivebox/archivebox
mkdkir -p ~/archivebox/data && cd ~/archivebox/data
docker run -it -v $PWD:/data archivebox/archivebox init --setup
```
*(You can create a collection in any directory you want, `~/archivebox/data` is just used as an example here)*
If you encounter permissions issues, you may need configure user/group ownership explicitly with [`PUID`/`PGID`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#puid--pgid).
<br/>
### Upgrading
See the wiki page on [Upgrading or Merging Archives: Upgrading with plain Docker](https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#upgrading-with-plain-docker) for instructions. ➡️
<br/>
### Usage
The Docker CLI `docker run ... archivebox/archivebox [subcommand]` works just like the non-Docker `archivebox [subcommand]` CLI.
First, make sure you're `cd`'ed into your collection data folder (e.g. `~/archivebox/data`).
```bash
docker run -it -v $PWD:/data archivebox/archivebox help
```
To add a single URL, pass it as an arg or pipe it in via stdin:
```bash
docker run -it -v $PWD:/data archivebox/archivebox add 'https://example.com'
# OR
echo 'https://example.com' | docker run -i -v $PWD:/data archivebox/archivebox add
```
To archive multiple URLs at once, pass text containing URLs in via stdin:
```bash
docker run -i -v $PWD:/data archivebox/archivebox add < urls.txt
# OR
curl 'https://example.com/some/rss/feed.xml' | docker run -i -v $PWD:/data archivebox/archivebox add
```
You can also use the `--depth=1` flag to tell ArchiveBox to recursively archive the URLs within a provided source.
```bash
docker run -it -v $PWD:/data archivebox/archivebox add --depth=1 'https://example.com/some/rss/feed.xml'
```
<br/>
### Accessing the data
The `docker run` `-v /path/on/host:/path/inside/container` flag specifies where your data dir lives on the host.
For example to use a folder on an external USB drive (instead of the current directory `$PWD` or `~/archivebox/data`):
```bash
docker run -it -v /media/USB-DRIVE/archivebox/data:/data archivebox/archivebox ...
```
Then to view your data, you can look in the folder on the host `/media/USB-DRIVE/archivebox/data`, or use the Web UI:
```bash
docker run -it -v /media/USB_DRIVE/archivebox/data:/data -p 8000:8000 archivebox/archivebox
# then open https://127.0.0.1:8000
```
<br/>
### Configuration
The easiest way is to use `archivebox config --set KEY=value` or edit `./ArchiveBox.conf` (in your collection dir).
For example, this sets `MEDIA_TIMEOUT=120` as a persistent setting for the collection:
```bash
docker run -it -v $PWD:/data archivebox/archivebox config --set MEDIA_TIMEOUT=120
# OR
echo 'MEDIA_TIMEOUT=120' >> ./ArchiveBox.conf
```
ArchiveBox in Docker also accepts config as environment variables, see more on the [[Configuration]] page.
For example, this applies `FETCH_SCREENSHOT=False` to a single run (without persisting for other runs):
```bash
docker run -it -v $PWD:/data -e FETCH_SCREENSHOT=False archivebox/archivebox add 'https://example.com'
# OR
echo 'FETCH_SCREENSHOT=False' >> ./.env
docker run ... --env-file=./.env archivebox/archivebox ...
```

23
docs/Donations.md
View File

@ -1,23 +0,0 @@
## Supporting Development
*ArchiveBox operates as a US 501(c)(3) nonprofit, <a href="https://hcb.hackclub.com/donations/start/archivebox">donations</a> are tax-deductible.*
<sub>(ArchiveBox is fiscally sponsored by <a href="https://hackclub.com/hcb?ref=donation">HCB</a> <code>EIN: 81-2908499</code>)</sub>
<br/>
**💬 [Hire us](https://docs.sweeting.me/s/archivebox-consulting-services)** to help your NGO/org with archiving, or donate to directly support ArchiveBox open-source development.
- ⭐️ **Direct donation via our `501(c)(3)` non-profit:** https://hcb.hackclub.com/donations/start/archivebox
- ⭐️ **Github Sponsors:** https://github.com/sponsors/pirate
- 👕 **Buy some swag:** https://archivebox-shop.fourthwall.com/
- **Patreon:** https://www.patreon.com/theSquashSH
- **Paypal:** https://paypal.me/NicholasSweeting
- **Crypto:** *[Contact me to request wallet address...](https://zulip.archivebox.io/#narrow/dm/284-Nick-Sweeting)*
<br/>
If you have any questions or want to partner with this project, contact me at: `donations-hello` `@` `archivebox` `.` `io`.

45
docs/Home.md
View File

@ -1,45 +0,0 @@
# ArchiveBox Documentation
<div align="center">
<img src="https://archivebox.io/icon.png" width="80px"/>
</div>
**📖 Use the sidebar on the right to browse documentation topics ➡️**
<i>(Expand the `Pages` section to 🔍 Search for a specific term)</i>
<br/>
**📚 If you need help or have a question, you can:**
- 💬 Chat with us on our [Public Zulip Server](https://zulip.archivebox.io)
- 🐞 Open an [issue or feature request](https://github.com/ArchiveBox/ArchiveBox/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc) in our bug tracker
- 💠 Reach out to me on Twitter [@ArchiveBoxApp](https://twitter.com/ArchiveBoxApp) or [@theSquashSH](https://twitter.com/theSquashSH)
---
<div align="center">
<img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/3b6a2a9c-00d5-4702-beba-13be24eb50a2" width="30%" alt="CLI Screenshot" align="top"/>
<img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/d97bf733-4fef-4600-a3b7-c806f3212af7" width="30%" alt="Desktop index screenshot" align="top"/>
<img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/4f4517e9-a1c1-4809-91ba-cc36e91add3c" width="30%" alt="Desktop details page Screenshot"/><br/>
<a href="https://github.com/ArchiveBox/ArchiveBox">Readme</a> | <a href="https://archive.sweeting.me/">Demo</a> | <a href="https://github.com/ArchiveBox/ArchiveBox/wiki/Quickstart">Quickstart</a> | <a href="https://github.com/ArchiveBox/ArchiveBox/wiki/Usage">Usage</a> | <a href="https://github.com/ArchiveBox/ArchiveBox/wiki/Web-Archiving-Community">Community</a>
<br/>
<hr/>
**🏛️ [Need professional support? Hire Us](https://docs.sweeting.me/s/archivebox-consulting-services) 💬**
<br/>
**✨ Or donate to support open-source development ✨**
[![](https://img.shields.io/badge/Donate-Directly-%13DE5D26.svg)](https://hcb.hackclub.com/donations/start/archivebox) [![](https://img.shields.io/badge/Donate-Github_Sponsors-%23B7CDFE.svg)](https://github.com/sponsors/pirate) <a href="https://archivebox-shop.fourthwall.com/"><img src="https://img.shields.io/badge/Buy-Merch-%23903851.svg"/></a>
<br/>
<sup>ArchiveBox operates as a US 501(c)(3) nonprofit FSP, <a href="https://hcb.hackclub.com/donations/start/archivebox">donations</a> are tax-deductible.<br/>(fiscally sponsored by <a href="https://hackclub.com/hcb?ref=donation">HCB</a> <code>EIN: 81-2908499</code>)</sup><br/>
<br/>
<sub>The name ArchiveBox™️ is trademarked in the US and you can find the <a href="https://www.stickermule.com/studio/brand-kits/06f665c3-5b24-4da7-98b3-61d68d3996a0">ArchiveBox brand kit</a> here.</sub>
</div>

311
docs/Install.md
View File

@ -1,311 +0,0 @@
# Install
ArchiveBox is primarily distributed as a Python package via `pip`, but it also depends on some system packages that can be installed manually or automatically with Docker. It usually takes less than ~10min to get ArchiveBox set up and running.
<img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/601d587d-b59f-47b9-938e-8a7fa7790176" width="20%" align="right"/>
- *[Supported Systems](#supported-systems)*
- Install Instructions
- **[Option A. Docker / Docker Compose ⭐️](#option-a-docker--docker-compose-setup-%EF%B8%8F)**
- [Option B. Automatic Setup Script](#option-b-automatic-setup-script)
- [Option C. System Package Manager Setup](#option-c-bare-metal-setup)
- *[Upgrading ArchiveBox to a new version](#upgrading-archivebox-to-a-new-version)*
- *[Next Steps](#next-steps)*
## Supported Systems
<img src="https://cdn0.iconfinder.com/data/icons/flat-round-system/512/freebsd-512.png" width="5%" align="right"/>
<img src="https://assets.ubuntu.com/v1/c5cb0f8e-picto-ubuntu.svg" width="5%" align="right"/>
<img src="https://imgur.zervice.io/Ue9BI7n.png" width="5%" align="right"/>
**CPU Architectures:** `amd64` (`x86_64`), `arm64` (`aarch64`), `arm7`
*(Including 64-bit Intel/AMD, M1/M2/etc. Macs, Raspberry Pi >= 3)*
* [**macOS:**](#macos) >=10.12 (with `pip`)
* [**Linux:**](#ubuntudebian) Ubuntu (>= 18.04), Debian (>= 10), etc. (with `apt`)
* [**BSD:**](#bsd) FreeBSD, OpenBSD, NetBSD etc (with `pkg`)
Other systems are not officially supported but may work with degraded functionality:
<img src="https://imgur.zervice.io/WYSb96z.png" width="6%" align="right"/>
<img src="http://files.softicons.com/download/system-icons/web0.2ama-icons-by-chrfb/png/256x256/Operating%20System%20-%20Windows.png" width="5%" align="right"/>
* **Windows:** Via [[Docker]], Docker in WSL2, or WSL2 without Docker (not recommended)
* [Other UNIX systems:](https://github.com/ArchiveBox/ArchiveBox#-package-manager-setup) Arch, Nix, Guix, Fedora, SUSE, Arch, CentOS, etc.
<sub>Note: On `arm7` the `playwright` package is not available, so `chromium` must be installed manually if needed.</sub>
<br/>
You will also need at least 500MB of RAM (bare minimum), 2GB or greater is recommended. You may be able to reduce the RAM requirements if you disable all the chrome-based archiving methods with `USE_CHROME=False`.
It's also recommended to use a filesystem with compression and/or [deduplication](https://www.ixsystems.com/blog/ixsystems-and-klara-systems-celebrate-valentines-day-with-a-heartfelt-donation-of-fast-dedupe-to-openzfs-and-truenas/) (e.g. [ZFS](https://openzfs.github.io/openzfs-docs/Getting%20Started/index.html) or BTRFS) for maximum efficiency.
<br/>
---
<br/>
## Option A. Docker / Docker Compose Setup ⭐️
*Docker Compose is the recommended way to get ArchiveBox, as it includes all the extras out-of-the-box and provides the best security and upgrade UX.*
1. If you don't already have docker installed, follow the official instructions to get Docker on Linux, macOS, or Windows:
https://docs.docker.com/install/#supported-platforms ➡️
2. Then follow the [Quickstart](https://github.com/ArchiveBox/ArchiveBox#quickstart) guide and read the [[Docker]] wiki page for next steps. ➡️
> You can also run Dockerized ArchiveBox using [UNRAID/TrueNAS/Proxmox/etc.](https://github.com/ArchiveBox/ArchiveBox#-other-options) or [Kubernetes](https://github.com/ArchiveBox/docker-archivebox/blob/master/archivebox.yml).
**More info:**
- [`Dockerfile`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/Dockerfile)
- [`docker-compose.yml`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/docker-compose.yml)
- [`archivebox-kubernetes.yml`](https://github.com/ArchiveBox/docker-archivebox/blob/master/archivebox.yml)
- [ArchiveBox Docker Quickstart](https://github.com/ArchiveBox/ArchiveBox#quickstart) + [Usage](https://github.com/ArchiveBox/ArchiveBox/wiki/Docker) + [Configuration](https://github.com/ArchiveBox/ArchiveBox/wiki/Docker#configuration) + [Upgrading](https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives) documentation
<br/>
---
<br/>
## Option B. Automatic Setup Script
If you're on Linux with `apt` or FreeBSD with `pkg` there is an optional auto-setup script provided.
*(or scroll further down for manual install instructions)*
```bash
curl -fsSL 'https://get.archivebox.io' | bash
# shortcut to run https://raw.githubusercontent.com/ArchiveBox/ArchiveBox/stable/bin/setup.sh
```
The script explains what it installs beforehand, and will prompt for user confirmation before making any changes to your system. The script uses Docker if already installed, but you can decline and it will attempt to auto-install everything using `apt`/`brew`/`pkg` + `pip` instead.
<sub>Note: The script will currently still attempt to install via `brew` on macOS. This will fail as ArchiveBox is no longer distributed as a Homebrew formula.</sub>
<img src="https://imgur.zervice.io/VMTzm0G.png" width="99%"/>
After running the setup script, continue with the [Quickstart](https://github.com/ArchiveBox/ArchiveBox#%EF%B8%8F-next-steps) guide... ➡️
> *See here for our thoughts on the [inherent limitations of `curl | sh`](https://docs.monadical.com/s/against-curl-sh) as an install method...*
<br/>
---
<br/>
## Option C. Bare Metal Setup
If you'd rather not use [Docker](https://github.com/ArchiveBox/ArchiveBox#%EF%B8%8F-easy-setup) or our [auto-install script](https://github.com/ArchiveBox/ArchiveBox#%EF%B8%8F-easy-setup), you can follow these manual setup instructions to install ArchiveBox and its dependencies using `pip` & your system package manager of choice (e.g. `apt`, `brew`, `pkg`, `nix`, etc.).
See our [Dependencies](https://github.com/ArchiveBox/ArchiveBox#dependencies) documentation to see the full list of dependencies and how they're used. Not all the dependencies are required for all modes. If you disable some archive methods you can skip installing those dependencies, for example, if you set `FETCH_MEDIA=False` you don't need to install `yt-dlp`, and if you set `FETCH_[PDF,SCREENSHOT,DOM]=False` you don't need `chromium`.
<img src="https://avatars0.githubusercontent.com/u/1503512?s=200&v=4" width="100px" align="right"/>
**More info:**
- For help installing these, see the [Manual Setup](#manual-setup), [[Troubleshooting]] and [[Chromium Install]] pages.
- To use specific binaries for dependencies, see the [Configuration: Dependencies](Configuration#dependency-options) page.
- To disable unwanted dependencies, see the [Configuration: Archive Method Toggles](Configuration#archive-method-toggles) page.
<br/>
### 1. Install base system dependencies needed for your OS
*Be aware, you'll need to keep all these packages up-to-date yourself over time!*
<img src="https://imgur.zervice.io/Ue9BI7n.png" width="30px" align="right"/>
#### macOS
Make sure you have [Homebrew](https://brew.sh/) installed first.
```bash
# Install ArchiveBox's dependencies manually (instead of using the all-in-one brew package)
brew install python3 node git wget curl ffmpeg yt-dlp ripgrep sonic
pip install archivebox
archivebox install
# Optional: get FFMPEG with the AAC addon
# brew tap homebrew-ffmpeg/ffmpeg
# brew uninstall ffmpeg; brew install homebrew-ffmpeg/ffmpeg/ffmpeg --with-fdk-aac
# Optional: get Chromium with brew (not needed if you already have /Applications/{Google Chrome,Chromium}.app)
# brew install --cask chromium
```
<img src="https://assets.ubuntu.com/v1/c5cb0f8e-picto-ubuntu.svg" width="30px" align="right"/>
#### Ubuntu/Debian-based Systems
Make sure `apt` and `dpkg` are available on your system.
```bash
# add the nodejs sources to your apt lists (optional, otherwise may use older node)
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
# Install base system dependencies manually (check ArchiveBox/Dockerfile for more if needed)
sudo apt install python3 python3-pip python3-minimal nodejs libatomic1 zlib1g-dev libssl-dev libldap2-dev libsasl2-dev python3-ldap python3-msgpack python3-mutagen python3-regex python3-pycryptodome procps dnsutils wget curl git yt-dlp ffmpeg ripgrep
sudo apt install python3-setuptools # or: python3-distutils on older systems
# Optional: get Chromium with pip (skip if you already have chromium-browser/google-chrome installed and in your $PATH)
# pip install --upgrade playwright
# playwright install --with-deps chromium
# OR: get chromium and manually with apt (not recommended, often out-of-date)
# sudo apt install chromium fontconfig fonts-ipafont-gothic fonts-wqy-zenhei fonts-thai-tlwg fonts-kacst fonts-symbola fonts-noto fonts-freefont-ttf
```
<img src="https://cdn0.iconfinder.com/data/icons/flat-round-system/512/freebsd-512.png" width="30px" align="right"/>
#### FreeBSD
```bash
sudo pkg install python git wget curl youtube_dl ripgrep py311-pip py311-sqlite3 npm ffmpeg
sudo pkg install chromium
# or for older versions:
# sudo pkg install python node wget curl git yt-dlp ffmpeg ripgrep chromium-browser
```
#### OpenBSD
```bash
sudo pkg_add python3 node wget git curl yt-dlp ffmpeg ripgrep chromium
```
#### Arch Linux / Nix / Guix / etc. Other OSs
See the [Quickstart](https://github.com/ArchiveBox/ArchiveBox#-package-manager-setup) instructions for other operating systems and release channels. ➡️
<br/>
<img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/65315723-adae-42e4-b8c6-e44b79165ae5" width="55px" align="right"/>
### 2. Install the Python dependencies using `pip`
It's recommended to `pip`-install ArchiveBox even if you already installed `archivebox` with one of our official `apt`/`pkg` packages above (sometimes the `pip` version is newer). This step also ensures you have the latest `yt-dlp` and `playwright` versions.
```bash
# get the latest version of archivebox from PyPI
pip install --upgrade --ignore-installed archivebox[ldap,sonic]
# if you see errors about ldap, install the C++ build tools + ldap headers and retry (only needed on some OSs + if you want ldap)
# apt install build-essensial python3-ldap
```
<br/>
### 3. Install the JS dependencies using `archivebox setup`
Finish installing the runtime JS dependencies that live inside your collection data dir (e.g. readability, singlefile, mercury).
```bash
# create a new empty folder anywhere to hold your collection, and cd into it
mkdir -p ~/archivebox/data && cd ~/archivebox/data
# instantiate the directory as an archivebox collection dir
archivebox init
# auto-install all the runtime JS dependencies inside ./node_modules
archivebox setup
# under the hood, this does:
# - installs npm dependencies: singlefile, readability, puppeteer, etc.
# - installs pip dependencies: yt-dlp, playwright, etc.
# - checks for / installs system dependencies: curl, wget, etc
# if you see "permission denied" errors, run 'sudo archivebox setup'
# ✅ see a final detailed breakdown of all the installed dependencies and commands available
archivebox version
archivebox help
```
<br/>
### Troubleshooting
Make sure the `pip`-installed version of `archivebox` is available in your `$PATH`.
```bash
pip show archivebox # show info about the pip-installed version of archivebox
echo $PATH # show the directories your system is searching for binaries
which -a archivebox # show all installed archivebox binaries available
which archivebox # show which archivebox binary is being called
cd ~/archivebox/data
archivebox version # ⭐️ show lots of useful info about installed dependencies and more
archivebox status
archivebox help
```
(ensure the version shown is the most recent available from [Releases](https://github.com/ArchiveBox/ArchiveBox/releases))
Make sure to run `archivebox` **as an unprivileged user** (i.e. without `sudo` / not logged in as `root`).
Make sure to run all commands, including `archivebox version`, `archivebox help`, etc. **inside a data directory** (or a new empty dir that will become a data dir).
If you have issues getting Chromium / Google Chrome or other dependencies working with ArchiveBox, see the [[Chromium Install]] and [[Troubleshooting]] pages for more detailed instructions.
<br/>
### Next Steps: Add some URLs to archive and try out CLI / Web UI
For guides on how to import URLs from different sources into ArchiveBox, check out [Input Formats](https://github.com/ArchiveBox/ArchiveBox#input-formats) and [Preparing URLs](https://github.com/ArchiveBox/ArchiveBox/wiki/Quickstart#2-get-your-list-of-urls-to-archive). ➡️
```bash
cd ~/archivebox/data
```
```bash
# feed in your URLs to start archiving!
archivebox add --help
archivebox add < ~/Downloads/bookmarks_export.html
```
```bash
# inspect the newly added Snapshots via the CLI
archivebox list
archivebox status
```
```bash
# OR start the webserver and view them in the Web UI
archivebox server 0.0.0.0:8000
open http://localhost:8000
```
See our [[Usage]] Wiki documentation page for more examples.
<br/>
### Next Steps: *Upgrading Archivebox to a new version*
Make sure all apt/brew/pkg/etc. dependencies from above are installed & up-to-date first.
```bash
# get the latest archivebox version from PyPI
pip install --upgrade --ignore-installed archivebox
# run init inside any data directories to migrate the index to the latest version
cd ~/archivebox/data
archivebox setup # update runtime dependencies to latest versions
archivebox init # update collection index & apply any migrations
```
Check our more detailed [Upgrading](https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives) documentation and [Release Notes](https://github.com/ArchiveBox/ArchiveBox/releases) if you run into any problems. ➡️
<br/>
---
<br/>
### Further Reading
- Read [[Usage]] to learn how to use the ArchiveBox CLI and HTML output
- Read [[Configuration]] to learn about the various archive method options
- Read [[Scheduled Archiving]] to learn how to set up automatic daily archiving
- Read [[Publishing Your Archive]] if you want to host your archive for others to access online
- Read [[Troubleshooting]] if you encounter any problems

19
docs/Makefile
View File

@ -1,19 +0,0 @@
# Minimal makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
SOURCEDIR = .
BUILDDIR = _build
# Put it first so that "make" without argument is like "make help".
help:
@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
.PHONY: help Makefile
# Catch-all target: route all unknown targets to Sphinx using the new
# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
%: Makefile
@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

124
docs/Merging-Collections.md
View File

@ -1,124 +0,0 @@
# Merging Collections
Two or more existing ArchiveBox collection dirs can be merged together by simply combining the contents of `archive/*` and re-running `archivebox init` to pull the new Snapshots into the index.
> [!WARNING]
> Snapshot folders are identified by their timestamp (in milliseconds), this is normally not a problem for archives collected on one machine, but when merging archives from two different instances that ran at the same time it means there is a small chance of conflicts. Check the contents of `archive/` before merging, and backup any directories that may conflict before proceeding.
1. Upgrade both old collections to the most recent ArchiveBox version (following instructions above)
```bash
pip install --upgrade archivebox # or follow instructions above for upgrading w/ Docker
cd /path/to/archivebox1/data
archivebox init
archivebox status
cd /path/to/archivebox2/data
archivebox init
archivebox status
# ... repeat the same for each collection if merging more than two
```
2. Create a new empty archivebox collection in a new folder somewhere, this will hold the new merged collection
```bash
mkdir /path/to/archivebox_new
cd /path/to/archivebox_new
archivebox init
```
3. Copy everything under `./archive/*` in each old collection into the new collection's `./archive/` folder
```bash
rsync --archive --info=progress2 /path/to/archivebox1/data/archive/ /path/to/archivebox_new/data/archive
rsync --archive --info=progress2 /path/to/archivebox2/data/archive/ /path/to/archivebox_new/data/archive
# ...repeat the same for each collection if merging more than two
```
4. Run `archivebox init` in the new merged collection to regenerate the new index
```bash
cd /path/to/archivebox_new
archivebox init
```
5. The new collection should now contain all the entries from the old collections combined
```bash
cd /path/to/archivebox_new
archivebox status
# optionally force an update of the snapshot index files (normally done lazily)
archivebox update --index-only
```
For more information about why Snapshot index files are usually updated lazily, see: https://github.com/ArchiveBox/ArchiveBox/issues/962
After you've confirmed your Snapshots are present in the new index, the old `index.sqlite3`, `index.json`, `index.html`, etc. main index files from the old archives can be safely deleted. You can optionally merge the contents of `ArchiveBox.conf` (your ArchiveBox config options), `sources/` (copies of all URLs imported in their original format), `logs/` (ArchiveBox error logs and debug info), and other root-level items yourself if that data is important to you.
---
## Modify the ArchiveBox SQLite3 DB directly
If you need to automate changes to the ArchiveBox DB (for example adding a User from an Ansible script), you can modify the SQLite3 DB directly.
Note, this is often unnecessary for modifying ArchiveBox on a host that doesn't have the CLI installed, as you can also copy the `index.sqlite3` to a local machine that has it, do the modifications locally, then copy the modified db back into place on the host. (Docker/CLI/GUI/Web ArchiveBox all share the same DB schema/format)
```bash
cd ~/archivebox/data # cd into your archivebox collection dir
sqlite3 index.sqlite3 # open the db with sqlite3 shell
```
#### Example: Modifying an existing user's email
```sql
UPDATE auth_user
SET email = 'someNewEmail@example.com', is_superuser = 1
WHERE username = 'someUsernameHere';
```
#### Example: Adding a new user with a hashed password
*Note: this is just an example to demonstrate direct database usage. If you are trying to create a user on initial setup, use the [`ADMIN_USERNAME` & `ADMIN_PASSWORD`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#admin_username--admin_password) configuration options.*
1. First, generate the hashed password in a Python shell using Django's `make_password` function.
This can be done on any machine with Python 3+, it doesn't have to have ArchiveBox installed.
```bash
pip3 install django==3.1.3 # install the django version used by ArchiveBox
python3 # open any python shell with django available, doesn't have to be the archivebox shell
```
```python3
>>> from django.contrib.auth.hashers import make_password
>>> make_password('somePasswordHere', 'someSaltHere', 'pbkdf2_sha256') # choose a password and a salt (can be anything 12 chars long)
'pbkdf2_sha256$216000$someSaltHere$styW1Uoy8SHp3zbSwGRp20C9mPjOHVjP9rl5a8/UOVE='
```
2. Use the generated hashed password to insert a new User row in the SQLite3 database directly:
```bash
cd ~/archivebox/data # cd into your archivebox collection dir
sqlite3 index.sqlite3 # open the db with sqlite3 shell
```
```sql
INSERT INTO "auth_user" ("password", "last_login", "is_superuser", "username", "first_name", "last_name", "email", "is_staff", "is_active", "date_joined")
VALUES ('pbkdf2_sha256$216000$someSaltHere$+2beZufc3JUXnmn0tG+2peJEBh7MjxPYmT3YfIFzEl0=', NULL, 0, 'someUsername', '', '', 'someEmail@example.com', 0, 1, '2022-03-22 23:34:02.333042')
```
Replace the values above with the desired username, email, and password hash from python output^.
3. Log in using the new generated user to confirm it works
https://localhost:8000/admin/login/ user: `someUsername` pass:`somePasswordHere`
More info:
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#python-shell-usage
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#sql-shell-usage
---
## Database Troubleshooting
See here [Troubleshooting: Database](https://github.com/ArchiveBox/ArchiveBox/wiki/Troubleshooting#database)...
---
## Related Documents
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#disk-layout
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#large-archives
- https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#output-folder
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#python-shell-usage
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#sql-shell-usage

130
docs/Publishing-Your-Archive.md
View File

@ -1,130 +0,0 @@
# Publishing Your Archive
There are two ways to publish your archive: using the `archivebox server` or by exporting and hosting it as static HTML.
<br/>
## 1. Use the built-in web server
```bash
# set the permissions depending on how public/locked down you want it to be
archivebox config --set PUBLIC_INDEX=True
archivebox config --set PUBLIC_SNAPSHOTS=True
archivebox config --set PUBLIC_ADD_VIEW=True
# create an admin username and password for yourself
archivebox manage createsuperuser
# then start the webserver and open the web UI in your browser
archivebox server 0.0.0.0:8000
open http://127.0.0.1:8000
```
This server is enabled out-of-the-box if you're using `docker-compose` to run ArchiveBox,
and there is a commented-out example nginx config with SSL set up as well. If hosting publicly, it's essential to place an SSL termination server in front of ArchiveBox (e.g. [`traefik`](https://github.com/traefik/traefik), [`caddy`](https://caddyserver.com/docs/automatic-https#activation), or [`cloudflared`](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/)),
> [!TIP]
> Advanced: You can use nginx to serve the static `/archive/` dir directly from the filesystem to increase performance.
> To protect the `/admin/` dashboard, it should ideally be served from a [different domain](#security-concerns) using redirects.
<br/>
## 2. Export and host it as static HTML
```bash
archivebox list --html --with-headers > index.html
archivebox list --json --with-headers > index.json
# then upload the entire output folder containing index.html and archive/ somewhere
# e.g. github pages or another static hosting provider
# you can also serve it with the simple python HTTP server
python3 -m http.server --bind 0.0.0.0 --directory . 8000
open http://127.0.0.1:8000
```
Here's a sample nginx configuration that works to serve your static archive folder:
```nginx
location / {
alias /path/to/your/ArchiveBox/data/;
index index.html;
autoindex on;
try_files $uri $uri/ =404;
}
```
Make sure you're not running any content as CGI or PHP, you only want to serve static files!
Urls look like: `https://demo.archivebox.io/archive/1493350273/en.wikipedia.org/wiki/Dining_philosophers_problem.html`
<br/>
---
<br/>
## Security Concerns
> [!CAUTION]
> Re-hosting untrusted archived content on a domain can potentially compromise *all apps on that domain*!
> (including other subdomains)
Make sure you thoroughly understand the dangers of [hosting untrusted HTML/JS/CSS that may be captured during archiving](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy), and how viewing it can enable [CSRF attacks](https://en.wikipedia.org/wiki/Cross-site_request_forgery) across all apps on the same domain. If a logged-in user happens to visit an archived page with malicious Javascript embedded, it would allow the JS to hijack any cookies on the domain and pretend to be them, potentially exfiltrating or modifying other Snapshots/data on your server.
(This is why we don't support serving ArchiveBox from a subdirectory like `myapps.example.com/archivebox/`, it's too dangerous to share domains)
The industry standard approach is to use a separate domain for untrusted content, for example Github uses `githubusercontent.com` and Google uses `googleusercontent.com` for all user-uploaded files. If hosting ArchiveBox publicly, do the same and keep it on an isolated domain in order to mitigate potential damage of leaked cookies, CORS, and CSRF attack.
### Protecting the Admin Dashboard
To protect the Admin dashboard, it's also recommended to serve all content under `/archive/` on a separate domain from `/admin/`. We do this on our servers using a simple redirect rule in nginx/cloudflare like so:
- https://demo.archivebox.io: only serves `/`, redirects `/archive/*` to `demo-static.`
- https://demo-static.archivebox.io: only serves `/archive/`, redirects everything else to `demo.`
<img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/8d855976-3b4a-4fa8-ad52-999b3c3deba4" width="800px" alt="Cloudflare redirect rule for /archive/ to another domain"/>
> Note: This is still recommended, but less critical if your `/archive/` folder does not contain any archived JS (e.g. if you [set `SAVE_WGET=False` and `SAVE_DOM=False`](https://github.com/ArchiveBox/ArchiveBox#security-risks-of-viewing-archived-js)).
More info:
- https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview
- https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#publishing
- https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#%EF%B8%8F-things-to-watch-out-for-%EF%B8%8F
<br/>
---
<br/>
## Copyright Concerns
> [!WARNING]
> Be aware that some sites you archive may not allow you to rehost their content publicly for copyright reasons, it's up to you to host responsibly and respond to takedown requests appropriately based on the laws in your jurisdiction.
Archiving for personal backups, research, and some other use-cases are covered by [fair use copyright exemptions](https://guides.library.oregonstate.edu/copyright/libraries) in the USA, but if your archive can deprive the original author of revenue (e.g. if you rehost it for profit), then your use case might no longer be covered and you have to respond to DMCA takedown notices.
**As a general rule of thumb:**
- Copies cannot be made for commercial purposes
- The copying cannot be systematic (e.g., to replace subscriptions)
- All copies made must include a notice stating that the materials may be protected under copyright.
Please modify the [`FOOTER_INFO`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#footer_info) config variable to add your contact info to the footer of your index.
Note: ArchiveBox prevents search engines from indexing your archives using [`/robots.txt`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/templates/static/robots.txt#L2) by default. It's not recommended to [disable](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#custom_templates_dir) this as it often leads to a flood of automated takedown requests and abuse reports to your hosting provider (from anti-piracy bots that scan for cloned copyrighted content via search engines).
*Keep in mind individuals, companies, schools, and libraries all have different copyright exemptions in different countries. Double check the specific laws for your situation in your own jurisdiction!*
#### Further Reading: USA Copyright Law & Fair Use Exemptions
- https://www.copyright.gov/title17/
- https://help.archive.org/help/rights/
- https://blog.archive.org/2024/03/01/fair-use-in-action-at-the-internet-archive/
- https://www.lib.ncsu.edu/workshops/understanding-copyright-and-fair-use-archival-research
- https://libguides.colorado.edu/c.php?g=1154758&p=8428124
- https://fairuse.stanford.edu/2003/11/10/digital_preservation_and_copyr/
- https://guides.library.oregonstate.edu/copyright/libraries
- https://www.clir.org/pubs/reports/pub112/body/
- https://github.com/pirate/internet-archiving-talk

89
docs/Quickstart.md
View File

@ -1,89 +0,0 @@
# Quickstart
<div align="center">
<img src="https://imgur.zervice.io/ZbHpEf8.jpg" width="30%"/>
</div>
▶️ *It only takes about 5 minutes to get up and running with ArchiveBox.*
ArchiveBox [officially supports](https://github.com/ArchiveBox/ArchiveBox/wiki/Install#supported-systems) **macOS**, **Ubuntu/Debian**, and **BSD**, but likely runs on many other systems. You can run it on any system that supports **Docker** and/or Python. Windows *is not supported* unless you run it inside Docker Desktop, Docker in WSL2, or WSL2.
For more detailed Docker and Docker Compose-specific instructions, see the [[Docker]] page.
---
## 1. Set up ArchiveBox
Follow the [README Instructions](https://github.com/ArchiveBox/ArchiveBox#quickstart) for your platform to get archivebox set up.
## 2. Get your list of URLs to archive
Follow the links here to find instructions for exporting a list of URLs from each service.
- [Pocket](https://github.com/ArchiveBox/pocket-exporter)
- [Pinboard](https://pinboard.in/export/)
- [Instapaper](https://instapaper.zendesk.com/hc/en-us/articles/30080578815245-Import-export-content-from-into-Instapaper)
- [Reddit Saved Posts](https://github.com/csu/export-saved-reddit)
- [Shaarli](https://www.mypersonnaldata.eu/shaarli/doc/Backup,-restore,-import-and-export.html#export-links-as)
- [Unmark.it](http://help.unmark.it/import-export)
- [Wallabag](https://doc.wallabag.org/en/user/import/wallabagv2.html)
- [Chrome Bookmarks](https://support.google.com/chrome/answer/96816?hl=en)
- [Firefox Bookmarks](https://support.mozilla.org/en-US/kb/export-firefox-bookmarks-to-backup-or-transfer)
- [Safari Bookmarks](http://imgur.zervice.io/AtcvUZA.png)
- [Opera Bookmarks](http://help.opera.com/Windows/12.10/en/importexport.html)
- [Internet Explorer Bookmarks](https://support.microsoft.com/en-us/help/211089/how-to-import-and-export-the-internet-explorer-favorites-folder-to-a-32-bit-version-of-windows)
- Chrome History: `./bin/export_browser_history.sh --chrome`
- Firefox History: `./bin/export_browser_history.sh --firefox`
- Safari History: `./bin/export_browser_history.sh --safari`
- Other File or URL: (e.g. RSS feed url, text file path) pass as second argument in the next step
(If any of these links are broken, please submit an issue and I'll fix it)
## 3. Add your URLs to the archive
Pass in URLs directly, import a list of links from a file, or import from a feed URL. All via stdin:
```bash
archivebox add < your_urls.txt
# or if using plain Docker
docker run -v $PWD:/data -it archivebox/archivebox add < your_urls.txt
# or if using Docker Compose
docker compose run -T archivebox add < your_urls.txt
# any text containing URLs can ingested via stdin or as args
curl -fsSL 'https://getpocket.com/users/YOURUSERNAME/feed/all' | archivebox add
archivebox add 'https://example.com'
```
## ✅ Done!
Open `./archive` to view your archive data in the filesystem.
You can also use the interactive Web UI to view/manage/add links to your archive:
```bash
# with plain Docker:
docker run -v $PWD:/data -it -p 8000:8000 archivebox/archivebox
# with Docker Compose:
docker compose up -d
# or without Docker:
archivebox server
open http://127.0.0.1:8000
```
---
**Next Steps:**
```bash
archivebox help # see info about all the available commands
```
- Read [[Usage]] to learn about the various CLI and web UI functions
- Read [[Configuration]] to learn about the various archive method options
- Read [[Scheduled Archiving]] to learn how to set up automatic daily archiving
- Read [[Publishing Your Archive]] if you want to host your archive for others to access online
- Read [[Troubleshooting]] if you encounter any problems

1
docs/README.md
View File

@ -1 +0,0 @@
../README.md

237
docs/Roadmap.md
View File

@ -1,237 +0,0 @@
# Roadmap
<img src="https://imgur.zervice.io/es97GGV.png" width="20%" align="right"/>
▶️ *Comment here to discuss the contribution roadmap:
[Official Roadmap Discussion](https://github.com/ArchiveBox/ArchiveBox/issues/120).*
---
## Planned Specification
(this is not set in stone, just a rough estimate)
### `v0.7: Schema improvements`
- move config loading logic into settings.py
- move all the extractors into "plugin" style folders that register their own config
- right now, the paths of the extractor output are scattered all over the codebase, e.g. `output.pdf` (should be moved to constants at the top of the plugin config file)
- make out_dir, link_dir, extractor_dir, naming consistent across codebase
- remove `timestamps` as primary keys in favor of hashes, UUIDs, or some other slug https://github.com/ArchiveBox/ArchiveBox/issues/74
- create a migration system for folder layout independent of the index (`mv` is atomic at the FS level, so we just need a `transaction.atomic(): move(oldpath, newpath); snap.data_dir = newpath; snap.save()`)
- make `Tag` a real model `ManyToMany` with Snapshots
- allow multiple Snapshots of the same site over time + CLI / UI to manage those, + migration from old style `#2020-01-01` hack to proper versioned snapshots
- upgrade from Django 3 to Django 5 https://github.com/ArchiveBox/ArchiveBox/issues/988
### `v0.8: Security`
- Add CSRF/CSP/XSS protection to rendered archive pages
- Provide secure reverse proxy in front of archivebox server in docker-compose.yml
- Create UX flow for users to setup session cookies / auth for archiving private sites
- cookies for wget, curl, etc low-level commands
- localstorage, cookies, indexedb setup for chrome archiving methods
### `v0.9: Performance`
- setup huey, break up archiving process into tasks on a queue that a worker pool executes
- setup pyppeteer2 to wrap chrome so that it's not open/closed during each extractor
### `v1.0: Full headless browser control`
- run user-scripts / extensions in the context of the page during archiving
- community userscripts for unrolling twitter threads, reddit threads, youtube comment sections, etc.
- pywb-based headless browser session recording and warc replay
- archive proxy support
- support sending upstream requests through an external proxy
- support for exposing a proxy that archives all downstream traffic
...
### `v2.0 Federated or distributed archiving + paid hosted service offering`
- ZFS / merkel tree for storing archive output subresource hashes
- DHT for assigning merkel tree hash:file shards to nodes
- tag system for tagging certain hashes with human-readable names, e.g. title, url, tags, filetype etc.
- distributed tag lookup system
---
### Major long-term changes
- ✅ release **`pip`, `apt`, `pkg`, and `brew` packaged distributions** for installing ArchiveBox
- ✅ add an **optional web GUI** for managing sources, adding new links, and viewing the archive
- ✅ switch to django + **sqlite db with migrations system** & json/html export for managing archive schema changes and persistence
- modularize internals to allow importing individual components
- switch to sha256 of URL as unique link ID
- support **storing multiple snapshots** of pages over time
- support **custom user puppeteer scripts to run while archiving** (e.g. for expanding reddit threads, scrolling thread on twitter, etc)
- support named collections of archived content with different user access permissions
- support sharing archived assets via DHT + torrent / ipfs / ZeroNet / other sharing system
### Smaller planned features
- support pushing pages to multiple 3rd party services using ArchiveNow instead of just archive.org
- ✅ body text extraction to markdown (using ~~[fathom](https://hacks.mozilla.org/2017/04/fathom-a-framework-for-understanding-web-pages/)~~ readability and mercury)
- featured image / thumbnail extraction
- auto-tagging links based on important/frequent keywords in extracted text (like pocket)
- automatic article summary paragraphs from extracted text with nlp summarization library
- ✅ full-text search of extracted text with ~~elasticsearch/elasticlunr/ag~~ sonic and ripgrep
- ✅ download closed-caption subtitles from Youtube and other video sites (TODO: submit the subtitle files to the full-text search index)
- try pulling dead sites from archive.org and other sources if original is down (https://github.com/hartator/wayback-machine-downloader)
- And more in the [issues list](https://github.com/ArchiveBox/ArchiveBox/issues/)...
---
**IMPORTANT**: *Please don't work on any of these major long-term tasks without [contacting me first](https://nicksweeting.com/blog#Contact-Me), work is already in progress for many of these, and I may have to reject your PR if it doesn't align with the existing work!*
---
## Past Releases
To see how this spec has been scheduled / implemented / released so far, read these pull requests:
- ✅ v0.1.x pre-git-history (~2017)
- ✅ [v0.2.x](https://github.com/ArchiveBox/ArchiveBox/tree/483a3bef9e2b1a7b80611947a3be99b0cf4f9959) (~2018/12)
- ✅ [v0.3.x](https://github.com/ArchiveBox/ArchiveBox/pull/197) (~2019/03)
- ✅ [v0.4.x](https://github.com/ArchiveBox/ArchiveBox/pull/207) (~2019/04)
- ✅ [v0.5.x](https://github.com/ArchiveBox/ArchiveBox/pull/552) (~2020/11)
- ✅ [v0.6.x](https://github.com/ArchiveBox/ArchiveBox/pull/680) (~2021/03)
- 🏖️ `sabbatical / coding hiatus during 2022`
- ✅ [v0.7.x](https://github.com/ArchiveBox/ArchiveBox/pull/721) (~2023/11)
- 🛠 [v0.8.x](https://github.com/ArchiveBox/ArchiveBox/pull/1311) (~2024/05)
- 📅 v0.9.x up next...
---
## UI / UX Improvements Planned
- https://github.com/ArchiveBox/ArchiveBox/issues/1358
- https://github.com/ArchiveBox/ArchiveBox/issues/1273
- https://github.com/ArchiveBox/ArchiveBox/issues/988
- https://github.com/ArchiveBox/ArchiveBox/issues/930
---
## New Extractors Planned
- `gallery-dl`: https://github.com/ArchiveBox/ArchiveBox/issues/564
- `forum-dl`: https://github.com/ArchiveBox/ArchiveBox/issues/1368
- `scihub-dl`: https://github.com/ArchiveBox/ArchiveBox/issues/720
- `cad-dl`: https://github.com/ArchiveBox/ArchiveBox/issues/668
- `aria2`: https://github.com/ArchiveBox/ArchiveBox/issues/1355
- `podcast-archiver`: https://github.com/ArchiveBox/ArchiveBox/issues/1357
- `bdfr`: https://github.com/ArchiveBox/ArchiveBox/issues/778
- `cutycapt` screenshots: https://github.com/ArchiveBox/ArchiveBox/issues/253
- sourcemap downloader: https://github.com/ArchiveBox/ArchiveBox/issues/1291
[ArchiveBox Developer Documentation: Contributing a New Extractor](https://github.com/ArchiveBox/ArchiveBox#contributing-a-new-extractor)
And others we're considering for the future:
### Social Media
- Instagram
- https://github.com/instaloader/instaloader (instagram downloader)
- https://github.com/althonos/InstaLooter (stale)
- Telegram
- https://github.com/iyear/tdl (telegram downloader)
- TikTok
- https://github.com/charmparticle/tiktokget (tiktok downloader using yt-dlp)
- https://github.com/TerminalWarlord/TikTok-Downloader-Bot
- https://github.com/n0l3r/tiktok-downloader
- https://github.com/hansputera/tiktok-dl
- https://github.com/naseif/tiktok-scraper
- https://github.com/irevenko/tiktik
- https://github.com/samirelanduk/tiktok-save
- https://github.com/Dinoosauro/tiktok-to-ytdlp
- https://github.com/krypton-byte/tiktok-downloader
- Twitter
- https://github.com/HoloArchivists/twspace-dl (stale, twitter spaces archiver)
### Video/Streams
- https://github.com/soimort/you-get ⭐️
- https://github.com/lay295/TwitchDownloader
- https://github.com/ihabunek/twitch-dl
- https://github.com/iawia002/lux (generic video/audio downloader)
- https://github.com/wukko/cobalt (generic video/audio downloader)
- https://github.com/jaysonlong/webvideo-downloader (Bilibili, iQIYI, Tencent Video, MGTV and WeTV)
- https://github.com/spaam/svtplay-dl (comedy central, twitch, HBO, etc. video downloader)
- https://github.com/aajanki/yle-dl (Yle Areena Finnish broadcasting video downloader)
- https://github.com/WHTJEON/widevine-dl (encrypted widevine video downloader)
### Audio/Music
- https://github.com/nathom/streamrip (Qobuz, Tidal, Deezer and SoundCloud)
- https://github.com/0xHJK/music-dl
- https://github.com/guanguans/music-dl
- https://github.com/CharlesPikachu/musicdl
- https://github.com/iheanyi/bandcamp-dl
- https://github.com/spotDL/spotify-downloader
- https://github.com/Shabinder/SpotiFlyer
- https://github.com/SathyaBhat/spotify-dl / https://github.com/SwapnilSoni1999/spotify-dl / https://github.com/dhruv-ahuja/spoti-dl
- https://github.com/vitiko98/qobuz-dl (Qobuz music downloader)
- https://github.com/akhilrex/podgrab (stale)
- https://github.com/yaronzz/Tidal-Media-Downloader-PRO (stale)
- https://github.com/flyingrub/scdl (stale)
- https://github.com/ravishi/rdio-dl (stale, Rdio song downloader)
- https://github.com/carlosflorencio/laracasts-downloader (stale?)
### Photos/Images/Comics
- https://github.com/mikf/gallery-dl ⭐️
- https://github.com/Bionus/imgbrd-grabber (generic image board downloader like gallery-dl)
- https://github.com/Xonshiz/comic-dl (comic, anime, manga, etc. downloader)
- https://github.com/justfoolingaround/animdl (anime downloader)
- https://github.com/metafates/mangal (manga downloader)
- https://github.com/boredazfcuk/docker-icloudpd (iCloud Photos downloader)
- https://github.com/Oshan96/monkey-dl (stale? anime downloader)
- https://github.com/QianyanTech/Image-Downloader (stale?)
- https://github.com/Xonshiz/anime-dl (stale?)
### Text/Forums
- https://github.com/mikwielgus/forum-dl ⭐️
- https://github.com/AndyTheFactory/newspaper4k ⭐️
- https://github.com/AAndyProgram/SCrawler (Twitter, Reddit, Instagram, Threads, Facebook, Pinterest, nsfw sites downloader)
- https://github.com/extractus/article-extractor
- https://github.com/shadowmoose/RedditDownloader (stale?)
- https://github.com/aliparlakci/bulk-downloader-for-reddit (stale?)
### MOOC/Educational Content
- https://github.com/coursera-dl/coursera-dl
- https://github.com/rand-net/khan-dl
- https://github.com/C0D3D3V/Moodle-DL
- https://github.com/r0oth3x49/acloud-dl
- https://github.com/Puyodead1/udemy-downloader
- https://github.com/PyJun/Mooc_Downloader (stale)
- https://github.com/yann0917/dedao-dl (stale, MOOC course downloader)
- https://github.com/coursera-dl/edx-dl (stale?)
- https://github.com/SigureMo/mooc-dl (stale?)
- https://github.com/calvinhobbes23/Skillshare-DL (stale)
- https://github.com/r0oth3x49/lynda-dl (stale, Lynda.com course downloader)
### Re-Archiving / WARC Creation
- https://github.com/hartator/wayback-machine-downloader
- https://github.com/MiniGlome/Archive.org-Downloader
- https://github.com/ArchiveTeam/grab-site
- https://github.com/oduwsdl/archivenow
- https://github.com/wabarc/warcraft
- https://github.com/sul-dlss/wasapi-downloader
- https://github.com/KellyStathis/warc_downloader
- https://github.com/internetarchive/heritrix3
- https://github.com/AhmadIbrahiim/Website-downloader (wget wrapper)
- https://github.com/igrigorik/gharchive.org (stale? Github downloader)
### Other
- https://github.com/KurtBestor/Hitomi-Downloader
- https://github.com/nilaoda/BBDown
- https://github.com/biliup/biliup
- https://github.com/yutto-dev/bilili
- https://github.com/nICEnnnnnnnLee/BilibiliDown
- https://github.com/matlink/gplaycli (Google Play store Android app downloader)
- https://github.com/AlphaSlayer1964/kemono-dl (Patreon, gumroad, etc. archiver)
- https://github.com/manga-download/hakuneko
- https://github.com/cancerian0684/dli-downloader (Digital Library of India ebook downloader)
- https://github.com/tusharbabbar/gaana-dl (gaana.com bollywood song downloader)
- https://github.com/rebane2001/matterport-dl (stale? virtual house tour downloader)

86
docs/Scheduled-Archiving.md
View File

@ -1,86 +0,0 @@
# Scheduled Archiving
ArchiveBox now stores schedules in the database and lets the orchestrator materialize them into queued `Crawl` records at the right time. You no longer need host cron, user crontabs, or a separate `archivebox_scheduler` container when `archivebox server` is running.
## How It Works
1. `archivebox schedule ...` creates a `CrawlSchedule` record plus a sealed template `Crawl`.
2. The long-running global orchestrator inside `archivebox server` watches enabled schedules.
3. When a schedule becomes due, the orchestrator creates a new queued `Crawl`.
4. That queued crawl is processed the same way as UI/API-submitted work.
One-shot foreground flows such as `archivebox add ...` continue to process only the crawl they were asked to run. They do not also sweep and execute unrelated scheduled crawls.
## CLI Usage
```bash
cd ~/archivebox/data
archivebox schedule --every=daily --depth=1 https://example.com/feed.xml
archivebox schedule --every='0 */6 * * *' https://example.com/feed.xml
archivebox schedule --show
archivebox schedule --clear
archivebox schedule --run-all
archivebox schedule --foreground
```
Accepted schedule formats:
- Aliases: `minute`, `hour`, `day`, `week`, `month`, `year`, `daily`, `weekly`, `monthly`, `yearly`
- Cron expressions: e.g. `0 */6 * * *`
`archivebox schedule --run-all` enqueues every enabled schedule immediately.
`archivebox schedule --foreground` runs the global orchestrator in the foreground, which is useful outside `archivebox server` if you want a dedicated long-running scheduler/worker process without the web UI.
Running `archivebox schedule --every=day` with no `import_path` creates a recurring maintenance schedule that queues `archivebox://update` crawls.
## Docker Compose
With the new orchestrator flow, you only need the main `archivebox` service:
```yaml
services:
archivebox:
image: archivebox/archivebox:dev
command: server --quick-init 0.0.0.0:8000
volumes:
- ./data:/data
```
Create schedules with:
```bash
docker compose run --rm archivebox schedule --every=weekly --depth=1 https://example.com/feed.xml
docker compose run --rm archivebox schedule --show
```
If the main `archivebox server` container is already running, its orchestrator will pick up future scheduled runs automatically. There is no scheduler sidecar to restart.
## Examples
Archive a Twitter mirror once a week:
```bash
archivebox schedule --every=weekly --depth=1 'https://nitter.net/ArchiveBoxApp'
```
Archive a subreddit and linked discussions once a week:
```bash
archivebox config --set URL_WHITELIST='^http(s)?:\/\/(.+)?teddit\.net\/?.*$'
archivebox schedule --every=weekly --overwrite --depth=1 'https://teddit.net/r/DataHoarder/'
```
Archive Hacker News every day:
```bash
archivebox config --set URL_BLACKLIST='^http(s)?:\/\/(.+\.)?(youtube\.com)|(amazon\.com)\/.*$'
archivebox schedule --every=daily --depth=1 'https://news.ycombinator.com'
```
Queue a daily maintenance update:
```bash
archivebox schedule --every=day
```

189
docs/Security-Overview.md
View File

@ -1,189 +0,0 @@
# Security Overview
> *💬 We offer [consulting services](https://docs.monadical.com/s/archivebox-consulting-services) to set up, secure, and maintain ArchiveBox on your preferred hosting environment.*
> <sub>We use this revenue (from corporate clients who can afford to pay) to support open source development and keep ArchiveBox free.</sub>
## Web UI Permissions
```bash
archivebox config --set PUBLIC_INDEX=False # require login to access the list of Snapshots
archivebox config --set PUBLIC_SNAPSHOTS=False # require login to access Snapshot content
archivebox config --set PUBLIC_ADD_VIEW=False # require log-in to submit new URLs for archiving
archivebox manage [createsuperuser|changepassword] # create/modify admin UI users
```
See [[Setting Up Authentication]] for more...
<br/>
## ArchiveBox Use-Cases
<br/>
<img src="https://imgur.zervice.io/K3dZcjG.png" width="50px" align="right"/>
#### Archiving Public Content Only ⭐️ `[Default, recommended for most people]`
This is the default (lax) mode, intended for archiving public (non-secret) URLs without authenticating the headless browser. This is the mode used if you're archiving news articles, audio, video, etc. browser bookmarks to a folder published on your webserver. This allows you to access and link to content on `http://your.archive.com/archive...` after the originals go down.
The default mode should not be used for archiving entire browser history or authenticated private content like Google Docs, paywalled content, invite-only subreddits, private photo share urls, etc.
```bash
# (these are the defaults)
archivebox config --set SAVE_ARCHIVE_DOT_ORG=True
archivebox config --set CHROME_USER_DATA_DIR=None
archivebox config --set COOKIES_FILE=None
```
<br/>
#### Archiving Content Behind Log-Ins 🚨 `[Advanced users only]`
ArchiveBox is able to archive content that requires authentication or cookies, but it comes with some caveats. Create dedicated logins for archiving to access paywalled content, private forums, LAN-only content, etc. then share them with ArchiveBox via Chrome profile + cookies.txt file.
```bash
archivebox config --set SAVE_ARCHIVE_DOT_ORG=False
archivebox config --set CHROME_USER_DATA_DIR=/path/to/chrome/profile
archivebox config --set COOKIES_FILE=/path/to/cookies.txt
```
To get started, set [`CHROME_USER_DATA_DIR`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#chrome_user_data_dir) and [`COOKIES_FILE`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#COOKIES_FILE) to point to a Chrome user folder that has your sessions and a wget `cookies.txt` file respectively.
➡️ For full instructions on setting up a Chromium user profile see here: https://github.com/ArchiveBox/ArchiveBox/wiki/Chromium-Install#setting-up-a-chromium-user-profile
If you're importing private links or authenticated content, you probably don't want to share your archive folder publicly on a webserver, so don't follow the [[Publishing Your Archive]] instructions unless you are only serving it on a trusted LAN or have some sort of authentication in front of it. Make sure to point ArchiveBox to an output folder with conservative permissions, as it may contain archived content with secret session tokens or pieces of your user data. You may also wish to encrypt the archive using an encrypted disk image or filesystem like ZFS as it will contain all requests and response data, including session keys, user data, usernames, etc.
#### ⚠️ Things to watch out for: ⚠️
- any cookies / secret state present in a Chrome user profile or `cookies.txt` file may be [reflected in server responses and saved in the Snapshot output (e.g. in `headers.json`)](https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/extractors/headers.py) making it [visible in cleartext to anyone viewing the Snapshot](https://archive.sweeting.me/archive/1613417792.264667/headers.json), (don't use your personal Chrome profile for archiving or people viewing your archive can then authenticate as you!)
- any secret tokens embedded in URLs (e.g. secret invite links, Google Doc URLs, etc.) will be visible on `archive.org` as the URLs are not filtered [when saving to `archive.org`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/extractors/archivedotorg.py#L46) (disable submitting to Archive.org entirely with `SAVE_ARCHIVE_DOT_ORG=False`)
- the domain portion in archived URLs is [sent to a favicon service](https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/extractors/favicon.py#L43) in order to retrieve an icon more reliably than a janky internal implementation would be able to (if leaking domains is a concern, you can change the [`FAVICON_PROVIDER`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/config.py#:~:text=FAVICON_PROVIDER) or disable favicon fetching entirely with `SAVE_FAVICON=False`)
- [viewing malicious archived JS could allow an attacker to access your other archive items + the admin interface (JS executes on the same origin as the admin panel right now, fix is pending, set `SAVE_WGET=False SAVE_DOM=False` to disable the risky extractors entirely or avoid viewing their output directly in a browser)](https://github.com/ArchiveBox/ArchiveBox/issues/239)
<br/>
<img src="https://imgur.zervice.io/Jszo4h2.png" width="400px"/>
*An example of a session cookie reflected in `headers.json` visible in the archive.*
<img src="https://imgur.zervice.io/DfyQUDV.png" width="50px" align="right"/>
<br/>
---
<br/>
### Publishing
> [!CAUTION]
> Re-hosting untrusted archived content on a domain can potentially compromise *all apps on that domain*!
> (including other subdomains)
Make sure you thoroughly understand the dangers of [hosting untrusted HTML/JS/CSS that may be captured during archiving](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy), and how viewing it can enable [CSRF attacks](https://en.wikipedia.org/wiki/Cross-site_request_forgery) across all apps on the same domain. If a logged-in user happens to visit an archived page with malicious Javascript embedded, it would allow the JS to hijack any cookies on the domain and pretend to be them, potentially exfiltrating or modifying other Snapshots/data on your server.
(This is why we don't support serving ArchiveBox from a subdirectory like `myapps.example.com/archivebox/`, it's too dangerous to share domains)
The industry standard approach is to use a separate domain for untrusted content, for example Github uses `githubusercontent.com` and Google uses `googleusercontent.com` for all user-uploaded files. If hosting ArchiveBox publicly, do the same and keep it on an isolated domain in order to mitigate potential damage of leaked cookies, CORS, and CSRF attacks.
To protect the Admin dashboard, it's also recommended to serve all content under `/archive/` on a separate domain from `/admin/`. We do this on our servers using a simple redirect rule in nginx/cloudflare like so:
- https://demo.archivebox.io: only serves `/`, redirects `/archive/*` to `demo-static.`
- https://demo-static.archivebox.io: only serves `/archive/`, redirects everything else to `demo.`
<img width="400" alt="Cloudflare redirect rule for /archive/ to be served by a separate domain" src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/9c77f503-0d97-4a8d-810f-1f4400c7aa3e">
Published archives automatically include a `robots.txt` `Disallow: /` to block search engines from indexing them. You may still wish to publish your contact info in the index footer though using [`FOOTER_INFO`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#FOOTER_INFO) so that you can respond to any DMCA and copyright takedown notices if you accidentally rehost copyrighted content.
⚠️ Make sure to read all the warnings [above](https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#%EF%B8%8F-things-to-watch-out-for-%EF%B8%8F) about the dangers of exposing Chrome profile data, cookies, secret tokens in URLs, and the risks of viewing archived JS on a shared origin before publishing your archive.
More info:
- https://github.com/ArchiveBox/ArchiveBox/wiki/Publishing-Your-Archive
- https://github.com/ArchiveBox/ArchiveBox/wiki/Publishing-Your-Archive#security-concerns
- https://github.com/ArchiveBox/ArchiveBox/wiki/Publishing-Your-Archive#copyright-concerns
- https://en.wikipedia.org/wiki/Cross-site_request_forgery
- https://github.com/ArchiveBox/ArchiveBox/issues/239
<br/>
---
<br/>
## Do not run as root
<img src="https://imgur.zervice.io/yDqJc4I.jpg" width="150px" align="right"/>
> [!WARNING]
> **Did you run a command in Docker with `exec` instead of `run` by accident and end up here?**
> Make sure you use `docker run` instead of `docker exec` to run ArchiveBox commands.
>
> *For example:*
> ✅ `docker compose run archivebox manage createsuperuser`
> ✅ `docker run -it -v $PWD:/data archivebox/archivebox manage createsuperuser`
> (`docker run` automatically uses the correct `archivebox` user & file permissions enforced via [`./bin/docker_entrypoint.sh`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/bin/docker_entrypoint.sh))
>
> *instead of:*
> ❌ `docker compose exec archivebox manage createsuperuser`
> ❌ `docker exec -it archivebox manage createsuperuser`
> (`docker exec` will skip the [entrypoint](https://github.com/ArchiveBox/ArchiveBox/blob/dev/bin/docker_entrypoint.sh) and attempt to run everything as root and fail)
>
> If you must use `exec` for some reason (e.g. if you only have access to a live container shell), you can run `su archivebox` within the shell, or add the arg `--user=archivebox` after `exec`.
Do not run ArchiveBox as root for a number of reasons:
- Chrome will execute as root and fail immediately because Chrome sandboxing is pointless when the data directory is opened as root (do not set `CHROME_SANDBOX=False` just to bypass that error!)
- All dependencies will be run as root, if any of them have a vulnerability that's exploited by sites you're archiving you're opening yourself up to full system compromise
- ArchiveBox does lots of HTML parsing, filesystem access, and shell command execution. A bug in any one of those subsystems could potentially lead to deleted/damaged data on your hard drive, or full system compromise unless restricted to a user that only has permissions to access the directories needed
- Do you really trust a project created by a Github user called `@pirate` 😉? Why give a random program off the internet root access to your entire system? (I don't have malicious intent, I'm just saying in principle you should not be running random Github projects as root)
**Instead, you should run ArchiveBox under a separate user account with less privileged access:**
```bash
useradd -r -g archivebox -G audio,video archivebox # the audio & video groups are used by chrome
mkdir -p /home/archivebox/data
chown -R archivebox:archivebox /home/archivebox
...
sudo -u archivebox archivebox add ...
```
~~If you absolutely must run it as root for some reason, a footgun is provided: you can set [`ALLOW_ROOT=True`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#ALLOW_ROOT) via environment variable or in your ArchiveBox.conf file.~~ This footgun option was removed (I'm sorry, the support burden of helping people who messed up their systems by running everything as root was too high).
<img src="https://imgur.zervice.io/ca1he6I.png" width="40px" align="right"/>
<br/>
---
<br/>
## Output Folder
### Database
The ArchiveBox database is an unencrypted, uncompressed SQLite3 `index.sqlite3` file on disk, and such does not require an authenticated admin SQL login to access (like PostgreSQL/MySQL would). Make sure to protect your database file adequately as anyone who can read it can read your entire collection contents. Passwords for the admin users are stored as salted and PBKDF2 hashed strings in the `auth_user` table.
More info:
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#disk-layout
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#database-troubleshooting
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#modify-the-archivebox-sqlite3-db-directly
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#example-adding-a-new-user-with-a-hashed-password
### Filesystem
How much are you planning to archive? Only a few bookmarked articles, or thousands of pages of browsing history a day? If it's only 1-50 pages a day, you can probably just stick it in a normal folder on your hard drive, but if you want to go over 100 pages a day, you will likely want to put your archive on a compressed/deduplicated/encrypted disk image or filesystem like ZFS. Other distributed/networked/checksummed filesystems that have also been reported to work (but are not technically officially supported) include SMB, NFS, Ceph, Unraid, and BTRFS. Make sure the filesystem you're using supports FSYNC. Some filesystems are unable to store more than a certain number of directory entries, and your total number of snapshots in `./archive` may be capped as a result. Some other filesystems begin to have performance degradations but continue to function when the directory entry count gets too high. Generally this isn't an issue unless you have more than ~20,000 Snapshot folders in `./archive`.
#### Purging entries
When `--yes` is passed to `archivebox remove`, matching Snapshots are removed from the index and their archived content folders are deleted from disk. Imported URLs are also logged separately in `./sources`, `./logs`, and the Sonic full-text index `./sonic` and should be removed manually as well to clear all traces of a URL added by accident. You can search for a URL on the filesystem you're trying to remove using `grep -a -r "https://example.com/url/to/search/for"`.
#### Permissions
Consider what permissioning to apply to your archive folder carefully. Limit access to the fewest possible users by checking folder ownership and setting [`OUTPUT_PERMISSIONS`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#OUTPUT_PERMISSIONS) accordingly. Generally the `index.sqlite3` file, `archive/` folder, and `ArchiveBox.conf` file must all be owned and writable by the `archivebox` user or a dedicated non-root user.
[`PUID` & `PGID`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#puid--pgid) can be set when running with Docker to control what user and group ArchiveBox expects to own the data directory within the container.
More info:
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#disk-layout
- https://github.com/ArchiveBox/ArchiveBox#output-formats
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#database-troubleshooting
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#filesystem-doesnt-support-fsync-eg-network-mounts
- https://github.com/ArchiveBox/ArchiveBox#storage-requirements

301
docs/Setting-Up-Storage.md
View File

@ -1,301 +0,0 @@
# Setting Up Storage
> *💬 We offer [consulting services](https://docs.monadical.com/s/archivebox-consulting-services) to set up, secure, and maintain ArchiveBox on your preferred storage provider.*
> <sub>We use this revenue (from corporate clients who can afford to pay) to support open source development and keep ArchiveBox free.</sub>
<br/>
ArchiveBox supports a wide range of local and remote filesystems using `rclone` and/or Docker storage plugins. The examples below use [Docker Compose bind mounts](https://docs.docker.com/storage/bind-mounts/) to demonstrate the concepts, you can adapt them to your OS and environment needs.
Example [`docker-compose.yml`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/docker-compose.yml) storage setup:
```yaml
services:
archivebox:
...
volumes:
# your index db, config, logs, etc. should be stored on a local SSD (usually <10Gb)
- ./data:/data
# but bulk archive/ content can be located on an HDD or remote filesystem
- /mnt/archivebox-s3/data/archive:/data/archive
```
<h4>Related Docs</h4>
<ul>
<li><a href="https://github.com/ArchiveBox/ArchiveBox#archive-layout">README: Archive Layout</a></li>
<li><a href="https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#Disk-Layout">Wiki: Usage (Disk Layout)</a></li>
<li><a href="https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#large-archives">Wiki: Usage (Large Archives)</a></li>
<li><a href="https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#output-folder">Wiki: Security Overview (Output Folder)</a></li>
<li><a href="https://github.com/ArchiveBox/ArchiveBox/wiki/Publishing-Your-Archive">Wiki: Publishing Your Archive</a></li>
<li><a href="https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives">Wiki: Upgrading or Merging Archives</a></li>
<li><a href="https://github.com/ArchiveBox/ArchiveBox/wiki/Troubleshooting#other-database-or-filesystem-issues">Wiki: Troubleshooting Filesystem Issues</a></li>
</ul>
---
## Supported Local Filesystems
<img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/45abfe78-87c4-4c87-ab11-9dae2f3b2518" alt="local filesystem icon" width="80px" align="right"/>
<a name="ext4"></a><a name="apfs"></a>
### `EXT4` (default on Linux), `APFS` (default on macOS)
> [!TIP]
> These default filesystems are fully supported by ArchiveBox on Linux and macOS (w/wo Docker).
<a name="zfs"></a>
### `ZFS` (recommended for best experience on Linux/BSD) ⭐️
> [!TIP]
> *This is the recommended filesystem for ArchiveBox on Linux, macOS, and BSD (w/wo Docker).*
> [`apt install zfsutils-linux`](https://openzfs.github.io/openzfs-docs/Getting%20Started/Ubuntu/index.html)
> <sub>Provides RAID, compression, encryption, deduping, 0-cost point-in-time backups, remote sync, integrity verification, and more...</sub>
- https://openzfs.github.io/openzfs-docs/
- https://openzfs.github.io/openzfs-docs/man/v2.2/8/zpool-create.8.html
- https://openzfs.github.io/openzfs-docs/man/v2.2/8/zfs-create.8.html
- https://docs.docker.com/storage/storagedriver/zfs-driver/
- https://www.ixsystems.com/blog/fast-dedup-is-a-valentines-gift-to-the-openzfs-and-truenas-communities/
```bash
# create a new archivebox pool to hold your dataset
zpool create -f \
-O mountpoint=/mnt/archivebox \
-O sync=standard \
-O compression=lz4 \
-O recordsize=128K \
-O dnodesize=auto \
-O atime=off \
-O xattr=sa \
-O acltype=posixacl \
-O aclinherit=passthrough \
-O utf8only=on \
-O normalization=formD \
-O casesensitivity=sensitive \
archivebox /dev/disk/by-uuid/disk1... /dev/disk/by-uuid/disk2...
# create the archivebox/data ZFS dataset
zfs create \
-o mountpoint=/mnt/archivebox/data \
archivebox/data
# optional: add encryption
-o encryption=on \
-o keysource=passphrase,prompt \
```
<a name="ntfs"></a><a name="hfs"></a><a name="btrfs"></a>
### `NTFS`, `HFS+`, `BTRFS`
> [!WARNING]
> These filesystems are likely supported, but are not officially tested.
<a name="ext2"></a><a name="ext3"></a><a name="fat32"></a><a name="exfat"></a>
### `EXT2`, `EXT3`, `FAT32`, `exFAT`
> [!CAUTION]
> Not recommended. Cannot store files >4GB or more than 31k ~ 65k Snapshot entries due to directory entry limits.
<br/>
---
<br/>
<a name="remote-filesystems"></a>
## Supported Remote Filesystems
<img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/6124b92a-df5a-47c4-b3c2-006ebd28785b" alt="local filesystem icon" width="80px" align="right"/>
ArchiveBox supports many common types of remote filesystems using RClone, FUSE, Docker Storage providers, and Docker Volume Plugins.
The `data/archive/` subfolder contains the bulk archived content, and it supports being stored on a slower remote server (SMB/NFS/SFTP/etc.) or object store (S3/B2/R2/etc.). For data integrity and performance reasons, the rest of the `data/` directory (`data/ArchiveBox.conf`, `data/logs`, etc.) must be stored locally while ArchiveBox is running.
> [!IMPORTANT]
> `data/index.sqlite3` is your main archive DB, *it must be on a fast, reliable, local filesystem* which supports [FSYNC](https://stackoverflow.com/questions/40849596/git-clone-fsync-input-output-error-in-linux#:~:text=Some%20filesystems%20%2D%20especially%20remote%20filesystems%20like%20NFS%2C%20sshfs%2C&text=do%20not%20support%20fsync()%20but%20git%20has%20no%20flag%20to%20disable%20these%20calls) (SSD/NVMe recommended for best experience).
> [!TIP]
> If you use a remote filesystem, you should switch ArchiveBox's search backend from [`ripgrep`](https://github.com/ArchiveBox/ArchiveBox/wiki/Setting-up-Search#ripgrep) to [`sonic`](https://github.com/ArchiveBox/ArchiveBox/wiki/Setting-up-Search#sonic) (or [`FTS5`](https://github.com/ArchiveBox/ArchiveBox/wiki/Setting-up-Search#fts5)).
> <sub>(`ripgrep` scans over every byte in the archive to do each search, which is **slow and potentially costly** on remote cloud storage)</sub>
<a name="nfs"></a>
### `NFS` (Docker Driver)
`docker-compose.yml`:
```yaml
services:
archivebox:
volumes:
- ./data:/data
- archivebox-archive:/data/archive
volumes:
archivebox-archive:
driver_opts:
type: "nfs"
o: "addr=some-remote-server.example.com,nolock,soft,rw,nfsvers=4"
device: ":/archivebox-archive"
```
<a name="smb"></a><a name="ceph"></a>
### `SMB` / `Ceph` (Docker CIFS Driver)
`docker-compose.yml`:
```yaml
services:
archivebox:
volumes:
- ./data:/data
- archivebox-archive:/data/archive
volumes:
archivebox-archive:
driver: local
driver_opts:
type: cifs
device: "//some-remote-server.example.com/archivebox-archive"
o: "username=XXX,password=YYY,uid=911,gid=911"
```
<br/>
<img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/0a159c27-5d54-46b9-814b-480f239ed27e" alt="local filesystem icon" height="80px" align="right"/><img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/5ca561b4-4597-401f-84b6-d53042fd7359" alt="local filesystem icon" height="80px" align="right"/>
<a name="s3"></a><a name="b2"></a><a name="gdrive"></a><a name="rclone"></a>
### Amazon S3 / Backblaze B2 / Google Drive / etc. (RClone)
```bash
# install the RClone and FUSE packages on your host
apt install rclone fuse # or brew install
# IMPORTANT: needed to allow FUSE drives to be shared with Docker
echo 'user_allow_other' >> /etc/fuse.conf
```
Then define your remote storage config `~/.config/rclone/rclone.conf`:
> [!TIP]
> You can also create `rclone.conf` using the RClone Web GUI: `rclone rcd --rc-web-gui`
```ini
# Example rclone.conf using Amazon S3 for storage:
[archivebox-s3]
type = s3
provider = AWS
access_key_id = XXX
secret_access_key = YYY
region = us-east-1
```
#### RClone Config Examples
- [SMB](https://rclone.org/smb/) / [Ceph](https://rclone.org/s3/#ceph) / [SFTP](https://rclone.org/sftp/) / [FTP](https://rclone.org/ftp/) / [WebDAV (e.g. Nextcloud)](https://rclone.org/webdav/)
- [Google Drive](https://rclone.org/drive/) / [Dropbox](https://rclone.org/dropbox/) / [OneDrive](https://rclone.org/onedrive/)
- [Amazon S3](https://rclone.org/s3/#configuration) / [Backblaze B2](https://rclone.org/b2/) / [Cloudflare R2](https://rclone.org/s3/#cloudflare-r2) / [DigitalOcean Spaces](https://rclone.org/s3/#digitalocean-spaces)
- [Google Cloud Storage](https://rclone.org/s3/#google-cloud-storage) / [Azure Blob](https://rclone.org/azureblob/) / [Azure Files](https://rclone.org/azurefiles/)
- [Storj](https://rclone.org/s3/#storj) / [Sia](https://rclone.org/sia/) / [Archive.org Storage](https://rclone.org/internetarchive/)
- And many more...
- https://rclone.org/s3/
- https://rclone.org/overview/
*Bonus:*
- Set up gzip compression: https://rclone.org/compress/
- Set up file encryption: https://rclone.org/crypt/
- Set up hashing engine: https://rclone.org/hasher/
<br/>
#### Option A: Running RClone on Bare Metal host
1. *If Needed:* Transfer any existing local archive data to the remote volume first
```bash
rclone sync --fast-list --transfers 20 --progress /opt/archivebox/data/archive/ archivebox-s3:/data/archive
mv /opt/archivebox/data/archive /opt/archivebox/data/archive.localbackup
```
2. **Mount the remote storage volume as FUSE filesystem**
```
rclone mount
--allow-other \ # essential, allows Docker to access FUSE mounts
--uid 911 --gid 911 \ # 911 is the default used by ArchiveBox
--vfs-cache-mode=full \ # cache both file metadata and contents
--transfers=16 --checkers=4 \ # use 16 threads for transfers & 4 for checking
archivebox-s3/data/archive:/opt/archivebox/data/archive # remote:local
```
See here for full more detailed instructions here: [RClone Documentation: The `rclone mount` command](https://rclone.org/commands/rclone_mount/)
> [!TIP]
> You can use any RClone FUSE mounts as a normal volumes (bind mount) for Docker ArchiveBox, typically no storage plugin is needed as long as `allow-other` is setup properly.
`docker run -v $PWD:/data -v /opt/archivebox/data/archive:/data/archive`
`docker-compose.yml`:
```yaml
services:
archivebox:
...
volumes:
- ./data:/data
- /opt/archivebox/data/archive:/data/archive
```
<br/>
#### Option B: Running RClone with Docker Storage Plugin
*This is only needed if you are unable to `Option A` for compatibility or performance reasons, or if you prefer defining your remote storage config in `docker-compose.yml` instead of `rclone.conf`.*
See here for full instructions: [RClone Documentation: Docker Plugin](https://rclone.org/docker/)
1. First, install the [Rclone Docker Volume Plugin](https://rclone.org/docker/#installing-as-managed-plugin) for your CPU architecture (e.g. `amd64` or `arm64`):
```bash
docker plugin install rclone/docker-volume-rclone:amd64 --grant-all-permissions --alias rclone
ln -sf ~/.config/rclone/rclone.conf /var/lib/docker-plugins/rclone/config/rclone.conf
```
2. Then, [create a volume using the Docker CLI](https://rclone.org/docker/#creating-volumes-via-cli) or [define one using Docker Compose / Swarm](https://rclone.org/docker/#using-with-swarm-or-compose):
`docker-compose.yml`:
```yaml
services:
archivebox:
volumes:
- ./data:/data
- archivebox-s3:/data/archive
volumes:
archivebox-s3:
driver: rclone
driver_opts:
remote: 'archivebox-s3/data/archive'
allow_other: 'true'
vfs_cache_mode: full
poll_interval: 0
uid: 911
gid: 911
transfers: 16
checkers: 4
```
To start the container and verify the filesystem is accessible within it:
```bash
docker compose run archivebox /bin/bash 'ls -lah /data/archive/ | tee /data/archive/.write_test.txt'
```
<br/>
---
<br/>
### More Docker Storage Plugins
- [IPFS](https://github.com/djdv/go-filesystem-utils/pull/40) / [Peergos](https://github.com/peergos/peergos) / [GlusterFS](https://github.com/calavera/docker-volume-glusterfs)
- [DigitalOcean Block Storage Volumes](https://github.com/djmaze/dobs-volume-plugin) / [Linode Block Storage Volumes](https://github.com/linode/docker-volume-linode)
- [More volume plugins...](https://docs.docker.com/engine/extend/legacy_plugins/#volume-plugins)

245
docs/Setting-up-Authentication.md
View File

@ -1,245 +0,0 @@
# Setting Up Authentication
> *💬 We offer [consulting services](https://docs.monadical.com/s/archivebox-consulting-services) to set up, integrate, and maintain ArchiveBox with your org's auth & hosting.
> If you need support, advanced development to capture difficult sites, audit logging, and more, we can provide it!*
> <sub>We use this revenue (from corporate clients who can afford to pay) to support open source development and keep ArchiveBox free.</sub>
---
ArchiveBox supports several types of authentication for users logging in via the Admin Web UI or REST API.
## Set Up Admin Web UI Permissions
<img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/024913f0-ad2c-463c-aa4a-eb3d0ec8eb64" alt="Non-admin user permissions are only available to paying ArchiveBox clients" width="200px" align="right">
Use these three options to set up your desired permissions for non-admin guest users:
- [`PUBLIC_INDEX=True`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#public_index--public_snapshots--public_add_view): Default *allows* non-logged-in users to see Snapshot list
- [`PUBLIC_SNAPSHOTS=True`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#public_index--public_snapshots--public_add_view): Default *allows* non-logged-in users to see Snapshot content
- [`PUBLIC_ADD_VIEW=False`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#public_index--public_snapshots--public_add_view): Default *doesn't allow* non-logged-in users to submit new URLs
> [!NOTE]
> **Open source ArchiveBox does not support setting up *non-admin* users** & groups with custom permissions. We do offer this feature, audit logging, and more to [paying clients](https://docs.monadical.com/s/archivebox-consulting-services).
- [Wiki: Configuration (`PUBLIC_ADD_VIEW`, `PUBLIC_SNAPSHOTS`, `PUBLIC_INDEX`)]()
- [Wiki: Security Overview](https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview)
<br/>
<br/>
## Admin Web UI Authentication Methods
<br/>
### Username & Password (the default)
You need a user account to access the Admin UI, you can run the commands below to create/edit a user from the CLI:
```bash
archivebox manage createsuperuser
archivebox manage changepassword <username>
# equivalent: docker compose run archivebox manage [...]
# equivalent: docker run -v $PWD:/data archivebox/archivebox manage [...]
```
> [!TIP]
> If using Docker, you can set [`ADMIN_USERNAME` & `ADMIN_PASSWORD`](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#admin_username--admin_password) to auto-create an admin account on first run.
Existing users can be managed from the Admin UI here: [`/admin/auth/user/`](http://127.0.0.1:8000/admin/auth/user/),
and you can change your password in the UI here: [`/admin/password_change/`](http://127.0.0.1:8000/admin/password_change/).
<br/>
<br/>
### Reverse Proxy Authentication
> Can be used with a reverse proxy auth provider like [oauth2-proxy](https://github.com/oauth2-proxy/oauth2-proxy), [Cloudflare Zero Trust](https://developers.cloudflare.com/cloudflare-one/tutorials/access-workers/#create-a-worker-with-custom-headers), [Authentik](https://docs.goauthentik.io/docs/providers/proxy/), and others.
Set these ArchiveBox configuration values based on your reverse proxy setup and needs:
```bash
# REQUIRED: the header where your upstream reverse proxy will place the authenticated user's username/email
# EXAMPLE: Cf-Access-Authenticated-User-Email (if using Cloudflare Access / Zero Trust)
REVERSE_PROXY_USER_HEADER=X-Remote-User
# REQUIRED: the IP/CIDR of your upstream reverse proxy server
# WARNING: make sure this range contains ONLY your reverse proxy server!
# ArchiveBox will completely trust any IP in this range for authentication
REVERSE_PROXY_WHITELIST=192.0.2.3/32
# OPTIONAL: redirect users to an external URL after they log out
LOGOUT_REDIRECT_URL=https://auth.yourcompany.example.com/after/logout
```
- https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#reverse_proxy_user_header
- https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#reverse_proxy_whitelist
- https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#logout_redirect_url
- https://github.com/ArchiveBox/ArchiveBox/pull/866
<br/>
### LDAP Authentication
> Can be used with an SSO provider like [Authentik](https://github.com/goauthentik/authentik), [Authelia](https://github.com/authelia/authelia), [Okta / Auth0](https://www.okta.com/), [Keycloak](https://www.keycloak.org/), and others.
First, `pip`-install the `ldap` add-on to use this feature (not needed for Docker Archivebox).
```bash
pip install archivebox[ldap]
```
Then set these configuration values to finish configuring LDAP:
```bash
LDAP=True
LDAP_SERVER_URI="ldap://ldap.example.com:3389"
LDAP_BIND_DN="ou=archivebox,ou=services,dc=ldap.example.com"
LDAP_BIND_PASSWORD="secret-bind-user-password"
LDAP_USER_BASE="ou=users,ou=archivebox,ou=services,dc=ldap.example.com"
LDAP_USER_FILTER="(objectClass=user)"
LDAP_USERNAME_ATTR="uid"
LDAP_FIRSTNAME_ATTR="givenName"
LDAP_LASTNAME_ATTR="sn"
LDAP_EMAIL_ATTR="mail"
```
- https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#ldap
- https://github.com/ArchiveBox/ArchiveBox/pull/1214
- https://github.com/django-auth-ldap/django-auth-ldap#example-configuration
- https://jumpcloud.com/blog/what-is-ldap-authentication
<br/>
### Not Yet Supported: SAML / OAuth2 / OpenID Authentication
> *We'd welcome PRs to add support for these using `django-allauth`!*
These methods are not natively supported by ArchiveBox at the moment. However it is still possible to use them with ArchiveBox by running your own [IdP (Identity Provider)](https://www.cloudflare.com/learning/access-management/what-is-an-identity-provider/) server to act as a bridge (e.g. [Authentik](https://docs.goauthentik.io/docs/providers/saml/), [Authelia](https://www.authelia.com/configuration/identity-providers/introduction/#openid-connect-10), [oauth2-proxy](https://github.com/oauth2-proxy/oauth2-proxy)).
The IdP server can act as a middleman gateway to authenticate users using an external SAML/OAuth/OpenID/etc. provider (e.g. Google, Microsoft, Github, Facebook, etc.), and then pass on the authenticated user's session info to ArchiveBox using LDAP or reverse proxy headers (as described above).
- https://www.cloudflare.com/learning/access-management/what-is-saml/
- https://docs.goauthentik.io/docs/providers/saml/
- https://docs.goauthentik.io/docs/providers/oauth2/
- https://www.authelia.com/configuration/identity-providers/introduction/#openid-connect-10
- https://github.com/oauth2-proxy/oauth2-proxy
- https://oauth2-proxy.github.io/oauth2-proxy/configuration/overview
<br/>
---
<br/>
## REST API
The REST API (available starting in v0.8.0) supports several methods of authentication for convenience.
To see API docs, try endpoints interactively, and see how auth works, visit this URL on your ArchiveBox server:
[`http://127.0.0.1:8000/api/v1/docs`](http://127.0.0.1:8000/api/v1/docs)
<img width="500" alt="Screenshot of django-ninja Swagger API docs page" src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/ad914143-f48b-4d4e-aa8c-f89a2c70cee7">
<br/><br/>
To get started using the REST API, you can generate an API key for your user in the Admin Web UI:
[`http://127.0.0.1:8000/admin/api/apitoken/add/`](http://127.0.0.1:8000/admin/api/apitoken/add/)
or by calling the `http://127.0.0.1:8000/api/v1/auth/get_api_token` endpoint with a username & password:
```bash
curl -X 'POST' \
'http://127.0.0.1:8000/api/v1/auth/get_api_token' \
-H 'Content-Type: application/json'
-d '{"username": "YOURUSERNAMEHERE", "password": "YOURPASSWORDHERE"}'
```
<br/>
> [!TIP]
> Bearer Tokens are the recommended method for the best balance of security and convenience.
### API Bearer Token Authentication
Pass `Authorization=Bearer YOURAPITOKENHERE` as a request header.
```bash
curl -X 'GET' \
'http://127.0.0.1:8000/api/v1/core/snapshots?limit=10' \
-H 'accept: application/json' \
-H 'Authorization: Bearer YOURAPITOKENHERE'
```
### API Request Header Authentication
> This method is provided in case you have a reverse proxy in front of ArchiveBox that consumes the bearer header.
Pass `X-ArchiveBox-API-Key=YOURAPITOKENHERE` as a request header.
```bash
curl -X 'GET' \
'http://127.0.0.1:8000/api/v1/core/snapshots?limit=10' \
-H 'accept: application/json' \
-H 'X-ArchiveBox-API-Key: YOURAPITOKENHERE'
```
<br/>
### API Query Parameter Authentication
> [!WARNING]
> This method is sometimes known as ["Capability URLs"](https://w3ctag.github.io/capability-urls/) because anyone in possession of the URL can perform API actions. It comes with [important security caveats](https://security.stackexchange.com/questions/118975/is-it-safe-to-include-an-api-key-in-a-requests-url) and is not recommended unless you fully understand the risks.
Pass `api_key=YOURAPITOKENHERE` as a GET/POST query parameter.
```bash
curl -X 'GET' \
'http://127.0.0.1:8000/api/v1/core/snapshots?limit=10&api_key=YOURAPITOKENHERE' \
-H 'accept: application/json'
```
<br/>
### API Session Cookie Authentication
> [!CAUTION]
> We recommend sticking to header-based authentication and not using this method unless you deeply understand the CSRF/CORS security risks.
> This method is mostly useful when accessing the API from external apps where CSRF/CORS is not a concern (e.g. `curl`, mobile apps, other servers, etc.).
> Browsers enforce that requests made to the ArchiveBox API from *other origins* will not include any session cookies by default. This is is a [foundational security principle of the web](https://docs.djangoproject.com/en/5.0/ref/csrf/) that protects you from API requests being initiated by JS on websites you don't control (aka CSRF/CORS attacks).
>
> To allow incoming POST/PUT/DELETE requests from other domains **that you trust**, you must add them to [`CSRF_TRUSTED_ORIGINS`](https://docs.djangoproject.com/en/5.0/ref/settings/#csrf-trusted-origins) in the `archivebox/core/settings.py` source code on your machine ([open an issue](https://github.com/ArchiveBox/ArchiveBox/issues/new/choose) and explain your use-case for help).
Log in via the Admin Web UI: `/admin/login/`, you can then re-use your login session id (stored in the `sessionid` cookie) for REST API requests. By default, this only allows you to make requests from the same domain ArchiveBox is being served on (e.g. from browser devtools open on an ArchiveBox page or CLI tools).
```bash
curl -X 'GET' \
'http://127.0.0.1:8000/api/v1/core/snapshots?limit=10' \
-H 'accept: application/json' \
-H 'Cookie: sessionid=YOURSESSIONIDVALUEHERE'
```
<br/>
### API HTTP Basic Authentication
> [!CAUTION]
> This method is fairly uncommon and is only useful in a few niche situations where the other methods are not available.
> **We will likely remove this method in a future ArchiveBox release if nobody uses it.**
> *If you rely on this method and want us to keep it, please [open an issue](https://github.com/ArchiveBox/ArchiveBox/issues/new/choose) and explain your use-case!*
Pass your ArchiveBox admin username & password via HTTP Basic Authentication.
```bash
curl -X 'GET' \
'http://127.0.0.1:8000/api/v1/core/snapshots?limit=10' \
-u 'YOURUSERNAMEHERE:YOURPASSWORDHERE'
-H 'accept: application/json'
```
<br/>
#### Further Reading
- The ArchiveBox API auth implementation: [`archivebox/api/auth.py`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/api/auth.py#:~:text=API_AUTH_METHODS) + [`archivebox/api/v1_auth.py`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/api/v1_auth.py)
- The [`django-ninja` auth documentation](https://django-ninja.dev/guides/authentication/) (which powers our API)
- The [Swagger auth documentation](https://swagger.io/docs/specification/authentication/) for the interactive API Docs UI

258
docs/Setting-up-Search.md
View File

@ -1,258 +0,0 @@
# Setting Up Search
## How to Search in ArchiveBox
You can search your ArchiveBox data in a number of ways:
- using the CLI: `archivebox list --filter-type=search 'text to search'` (`archivebox list --help` for more)
- using the Web UI: both the `/public` index and `/admin/core/snapshot` pages provide a search box
- using the REST API: `/api/v1/list?filter_type=search` provides the same search interface as the CLI
- by searching the archive data folder directly with external tools (e.g. macOS Spotlight, [Cerebro](https://www.cerebroapp.com/), `ag`, [Yacy](https://yacy.net/), etc.)
![image](https://github.com/ArchiveBox/ArchiveBox/assets/511499/637675ee-bf4a-49f9-b936-c2da1bd64410)
<br/>
---
## How Search Works
ArchiveBox search works by doing substring matches in `Snapshot` metadata fields (`url`, `title`, `timestamp`, `tags`), and by searching the full archived content within each Snapshot (using the selected search backend below). You can find the search implementation source code here: [`archivebox/core/views.py: PublicIndex.get_queryset()`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/core/views.py#:~:text=title__icontains).
> *Note: ArchiveBox currently only returns the bare list of snapshots that match when performing a search.*
>
> This will be [improved in the future](https://zulip.archivebox.io/#narrow/stream/154-support/topic/Full.20Text.20Search.20works.2E.2E.2E.20but.20is.20there.20a.20UI.3F) to highlight the *specific paragraph/line/area that matched* within a Snapshot.
> For now we recommend using Ctl+F in the browser or one of the external tools listed above to further filter for a term within a Snapshot's contents.
<br/>
## ArchiveBox Search Backends
ArchiveBox provides a number of "Search Backend Engines" to tune its performance & behavior for different use-cases.
```bash
# this setting controls which search backend ArchiveBox uses
archivebox config --set SEARCH_BACKEND_ENGINE=[ripgrep]|sonic|sqlite
# to see information about the backend you are currently using, run:
archivebox version
archivebox config --get SEARCH_BACKEND_ENGINE
```
By default out-of-the-box, the selected engine is a simple but efficient tool similar to `grep -r` called [`ripgrep`](https://github.com/BurntSushi/ripgrep).
Ripgrep is [currently the fastest](https://blog.burntsushi.net/ripgrep/) available *filesystem search* tool that scans over the raw archived files on every search. We chose it as the default so that beginners and 95% of users with small collections can have an experience that "just works", without needing to install and maintain complex additional dependencies or background workers.
However, there are some fundamental limitations of scanning through every file on disk each time a search is done, so ArchiveBox provides a number of additional search backend options for when users outgrow `ripgrep`.
> [!TIP]
> **You should consider switching ArchiveBox to use `sonic` or another backend IF:**
>
> - you have more than 1,000 Snapshots saved in your archive
> - your archive data is stored on a slower filesystem like a spinning hard drive or remote network mount
> - you want more advanced search features like stemming, boolean operators, and ability to search PDFs, eBooks, ZIP/tar files, etc.
<br/>
<a name="ripgrep"></a>
### `ripgrep` *(the default)*
If you do not already have `ripgrep` installed, follow the [instructions here](https://github.com/BurntSushi/ripgrep#installation) to get it.
ArchiveBox will use `ripgrep` by default if it is found, however you can explicitly configure it to be used like so:
```bash
archivebox config --set SEARCH_BACKEND_ENGINE=ripgrep
archivebox config --set RIPGREP_BINARY=rg
# check that archivebox detects the installed version:
archivebox version
# then try it out by searching via the Web UI or CLI:
archivebox list --filter-type=search 'text to search for'
```
#### Pros
- supports advanced searching with regex patterns
- simple, few moving parts, and broadly available for all OSs and CPU architectures
- 0 idle resource use as there is no background indexer process running
- 0 additional disk storage needed as it searches the original data instead of maintaining a separate index
- reasonably fast on NVMe and SSD drives for small collections
#### Cons
- very slow as archive collection size increases (doesn't scale well beyond 500~1,000 Snapshots)
- very slow if underlying filesystem is slow (e.g. HDDs or network mounts)
- doesn't support stemming, boolean operators, or other advanced full-text search features
<br/>
<a name="ripgrep-all"></a>
### `ripgrep-all` (aka `rga`)
The same as ripgrep except that it supports searching more binary filetypes like PDFs, eBooks, Office documents, zip, tar.gz, etc.
To use it, follow the [install instruction for your OS](https://github.com/phiresky/ripgrep-all#installation), then configure ArchiveBox to use it like so:
```bash
archivebox config --set SEARCH_BACKEND_ENGINE=ripgrep
archivebox config --set RIPGREP_BINARY=rga
# check that archivebox detects the installed version:
archivebox version
# then try it out by searching via the Web UI or CLI:
archivebox list --filter-type=search 'text to search for'
```
<br/>
<a name="ugrep"></a>
### `ugrep`
Not tested by the ArchiveBox team but it's very similar to `ripgrep` and may work as a drop-in replacement, with some caveats. (contributions welcome to improve support)
`ugrep` is similar to `ripgrep` and `ripgrep-all` in that it's an indexless disk-search tool, but it provides some more of the full-text search features without the performance overhead of maintaining a separate search backend worker with an independent index.
https://github.com/Genivia/ugrep
```bash
archivebox config --set RIPGREP_BINARY=ugrep+
```
#### Pros
- supports [boolean operators](https://github.com/Genivia/ugrep#bool) in search queries
- supports binary formats like compressed archives, PDFs, eBooks, etc.
- better support for Unicode, special characters, and searching across multiple lines of text
- supports [fuzzy search](https://github.com/Genivia/ugrep#fuzzy)
#### Cons
- not as fast as `sonic` and but also not as simple as `ripgrep`
- not all of its features are fully integrated with ArchiveBox yet
<br/><br/>
<a name="sonic"></a>
### `sonic` ⭐️ (the recommended upgrade path for most people)
[Sonic](https://github.com/valeriansaliou/sonic) is a fast, lightweight, rust-based alternative to super-heavy traditional search backends like Elasticsearch. It is capable of normalizing natural language search queries, fuzzy matching, and searching Unicode, without needing to maintain a duplicate document store index of all the searchable text.
Internally it functions as an index store, storing only the original IDs of the Snapshots with a super-compressed representation of the text. This allows it to scale to searching terabytes of archive data while maintaining an index only a fraction of that size.
*ArchiveBox has supported Sonic for years, and it is the most thoroughly tested and recommended backend for ArchiveBox users that need to scale beyond `ripgrep`.*
Using [sonic with ArchiveBox in Docker Compose](https://github.com/ArchiveBox/ArchiveBox/blob/dev/docker-compose.yml) is the easiest way to get started, though you can also use it without Docker by [installing it manually](https://github.com/valeriansaliou/sonic#installation) and then running `pip install archivebox[sonic]`.
```bash
# edit docker-compose.yml to uncomment the lines that enable sonic
nano docker-compose.yml
# make sure ArchiveBox is configured to use the Sonic backend
docker compose run archivebox config --set SEARCH_BACKEND_ENGINE=sonic
# restart the containers to apply changes and start the Sonic worker
docker compose down
docker compose up
# check that the sonic container started without issues
docker compose logs sonic
docker compose run archivebox version
# backfill any existing archivebox data into the Sonic index (may take an hour or longer depending on storage speed and collection size)
docker compose run archivebox update --index-only
# then test it out:
docker compose run archivebox list --filter-type=search 'some text to search'
```
*Fore more detailed instructions [see here](https://github.com/ArchiveBox/ArchiveBox/issues/956#issuecomment-1320587158)...*
#### Pros
- extremely fast, most queries complete in microseconds even with 100k+ snapshots
- maintains lightweight, compressed search index that is minuscule compared to original data
- all-in-one binary written in rust, available cross-platform and easy to deploy
- supports advanced full-text search features like normalization, stemming, etc.
- supports indexing and querying on a remote server (many ArchiveBox instances can share a single `sonic` instance)
#### Cons
- one extra dependency to install and background worker to keep running (Docker Compose makes this easy though)
- does not support searching binary files like PDFs, eBooks, compressed archives, etc.
<br/>
<a name="fts5"></a>
### `SQLite FTS5`
This is a [recently added](https://github.com/ArchiveBox/ArchiveBox/pull/1241) experimental option that uses a separate SQLite3 Database (similar to the one ArchiveBox already uses for Snapshot metadata) to provide full-text search.
```bash
archivebox config --set SEARCH_BACKEND_ENGINE=sqlite
# add existing data to index by running update:
archivebox update --index-only
# test it out using the archivebox Web UI or CLI:
archivebox list --filter-type=search 'some text to search'
# or using SQLite3 directly;
sqlite3 ./search.sqlite3
> SELECT snapshot_id FROM snapshot_fts
INNER JOIN snapshot_id_fts ON snapshot_id_fts.rowid = snapshot_fts.rowid
WHERE snapshot_fts MATCH "some text to search";
```
```bash
# optional advanced tuning:
archivebox config --set FTS_SEPARATE_DATABASE=True
archivebox config --set FTS_TOKENIZERS="porter unicode61 remove_diacritics 2"
archivebox config --set FTS_SQLITE_MAX_LENGTH=1000000000
```
- https://www.sqlite.org/fts5.html
- https://github.com/ArchiveBox/ArchiveBox/pull/1241
#### Pros
- No additional dependencies needed to install, SQLite3 is already available and used by ArchiveBox
- No long-running background search worker process needed, 0 idle resource use
- Supports advanced full-text search features like boolean operators, stemming, phrases, etc.
- Comparable speed and efficiency to `sonic` for most use-cases (much faster than `ripgrep`/`ugrep`)
- Durability and portability, SQLite is widely used and supported by every major platform on earth
#### Cons
- Not as thoroughly-tested by ArchiveBox team as our `sonic` or `ripgrep` backends
- Maintains a (compressed, but still potentially large) duplicate copy of all searchable text in `search.sqlite3` db
- Does not support searching binary files PDFs, eBooks, compressed archives, etc.
- Search indexing and querying must be performed on same server as ArchiveBox data (we don't yet support sending FTS5 queries to a remote server)
<br/>
---
<br/>
### Further Reading
- https://github.com/ArchiveBox/ArchiveBox/blob/dev/docker-compose.yml#:~:text=SEARCH_BACKEND_ENGINE
- https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#ripgrep_binary
* [#22 Original Issue where full-text search functionality was proposed](https://github.com/ArchiveBox/ArchiveBox/issues/22)
* [#543 + #570 Original PR where full-text search functionality was implemented](https://github.com/ArchiveBox/ArchiveBox/pull/543)
* [#956 Documentation: Document how search works](https://github.com/ArchiveBox/ArchiveBox/issues/956#issuecomment-1320587158)
* [#654 Support: Search Backend only searching admin Snapshot fields instead of archive content](https://github.com/ArchiveBox/ArchiveBox/issues/654)
* [#1087 Support: Help setting up full text search](https://github.com/ArchiveBox/ArchiveBox/issues/1087)
* [#1091 Support: Help switching to ripgrep-all](https://github.com/ArchiveBox/ArchiveBox/issues/1091)
* [#1318 Troubleshooting: Search times out on v0.7.2 installed on Synology using Portainer](https://github.com/ArchiveBox/ArchiveBox/issues/1318)
* [#1333 + #1316 Text Search and Filters don't work at the same time in the web UI](https://github.com/ArchiveBox/ArchiveBox/pull/1333)
* [#1320 Troubleshooting: Sonic backend Error: ENDED authentication_failed doesn't contain protocol(NUMBER)](https://github.com/ArchiveBox/ArchiveBox/pull/1320)
- [#1139 Feature Request: Add AI-assisted summarization, tagging, search, and more using LLMs / RAG](https://github.com/ArchiveBox/ArchiveBox/issues/1139)
- [#1358 Django Admin general improvements: tree view, better filters, better sorting, custom pages, etc.](https://github.com/ArchiveBox/ArchiveBox/issues/1358)

335
docs/Troubleshooting.md
View File

@ -1,335 +0,0 @@
# Troubleshooting
▶️ *If you need help or have a question, you can open an [issue](https://github.com/ArchiveBox/ArchiveBox/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc) or reach out on [Twitter](https://twitter.com/theSquashSH).*
What are you having an issue with?:
- [Installing ArchiveBox](#Installing)
- [Upgrading ArchiveBox](https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives)
- [Configuring ArchiveBox](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration)
- [Archiving content with ArchiveBox](#Archiving)
- [Hosting your collection publicly](#Hosting-the-Archive)
- [Database and filesystem issues](#database)
---
## Installing
If using `archivebox` without Docker, make sure you've followed the full guide in the [[Install]] instructions first. Then check here for help depending on what component you need help with.
Then make sure `archivebox` is installed available in your `$PATH`.
```bash
apt show archivebox # show info about the apt-installed version of archivebox
brew info archivebox # show info about the brew-installed version of archivebox
pip show archivebox # show info about the pip-installed version of archivebox
echo $PATH # show the directories your system is searching for binaries
which -a archivebox # show all installed archivebox binaries available
which archivebox # show which archivebox binary is being called
```
**⭐️ Show the full archivebox version info + info about all installed dependencies:**
```bash
archivebox version # shows lots of useful info about installed dependencies and more
```
(ensure the version shown is the most recent available from [Releases](https://github.com/ArchiveBox/ArchiveBox/releases))
### macOS
**✨ ArchiveBox no longer needs to be `brew`-installed:**
✅ ArchiveBox still fully supports macOS, don't worry!
📦 Just install it using `pip` (or `pipx`) instead now:
```bash
mkdir -p ~/archivebox/data
cd ~/archivebox/data # (for example, can be anywhere)
pip install archivebox # just use pip to get archivebox
archivebox install # then finish installing dependencies
```
More info: https://github.com/ArchiveBox/homebrew-archivebox
### Python
Make sure you have at least Python 3.9 installed on your system.
```bash
python3 --version
pip --version
pip install --upgrade pip setuptools
```
If you still need help getting Python installed, [the official Python docs](https://docs.python.org/3.9/using/unix.html) are a good place to start.
### Chromium/Google Chrome
For more info, see the [[Chromium Install]] page.
ArchiveBox depends on being able to access a `chromium-browser`/`google-chrome` executable. The executable used
defaults to `chromium-browser` but can be manually specified with the environment variable `CHROME_BINARY`:
```bash
env CHROME_BINARY=/usr/local/bin/chromium-browser archivebox add ~/Downloads/bookmarks_export.html
```
1. Test to make sure you have Chrome on your `$PATH` with:
```bash
which chromium-browser || which google-chrome
```
If no executable is displayed, follow the setup instructions to install and link one of them.
2. If a path is displayed, the next step is to check that it's runnable:
```bash
chromium-browser --version || google-chrome --version
```
If no version is displayed, try the setup instructions again, or confirm that you have permission to access chrome.
3. If a version is displayed and it's `<111`, upgrade it:
```bash
apt upgrade chromium-browser -y
# OR
brew cask upgrade chromium-browser
```
4. If a version is displayed and it's `>=111`, make sure ArchiveBox is running the right one:
```bash
env CHROME_BINARY=/path/from/step/1/chromium-browser archivebox version # replace the path with the one you got from step 1
```
### Wget & Curl
If you're missing `wget` or `curl`, simply install them using `apt` or your package manager of choice.
See the "Manual Setup" instructions for more details.
If wget times out or randomly fails to download some sites that you have confirmed are online,
upgrade wget to the most recent version with `brew upgrade wget` or `apt upgrade wget`. There is
a bug in versions `<=1.19.1_1` that caused wget to fail for perfectly valid sites.
### NPM Dependencies
NPM packages like `readability`, `singlefile`, etc. are auto-installed by `archivebox setup` into `data/node_modules`.
Make sure you have installed NodeJS + NPM first, here are their [official install docs](https://nodejs.org/en/download/package-manager/).
```bash
node --version # make sure you have node >=19 installed
npm --version # make sure you have npm installed
cd ~/archivebox/data # go into your data directory
archivebox setup # auto-installs all JS dependencies into ./node_modules
# equivalent to:
# curl -fsSL 'https://raw.githubusercontent.com/ArchiveBox/ArchiveBox/stable/archivebox/package.json' > package.json
# npm install
# install npm dependencies should then be present in ~/archivebox/data/node_modules/.bin
archivebox version # show version full info to make sure they're loaded correctly
```
---
## Archiving
### No links parsed from export file
Please open an [issue](https://github.com/ArchiveBox/ArchiveBox/issues) with a description of where you got the export, and
preferably your export file attached (you can redact the links). We'll fix the parser to support your format.
### Lots of skipped sites
If you ran the archiver once, it wont re-download sites subsequent times, it will only download new links.
If you haven't already run it, make sure you have a working internet connection and that the parsed URLs look correct.
You can check the ArchiveBox stdout logs or the Web UI to see what links it's downloading.
If you're still having issues, try deleting or moving the `./archive` folder (back it up first!) and running `archivebox init` again.
### Lots of errors
Make sure you have all the dependencies installed and that you're able to visit the links from your browser normally.
Open an [issue](https://github.com/ArchiveBox/ArchiveBox/issues) with a description of the errors if you're still having problems.
### Lots of broken links from the index
Not all sites can be effectively archived with each method, that's why it's best to use a combination of `wget`, PDFs, and screenshots.
If it seems like more than 10-20% of sites in the archive are broken, open an [issue](https://github.com/ArchiveBox/ArchiveBox/issues)
with some of the URLs that failed to be archived and I'll investigate.
### Removing unwanted links from the index
`archivebox remove --help`
## Hosting the Archive
If you're having issues trying to host the archive via nginx, make sure you already have nginx running with SSL.
If you don't, google around, there are plenty of tutorials to help get that set up. Open an [issue](https://github.com/ArchiveBox/ArchiveBox/issues)
if you have problem with a particular nginx config.
### Other database or filesystem issues
#### Docker Permissions issues
Try Setting `PUID` & `PGID`: https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#puid--pgid
Try using [`bindfs`](https://github.com/clecherbauer/docker-volume-bindfs) to work around issues by remapping permissions, for example to remap `uid:33 gid:33` on the host to `911:911` inside the container:
`docker-compose.yml`:
```yaml
services:
archivebox:
volumes:
- archivebox-data:/data
volumes:
archivebox-data:
driver: lebokus/bindfs:latest
driver_opts:
sourcePath: "${EXTERNAL_MOUNT_PARENT}/external-parent/external/archivebox"
map: "33/911:@33/@911"
```
<br/>
---
<br/>
## Database
Database and filesystem issues are uncommon but do come up from time to time (especially when using networked storage, large archives, or multiple ArchiveBox processes for a single collection).
*ℹ️ Generally, these commands can help you resolve most issues:*
```bash
archivebox init # upgrade the archivebox collection
archivebox init --setup # upgrade the archivebox collection and all dependencies
archivebox update --index-only # force an upgrade of some of the archivebox index/collection files
archivebox server --debug # run the server with more verbose debug log output
archivebox shell # access the Python API / Django management shell
sqlite3 index.sqlite3 # access the SQLite3 SQL database shell
```
Don't be scared by the volume of content here. Almost all of these issues linked below are duplicates or old resolved bugs, but they contain valuable context and troubleshooting steps if you're trying to figure out the cause of a problem with your setup.
#### Filesystem doesn't support FSYNC (e.g. network mounts)
The `index.sqlite3` file must be stored on a filesystem that supports FSYNC (most local filesystems) in order to ensure SQLite3 database integrity when multiple ArchiveBox processes may be accessing it simultaneously. However, the `./archive` folder can be on a NAS or other filesystem that does not support FSYNC.
- [Archivebox hangs when initializing collection on network drive that doesn't support FSYNC #742](https://github.com/ArchiveBox/ArchiveBox/issues/742)
- [Question: How to run AB on localhost but store data on NAS? #894](https://github.com/ArchiveBox/ArchiveBox/issues/894)
- [Question: Docker on Windows archiving to an SMB path that doesn't support FSYNC #722](https://github.com/ArchiveBox/ArchiveBox/issues/722)
- [Support for network drives or filesystems that don't implement FSYNC #456](https://github.com/ArchiveBox/ArchiveBox/issues/456)
More info:
- https://www.geeksforgeeks.org/python-os-fsync-method/
- https://man7.org/linux/man-pages/man2/fdatasync.2.html
- https://www.samba.org/samba/docs/current/man-html/smb.conf.5.html
- https://eclecticlight.co/2022/02/18/how-can-you-trust-a-disk-to-write-data/
#### Database and filesystem contention issues when running multiple ArchiveBox processes
ArchiveBox can sometimes struggle when archiving many links in parallel with multiple ArchiveBox processes trying to write to the database at the same time, leading to errors like this:
```bash
Unable to create the django_migrations table (database is locked)
```
These errors can also be encountered when there are permissions, network, or filesystem issues preventing writes to `index.sqlite3`.
- [Question: Unable to create the django_migrations table (database is locked) - When OUTPUT_DIR to SAMBA share #946](https://github.com/ArchiveBox/ArchiveBox/issues/946)
- [Question: ...Unable to create the django_migrations table (database is locked) #880](https://github.com/ArchiveBox/ArchiveBox/issues/880)
- [Database is locked and other weird behavior when doing simultaneous adds #781](https://github.com/ArchiveBox/ArchiveBox/issues/781)
- [Bugfix: Retry on "database locked" error (or add support for PostgreSQL/MySQL DB backend) #601](https://github.com/ArchiveBox/ArchiveBox/issues/601)
- [Architecture: Use multiple cores to run link archiving in parallel #91](https://github.com/ArchiveBox/ArchiveBox/issues/91)
- [ArchiveBox index corruption when running multiple import processes on v0.5.0 #454](https://github.com/ArchiveBox/ArchiveBox/issues/454)
- [Architecture: Concurrent runs accidentally delete each other's temp files, leaving the index broken #234](https://github.com/ArchiveBox/ArchiveBox/issues/234)
- [Database is locked and other weird behavior when doing simultaneous adds #781](https://github.com/ArchiveBox/ArchiveBox/issues/781)
- [Bugfix: Retry on "database locked" error (or add support for PostgreSQL/MySQL DB backend) #601](https://github.com/ArchiveBox/ArchiveBox/issues/601)
More info:
- https://www.sqlite.org/lockingv3.html
- https://charlesleifer.com/blog/going-fast-with-sqlite-and-python/
- https://victoria.dev/blog/sqlite-in-production-with-wal/
- https://code.djangoproject.com/ticket/29280
- https://stackoverflow.com/questions/47761570/how-can-i-avoid-database-is-locked-sqlite3-errors-in-django
#### Database migrations errors or upgrade issues
Migration or upgrade issues happen occasionally with some niche setups or when skipping major versions during archiving.
Always backup your archive before upgrading, but know that migrations are deterministic and atomic using Django's migration system, so a failed migration does not mean your archive is unrecoverable, you just have to downgrade to the previous stable major version then continue upgrading.
```bash
archivebox init # this usually applies any necessary migrations (atomically and idempotently, safe to run multiple times)
```
- [Bug: NOT NULL constraint failed: core_archiveresult.output when upgrading v0.4.24 archive to v0.6 #705](https://github.com/ArchiveBox/ArchiveBox/issues/705)
- [Bugfix: sqlite3.IntegrityError: NOT NULL constraint failed: core_archiveresult.cmd_version and .output #597](https://github.com/ArchiveBox/ArchiveBox/issues/597)
- [Error: django.db.utils.IntegrityError: UNIQUE constraint failed: core_tag.slug #596](https://github.com/ArchiveBox/ArchiveBox/issues/596)
- [Bugfix: django.db.utils.IntegrityError: UNIQUE constraint failed: core_snapshot.timestamp #412](https://github.com/ArchiveBox/ArchiveBox/issues/412)
- [Best Practices for Backup/Restore #341](https://github.com/ArchiveBox/ArchiveBox/issues/341)
- [Bug: Running archivebox update --index-only doesn't upgrade Snapshot index.{html,json} files #962](https://github.com/ArchiveBox/ArchiveBox/issues/962)
- [Feature Request: Deduplicate files on archives #704](https://github.com/ArchiveBox/ArchiveBox/issues/704)
More info:
- https://docs.djangoproject.com/en/4.0/topics/migrations/
- https://realpython.com/django-migrations-a-primer/
- https://realpython.com/digging-deeper-into-migrations/
- https://www.kite.com/blog/python/django-database-migrations-overview/
- https://markusholtermann.eu/2021/06/writing-safe-database-migrations-in-django/
#### Repairing a corrupted SQLite3 database file
A corrupted database file can theoretically only happen if an external process or filesystem error corrupts the SQLite3 database (there have only been [two](https://github.com/ArchiveBox/ArchiveBox/issues/1699) [reports](https://github.com/ArchiveBox/ArchiveBox/issues/955) of a user encountering this in real life). If you ever need to repair a corrupted ArchiveBox index you can run the following steps.
Note this is specific to this error, these steps do not apply to other migrations/db errors (see above/below for other issues):
```bash
sqlite3.DatabaseError: database disk image is malformed
```
Generally all index issues should be fixable by running `archivebox init`.
You can see the status of Snapshots and find any invalid/orphan/missing snapshots with `archivebox status`.
**Error output:**
```python3
[i] [2022-03-24 20:37:27] ArchiveBox v0.6.2: archivebox init
> /data
[^] Verifying and updating existing ArchiveBox collection to v0.6.2...
----------------------------------------------------------------------
[*] Verifying archive folder structure...
+ ./archive, ./sources, ./logs...
+ ./ArchiveBox.conf...
[*] Verifying main SQL index and running any migrations needed...
Traceback (most recent call last):
File "/usr/local/lib/python3.9/site-packages/django/db/backends/utils.py", line 82, in _execute
return self.cursor.execute(sql)
File "/usr/local/lib/python3.9/site-packages/django/db/backends/sqlite3/base.py", line 411, in execute
return Database.Cursor.execute(self, query)
sqlite3.DatabaseError: database disk image is malformed
```
**Steps to fix:**
```bash
cd ~/archivebox/data
echo '.dump' | sqlite3 index.sqlite3 | sqlite3 repaired_index.sqlite3
mv index.sqlite3 corrupt_index.sqlite3
mv repaired_index.sqlite3 index.sqlite3
```
More info:
- https://github.com/ArchiveBox/ArchiveBox/issues/955 and https://github.com/ArchiveBox/ArchiveBox/issues/1699
- https://stackoverflow.com/questions/5274202/sqlite3-database-or-disk-is-full-the-database-disk-image-is-malformed
---
See here for more info:
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading
- https://github.com/ArchiveBox/ArchiveBox/wiki/Merging-Collections
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#python-shell-usage
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#sql-shell-usage
- https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#do-not-run-as-root
- https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#output-folder

7
docs/Upgrading-or-Merging-Archives.md
View File

@ -1,7 +0,0 @@
# Upgrading or Merging Archives
Moved to:
- [[Upgrading]]
- [[Merging Collections]]
- [Database Troubleshooting](./Troubleshooting#database)

143
docs/Upgrading.md
View File

@ -1,143 +0,0 @@
# Upgrading Versions
```bash
# cd /path/to/your/archivebox/data
cd ~/archivebox/data
pip install --upgrade --ignore-installed archivebox
# or
docker pull archivebox/archivebox:latest
# upgrade the collection to a new version
archivebox init
```
**✅ Upgrading checklist:**
1. Find the version you want to upgrade to on https://github.com/ArchiveBox/ArchiveBox/releases
2. **Read the release notes carefully** for any instructions or extra steps around upgrading for each release you're skipping or installing
3. **Make a full backup** of your `index.sqlite3` and `archive/` content before upgrading!
`gzip -9 < index.sqlite3 > "index.sqlite3.$(date +%s).bak"`
4. Follow the steps below depending on your setup to run `archivebox init` (repeating as necessary for each major version if upgrading across multiple major versions)
5. Confirm the upgrade succeeded and check for any orphan/corrupted snapshots with `archivebox status`
💬 [Open an issue](https://github.com/ArchiveBox/ArchiveBox/issues/new/choose) in our bug tracker if you experience any problems with upgrading/merging/modifying collections.
---
*Note: It's recommended to only upgrade one major version at a time. e.g. if you're on `v0.4.14`, upgrade to `v0.5.6` next, then `v0.6.3`, and finally `v0.7.1` (as 3 separate steps).
You can specify exact versions with pip like so: `pip install archivebox==0.6.3` or with docker `docker pull archivebox/archivebox:0.6.3`. Upgrading directly across multiple major versions may work in some cases, but is not recommended for maximum data safety.*
---
**ℹ️ How it works internally:**
The same command is used for initializing a new archive and upgrading an existing one. `archivebox init` is idempotent and safely be run multiple times. Running it will ensure your collection is on the latest version and all the files are in their correct locations. `archivebox status` can be used to check for orphan/corrupted snapshots or invalid index data.
There are three main areas on disk that ArchiveBox modifies during upgrades:
- `index.sqlite3` contains the SQLite3 DB index that gets upgraded automatically by Django based on the changes in [`archivebox/core/models.py`](https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/core/models.py).
- `archive/*/index.json` these files are redundant json exports of the data for each Snapshot in `index.sqlite3`, these files are overwritten on every `archivebox update` run or anytime the Snapshot is modified from the GUI or CLI. These files will be [lazily updated](https://github.com/ArchiveBox/ArchiveBox/issues/962) to the latest schema versions as ArchiveBox accesses them, but are usually not modified in bulk during `archivebox init` when upgrading.
- `archive/*` the Snapshot output files may be moved or renamed by future upgrades (so far they have remained unchanged since v0.1, but future versions reserve the right to change their locations)
The `ArchiveBox.conf` file is not modified by upgrades and should remain forward-compatible across future versions (even when config options are renamed, we check the old names internally to maintain compatibility).
As of v0.4 and above, ArchiveBox uses the Django migrations system for deterministic, atomic, safe upgrades, so your DB should always be left in a consistent state in the event of a failure or power outage. If you need help fixing a corrupted collection, open an issue using the link above.
More info:
- https://docs.djangoproject.com/en/4.0/topics/migrations/
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#database-migrations-errors-or-upgrade-issues
- https://github.com/ArchiveBox/ArchiveBox/wiki/Troubleshooting
---
### Upgrading with Docker Compose ⭐️
Using Docker Compose is recommended because it makes upgrading a breeze! ✨
Pulling and running the latest version automatically upgrades the ArchiveBox collection and all of ArchiveBox's internal dependencies.
```bash
cd ~/archivebox # or wherever your folder containing docker-compose.yml is
docker-compose down # stop the currently running archivebox containers
docker-compose down # run twice to clear stopped containers
docker-compose pull # pull the latest image version from Docker Hub
docker-compose up # collection will be automatically upgraded as it starts
```
More info:
- https://github.com/ArchiveBox/ArchiveBox#%EF%B8%8F-easy-setup
- https://github.com/ArchiveBox/ArchiveBox/wiki/Docker#docker-compose
- https://github.com/ArchiveBox/ArchiveBox/wiki/Docker#setup
### Upgrading with plain Docker
Upgrading with plain Docker is similar to the process with Docker Compose, but you have to run `archivebox init` manually at the end to finish the process.
```bash
docker ps -a -q --filter ancestor=archivebox/archivebox # find any currently running archivebox containers
docker kill <image> # stop any currently running archivebox versions
docker pull archivebox/archivebox
docker run -v $PWD:/data -it archivebox/archivebox init # upgrade the collection to the latest version
# restart the archivebox server container if needed
docker run -v $PWD:/data -it -p 8000:8000 archivebox/archivebox server 0.0.0.0:8000
```
More info:
- https://github.com/ArchiveBox/ArchiveBox#%EF%B8%8F-easy-setup
- https://github.com/ArchiveBox/ArchiveBox/wiki/Docker#docker
- https://github.com/ArchiveBox/ArchiveBox/wiki/Docker#setup-1
### Upgrading with a package manager
Package manager releases take a lot of effort to maintain ([contributions welcome!](https://github.com/ArchiveBox/ArchiveBox/wiki/Donations)) and sometimes lag behind the Docker releases. We make a best effort to have the latest release available through all channels within a reasonable timeframe.
```bash
cd ~/archivebox/data # or wherever your data folder is
killall archivebox # stop the currently running archivebox version
# upgrade ArchiveBox using the package manager you originally used to install it
pip install --upgrade --ignore-installed archivebox
# or
apt install --upgrade archivebox
# or with the optional auto-installer script
curl -sSL 'https://get.archivebox.io' | sh
archivebox init # run init to upgrade the collection to the latest version
archivebox update --index-only # optionally force an update of the snapshot index files (normally done lazily, see issue #962 for more info)
archivebox status # check that everything succeeded
```
More info:
- https://github.com/ArchiveBox/ArchiveBox#-package-manager-setup
- https://github.com/ArchiveBox/ArchiveBox/wiki/Install#manual-setup
- https://github.com/ArchiveBox/pip-archivebox
- https://github.com/ArchiveBox/homebrew-archivebox
- https://github.com/ArchiveBox/docker-archivebox
- https://github.com/ArchiveBox/debian-archivebox
- https://github.com/ArchiveBox/electron-archivebox
- https://aur.archlinux.org/packages/archivebox
- https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/misc/archivebox/default.nix
<hr/>
## Merge two or more existing archives
See [[Merging Collections]]...
<br/>
<hr/>
## Related Documents
- https://github.com/ArchiveBox/ArchiveBox/wiki/Troubleshooting#database
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#disk-layout
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#large-archives
- https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#output-folder
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#python-shell-usage
- https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#sql-shell-usage

430
docs/Usage.md
View File

@ -1,430 +0,0 @@
# Usage
▶️ _Make sure the dependencies are [fully installed](https://github.com/ArchiveBox/ArchiveBox/wiki/Install) before running any ArchiveBox commands._
**ArchiveBox API Reference:**
<img src="https://imgur.zervice.io/aQZZcku.png" width="20%" align="right"/>
- [CLI Usage](#CLI-Usage): Docs and examples for the ArchiveBox command line interface.
- [Admin UI Usage](#UI-Usage): Docs and screenshots for the outputted HTML archive interface.
- [Browser Extension Usage](#Browser-Extension-Usage): Docs and screenshots for the outputted HTML archive interface.
- [Disk Layout](#Disk-Layout): Description of the archive folder structure and contents.
**Related:**
- [[Docker]]: Learn about ArchiveBox usage with Docker and Docker Compose
- [[Configuration]]: Learn about the various archive method options
- [[Scheduled Archiving]]: Learn how to set up automatic daily archiving
- [[Publishing Your Archive]]: Learn how to host your archive for others to access
- [[Troubleshooting]]: Resources if you encounter any problems
## CLI Usage
<img src="https://imgur.zervice.io/biVfFYr.png" width="30%" align="right"/>
All three of these ways of running ArchiveBox are equivalent and interchangeable:
- `archivebox [subcommand] [...args]`
*Using the PyPI package via `pip install archivebox`*
- `docker run ... archivebox/archivebox [subcommand] [...args]`
*Using the official Docker image*
- `docker-compose run archivebox [subcommand] [...args]`
*Using the official Docker image w/ Docker Compose*
You can share a single archivebox data directory between Docker and non-Docker instances as well, allowing you to run the server in a container but still execute CLI commands on the host for example.
For more examples see [README: Usage](https://github.com/ArchiveBox/ArchiveBox#%EF%B8%8F-cli-usage) and [[Docker]] pages.
- [Run ArchiveBox with configuration options](#Run-ArchiveBox-with-configuration-options)
- [Import a single URL](#Import-a-single-URL)
- [Import a list of URLs from a text file](#Import-a-list-of-URLs-from-a-text-file)
- [Import list of links from browser history](#Import-list-of-links-from-browser-history)
---
### Run ArchiveBox with configuration options
You can set environment variables in your shell profile, a config file, or by using the `env` command.
```bash
# set config via the CLI
archivebox config --set MEDIA_MAX_SIZE=750mb
# OR modify the config file directly
echo 'MEDIA_MAX_SIZE=750mb' >> ArchiveBox.conf
# OR use environment variables
env MEDIA_MAX_SIZE=750mb archivebox add 'https://example.com'
```
See [[Configuration]] page for more details about the available options and ways to pass config.
If you're using Docker, also make sure to read the Configuration section on the [[Docker]] page.
> [!TIP]
> You can run ArchiveBox commands from anywhere (without having to `cd` into a data directory first):
> `/usr/bin/env --chdir=/path/to/archivebox/data archivebox update`
---
### Import a single URL
```bash
archivebox add 'https://example.com'
# OR
echo 'https://example.com' | archivebox add
```
You can also add `--depth=1` to any of these commands if you want to recursively archive the URLs and all URLs one hop away. (e.g. all the outlinks on a page + the page).
### Import a list of URLs from a text file
```bash
cat urls_to_archive.txt | archivebox add
# OR
archivebox add < urls_to_archive.txt
# OR
curl 'https://example.com/some/rss/feed.xml' | archivebox add
# OR
archivebox add --depth=1 'https://example.com/some/rss/feed.xml'
```
You can also pipe in RSS, XML, Netscape, or any of the other [supported import formats](https://github.com/ArchiveBox/ArchiveBox/wiki/Quickstart#2-get-your-list-of-urls-to-archive) via stdin.
```bash
archivebox add < ~/Downloads/browser_bookmarks_export.html
# OR
archivebox add < ~/Downloads/pinboard_bookmarks.json
# OR
archivebox add < ~/Downloads/any_text_containing_urls.txt
```
---
### Import list of links from browser history
Look in the `bin/` folder of this repo to find a script to parse your browser's SQLite history database for URLs.
Specify the type of the browser as the first argument, and optionally the path to the SQLite history file as the second argument.
```bash
./bin/export-browser-history --chrome
archivebox add < output/sources/chrome_history.json
# or
./bin/export-browser-history --firefox
archivebox add < output/sources/firefox_history.json
# or
./bin/export-browser-history --safari
archivebox add < output/sources/safari_history.json
```
<br/>
---
<br/>
### Import browser cookies into a persona
To archive logged-in sites, you can import cookies from your browser into a persona. This generates a `cookies.txt` file in the persona directory (used by wget/curl/yt-dlp, etc.) and, for Chromium-based browsers, also copies the profile into the persona so Chrome-based extractors can reuse it.
```bash
archivebox persona create --import=chrome personal
# supported: chrome/chromium/brave/edge (Chromium-based only)
# use --profile to target a specific profile (e.g. Default, Profile 1)
# re-running import merges/dedupes cookies.txt (by domain/path/name) but replaces chrome_user_data
```
If cookie extraction fails, you can still export a Netscape-format `cookies.txt` using a browser extension and place it at `data/personas/<NAME>/cookies.txt`.
<br/>
---
<br/>
## UI Usage
```bash
# configure which areas you want to require login to use vs make publicly available
archivebox config --set PUBLIC_INDEX=False
archivebox config --set PUBLIC_SNAPSHOTS=False
archivebox config --set PUBLIC_ADD_VIEW=False
archivebox manage createsuperuser # set an admin password to use for any areas requiring login
archivebox server 0.0.0.0:8000 # start the archivebox web server
open http://127.0.0.1:8000 # open the admin UI in a browser to view your archive
```
*See the [Configuration Wiki](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#public_index--public_snapshots--public_add_view) and [Security Wiki](https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#archiving-private-content) for more info...*
Or if you prefer to generate a [static HTML index](https://github.com/ArchiveBox/ArchiveBox#static-archive-exporting) instead of using the built-in web server, you can run `archivebox list --html --with-headers > ./index.html` and then open `./index.html` in a browser. You should see something [like this](https://demo.archivebox.io).
You can sort by column, search using the box in the upper right, and see the total number of links at the bottom.
Click the Favicon under the "Files" column to go to the details page for each link.
<div align="center">
<img src="https://imgur.zervice.io/52RjhUM.png" width="45%" align="top"/>
<img src="https://imgur.zervice.io/Gg9sTyq.png" width="45%" align="top"/>
</div>
### Explanation of buttons in the web UI - admin snapshots list
<img src="https://imgur.zervice.io/4Sa76Ek.png" alt="Screenshot of buttons at top of Snapshot admin page"/>
A logged-in admin user may select ☑️ one or more snapshots from the list and perform Snapshot actions:
- <kbd>Search</kbd> Search text in the Snapshot title, URL, tags, or archived content (supports regex with the default ripgrep search backend, or enable the [Sonic](https://github.com/ArchiveBox/ArchiveBox/blob/dev/docker-compose.yml#L35) full-text search backend in `docker-compose.yml` and set `SEARCH_BACKEND_ENGINE=sonic`, `SEARCH_BACKEND_HOST`, `SEARCH_BACKEND_PASSWORD` for full-text fuzzy searching) https://github.com/ArchiveBox/ArchiveBox/issues/956
- <kbd>Tags</kbd> Start typing in the field to select some tags, then click `+` to add them or `-` remove them from the checked snapshots (`Tags` can be created/edited from the `/admin/core/tag/` page)
- <kbd>Title</kbd> Pull the latest title and favicon without doing a full snapshot. (helpful to quickly ping any URLs that are stuck showing up as `Pending...` or are missing a title)
- <kbd>Pull</kbd> Finish downloading the Snapshot, pulls any missing/failed outputs/extractors methods (pdf, wget... etc). Resumes running the same archiving steps as when you add new URL. Useful to finish pulling when previous import was paused or interrupted by a reboot or something. https://github.com/ArchiveBox/ArchiveBox#output-formats
- <kbd>Re-Snapshot</kbd> Re-archive the original URL from scratch as a new separate snapshot. Differs from pulling in that it doesn't resume/update existing snapshot, it creates a new separate entry and re-snapshots the URL at the current point in time. (useful for saving multiple Snapshots of a single URL over time) https://github.com/ArchiveBox/ArchiveBox#saving-multiple-snapshots-of-a-single-url
- <kbd>Reset</kbd> Keep the Snapshot entry, but delete all its archive results and redownload them from scratch immediately. Useful for re-trying a bad Snapshot and overwriting its previous results, e.g. if it initially archived a temporary error page or hit a transient rate-limit/CAPTCHA/login page.
- <kbd>Delete</kbd> Delete a snapshot and all its archive results entirely. This action cannot be undone. (Note: to thoroughly remove every trace of a URL ever being added, you should also manually scrub log output found in `sources/` and `logs/`)
<br/>
---
<br/>
## Browser Extension Usage
Set up the official [ArchiveBox Browser Extension](https://github.com/ArchiveBox/archivebox-browser-extension) to submit URLs directly from your browser to ArchiveBox.
1. Install the extension in your browser:
- [Google Chrome / Edge / All Chromium-based browsers...](https://chrome.google.com/webstore/detail/habonpimjphpdnmcfkaockjnffodikoj)
- [Firefox](https://addons.mozilla.org/en-US/firefox/addon/archivebox-exporter/)
2. Log into your ArchiveBox server's admin UI in the same browser where you installed the extension, e.g.
[`http://localhost:8000/admin/`](http://localhost:8000/admin/) or `https://demo.archivebox.io/admin/`
The extension will re-use your admin UI login session to submit URLs to your server, so *make sure to log in!*
. . .
*Alternatively:* You can configure Archivebox to [allow submitting URLs without requiring log-in](https://github.com/ArchiveBox/ArchiveBox/wiki/Configuration#public_index--public_snapshots--public_add_view)
`archivebox config --set PUBLIC_ADD_VIEW=True`
3. Click the ArchiveBox extension in your browser and set `Config > ArchiveBox Base URL` to your server's URL, e.g.
`http://localhost:8000` or `https://demo.archivebox.io`
4. ✅ Done! Test it out: `Right-click on any page > ArchiveBox Exporter > Archive Current Page`
*Then check your ArchiveBox instance to confirm the URL was added.*
<img width="400" align="right" alt="browser extension config screen" src="https://user-images.githubusercontent.com/511499/215702958-4683af8f-7f1e-4b0e-a313-2466b9cf0276.png"/>
<img width="350" align="top" alt="chrome web store screenshot" src="https://user-images.githubusercontent.com/511499/215699375-5c98c9bb-56fd-4a46-a990-e5745d46019c.png"/><br/><img width="400" alt="image" src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/8bdd99a8-656b-4839-937d-80670ec4d8a6">
#### More Info
- https://github.com/ArchiveBox/archivebox-browser-extension
- https://github.com/ArchiveBox/archivebox-browser-extension#setup
- https://github.com/ArchiveBox/archivebox-browser-extension#features
- https://github.com/ArchiveBox/archivebox-browser-extension#alternative-extensions-for-archiving
- https://github.com/ArchiveBox/ArchiveBox/issues/577
<br/>
---
<br/>
## Disk Layout
The `OUTPUT_DIR` folder (usually whatever folder you run the `archivebox` command in), contains the UI HTML and archived data with the structure outlined below.
Simply back up the entire `data/` folder to back up your archive, e.g. `zip -r data.backup.zip data`.
```yaml
- data/
- index.sqlite3 # Main index of all archived URLs
- ArchiveBox.conf # Main config file in ini format
- archive/
- 155243135/ # Archived links are stored in folders by timestamp
- index.json # Index/details page for individual archived link
- index.html
# Archive method outputs:
- warc/
- media/
- git/
...
- sources/ # Each imported URL list is saved as a copy here
- getpocket.com-1552432264.txt
- stdin-1552291774.txt
...
```
For more info about ArchiveBox's database/filesystem layout and troubleshooting steps:
- https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#output-folder
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#modify-the-archivebox-sqlite3-db-directly
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#database-troubleshooting
### Large Archives
I've found it takes about an hour to download 1000 articles, and they'll take up roughly 1GB.
Those numbers are from running it single-threaded on my i5 machine with 50mbps down. YMMV.
Storage requirements go up immensely if you're using `FETCH_MEDIA=True` and are archiving many pages with audio & video.
You can try to run it in parallel by manually splitting your URLs into separate chunks (though this may not work with `database locked` errors on slower filesystems):
```bash
archivebox add < urls_chunk_1.txt &
archivebox add < urls_chunk_2.txt &
archivebox add < urls_chunk_3.txt &
```
(though this may not be faster if you have a very large collection/main index)
Users have reported running it with 50k+ bookmarks with success (though it will take more RAM while running).
If you already imported a huge list of bookmarks and want to import only new
bookmarks, you can use the `ONLY_NEW` environment variable. This is useful if
you want to import a bookmark dump periodically and want to skip broken links
which are already in the index.
For more info about troubleshooting filesystem permissions, performance, or issues when running on a NAS:
- https://github.com/ArchiveBox/ArchiveBox/wiki/Security-Overview#output-folder
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#database-troubleshooting
<br/>
---
<br/>
## SQL Shell Usage
Explore the SQLite3 DB a bit to see what's available using the SQLite3 shell:
```bash
cd ~/archivebox/data
sqlite3 index.sqlite3
# example usage:
SELECT * FROM core_snapshot;
UPDATE auth_user SET email = 'someNewEmail@example.com' WHERE username = 'someUsernameHere';
...
```
More info:
- https://github.com/ArchiveBox/ArchiveBox#-sqlpythonfilesystem-usage
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#modify-the-archivebox-sqlite3-db-directly
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#database-troubleshooting
- https://stackoverflow.com/questions/1074212/how-can-i-see-the-raw-sql-queries-django-is-running
- https://adamobeng.com/wddbfs-mount-a-sqlite-database-as-a-filesystem/
<br/>
---
<br/>
## Python Shell Usage
Explore the Python API a bit to see what's available using the archivebox shell:
**Python API Documentation:** https://docs.archivebox.io/dev/apidocs/index.html
```bash
$ archivebox shell
[i] [2020-09-17 16:57:07] ArchiveBox v0.4.21: archivebox shell
> /Users/squash/Documents/opt/ArchiveBox/data
# Shell Plus Model Imports
from core.models import Snapshot
from django.contrib.admin.models import LogEntry
from django.contrib.auth.models import Group, Permission, User
from django.contrib.contenttypes.models import ContentType
from django.contrib.sessions.models import Session
# Shell Plus Django Imports
from django.core.cache import cache
from django.conf import settings
from django.contrib.auth import get_user_model
from django.db import transaction
from django.db.models import Avg, Case, Count, F, Max, Min, Prefetch, Q, Sum, When
from django.utils import timezone
from django.urls import reverse
from django.db.models import Exists, OuterRef, Subquery
# ArchiveBox Imports
from archivebox.core.models import Snapshot, User
from archivebox import *
help
version
init
config
add
remove
update
list
shell
server
status
manage
oneshot
schedule
[i] Welcome to the ArchiveBox Shell!
https://github.com/ArchiveBox/ArchiveBox/wiki/Usage#Shell-Usage
https://docs.archivebox.io/dev/apidocs/index.html
Hint: Example use:
print(Snapshot.objects.filter(is_archived=True).count())
Snapshot.objects.get(url="https://example.com").as_json()
add("https://example.com/some/new/url")
# run Python API queries/function calls directly
>>> print(Snapshot.objects.filter(is_archived=True).count())
24
# get help info on an object or function
>>> help(Snapshot)
...
# show raw SQL queries run
>>> from django.db import connection
>>> print(connection.queries)
```
For more info and example usage:
- https://github.com/ArchiveBox/ArchiveBox/wiki/Upgrading-or-Merging-Archives#example-adding-a-new-user-with-a-hashed-password
- https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/main.py
- https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/config.py
- https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/core/models.py
- https://stackoverflow.com/questions/1074212/how-can-i-see-the-raw-sql-queries-django-is-running
<br/>
---
<br/>
## Python API Usage
You can interact with ArchiveBox as a Python library from external scripts or programs.
This API is a *local* API, designed to be used on the same machine as the ArchiveBox collection.
For example you could creat a script `add_archivebox_url.py` like so:
```python
import os
DATA_DIR = '~/archivebox/data'
os.chdir(DATA_DIR)
# you must import and setup django first to establish a DB connection
from archivebox.config.legacy import setup_django
setup_django()
# then you can import all the main functions
from archivebox.main import add, remove, server
add('https://example.com', index_only=True, out_dir=DATA_DIR)
remove(...)
server(...)
...
```
For more information see:
- [ArchiveBox Python API Reference (ReadTheDocs)](https://docs.archivebox.io/dev/apidocs/index.html)
- [ArchiveBox Developer Documentation](https://github.com/ArchiveBox/ArchiveBox#archivebox-development)
- [ArchiveBox Python source code](https://github.com/ArchiveBox/ArchiveBox/blob/dev/archivebox/)

510
docs/Web-Archiving-Community.md
View File

@ -1,510 +0,0 @@
# Web Archiving Community
<div align="center" style="text-align: center">
<!--💬 **Join the [`#ArchiveBox` channel](http://webchat.freenode.net?channels=ArchiveBox&uio=d4) via IRC on [FreeNode.net](http://webchat.freenode.net?channels=ArchiveBox&uio=d4) to chat with us!**-->
💬 <i><b>Join us on our new ArchiveBox community chat server: https://Zulip.ArchiveBox.io</b></i>
🔢 **Just getting started and want to learn more about why Web Archiving is important? <br/>** &nbsp; &nbsp;&nbsp; Check out this article: [On the Importance of Web Archiving](https://items.ssrc.org/parameters/on-the-importance-of-web-archiving/).
</div>
---
The internet archiving community is surprisingly far-reaching and almost universally friendly! It has some overlap with the scraping and OSINT worlds, but it's also kinda its own thing.
Whether you want to learn which organizations are the big players in the web archiving space, want to find a specific open source tool for your web archiving need, or just want to see where archivists hang out online, this is my attempt at an index of the entire web archiving community. I cant promise that this list is up-to-date, the bulk of it was written in ~2022.
<img src="https://imgur.zervice.io/duS8Lm7.png" width="200px" align="right" style="float: right; margin: 5px"/>
- [The Master Lists](#The-Master-Lists)
*Community-maintained indexes of web archiving tools and groups by IIPC, COPTR, ArchiveTeam, Wikipedia, & the ASA.*
- [Web Archiving Software](#Web-Archiving-Projects)
*Open source tools and projects in the internet archiving space.*
- [Bookmarking Services](#bookmarking-services)
- [Well-Known Open Source Projects](#from-the-archiveorg--archive-it-teams)
- [Public Archiving Services](#other-public-archiving-services)
- [ArchiveBox Alternatives](#other-archivebox-alternatives)
- [Smaller Utilities](#smaller-utilities)
- [Reading List](#Reading-List)
*Articles, posts, and blogs relevant to ArchiveBox and web archiving in general.*
- [Blogs](#Blogs)
- [Articles](#Articles)
- [ArchiveBox-Specific Posts, Tutorials, and Guides](#archivebox-specific-posts-tutorials-and-guides)
- [ArchiveBox Discussions in News & Social Media](#archivebox-discussions-in-news--social-media)
- [Communities](#Communities)
*A collection of the most active internet archiving communities and initiatives.*
- [Most Active Web-Archiving Communities](#most-active-communities)
- [Other Web Archiving Communities](#web-archiving-communities)
- [General Archiving Foundations, Coalitions, Initiatives, and Institutes](#general-archiving-foundations-coalitions-initiatives-and-institutes)
---
## The Master Lists
<img src="https://i.pinimg.com/originals/5d/8f/ae/5d8fae9a42210eb0320960b23e3fe236.jpg" width="230px" align="right" style="float: right; margin: 5px"/>
Indexes of archiving institutions and software maintained by other people. If there's anything archivists love doing, it's making lists.
- **[COPTR Wiki of Web Archiving Tools](http://coptr.digipres.org/Category:Tools) (COPTR)**
- **[Awesome Web Archiving Tools](https://github.com/iipc/awesome-web-archiving) (IIPC)**
- **[My up-to-date list of starred archiving github projects](https://github.com/stars/pirate/lists/internet-archiving)**
- [Spreadsheet Comparison of Archiving Tools](https://github.com/datatogether/research/tree/master/web_archiving) (DataTogether)
- [Awesome Web Crawling Tools](https://github.com/BruceDone/awesome-crawler)
- [Awesome Web Scraping Tools](https://github.com/duyetdev/awesome-web-scraper)
- [ArchiveTeam's List of Software](https://www.archiveteam.org/index.php?title=Software) (ArchiveTeam.org)
- [List of Web Archiving Initiatives](https://en.wikipedia.org/wiki/List_of_Web_archiving_initiatives) (Wikipedia.org)
- [Directory of Archiving Organizations](https://www2.archivists.org/assoc-orgs) (American Society of Archivists)
---
## Web Archiving Projects
<div align="center" style="text-align: center">
<img src="http://web.archive.org/web/20201127205833if_/https://avatars3.githubusercontent.com/u/1553831?s=200&v=4" width="50px"/> &nbsp; &nbsp;
<img src="https://assets.ifttt.com/images/channels/23/icons/large.png" width="50px"/> &nbsp; &nbsp;
<img src="https://avatars1.githubusercontent.com/u/8275533?s=400&v=4" width="50px"/> &nbsp; &nbsp;
<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/b/b8/Logo-wallabag-svg.svg/2000px-Logo-wallabag-svg.svg.png" width="50px"/>
</div>
### Bookmarking Services
- **[Linkwarden](https://github.com/linkwarden/linkwarden)** Modern bookmarking UI with singlefile archiving
- [Hoarder](https://github.com/hoarder-app/hoarder)
- **[Gosuki](https://github.com/blob42/gosuki/releases/tag/v1.3.0) A lightweight, open-source, privacy-first bookmark manager that unifies bookmarks across multiple browsers**
- ~[Pocket Premium](https://getpocket.com) Bookmarking tool that provides an archiving service in their paid version, run by Mozilla~
- **[Pinboard](https://pinboard.in) Bookmarking tool that provides archiving in a paid version, run by a single independent developer**
- **[Raindrop](https://raindrop.io) Bookmarking tool with archiving in their paid version, run by a company est. 2011**
- [Instapaper](https://www.instapaper.com) Bookmarking alternative to Pocket/Pinboard (with no archiving)
- [Wallabag](https://wallabag.org) / [Wallabag.it](https://wallabag.it) Self-hostable web archiving server that can import via RSS
- [Shaarli](https://github.com/shaarli/Shaarli) Self-hostable bookmark tagging, archiving, and sharing service
- [ReadWise](https://readwise.io/) A paid Pocket/Pinboard alternative that includes article snippet and highlight saving
- [Diigo](https://www.diigo.com/) Another brookmarking/annotation service with archiving as a paid feature
---
### From the Archive.org & Archive-It teams
<img src="https://github.com/internetarchive.png" width="128px" align="right" style="float: right; margin: 5px"/>
- **[Archive.org](https://archive.org) The O.G. Wayback Machine provided publicly by the Internet Archive (Archive.org)**
- **[Archive.it](https://archive-it.org) commercial Wayback Machine solution**
- **[Heritrix](https://github.com/internetarchive/heritrix3) The king of internet archiving crawlers, powers the Wayback Machine**
- **[Brozzler](https://github.com/internetarchive/brozzler) chrome headless crawler + WARC archiver maintained by Archive.org**
- [WarcProx](https://github.com/internetarchive/warcprox) WARC proxy recording and playback utility
- [WarcTools](https://github.com/internetarchive/warctools) utilities for dealing with WARCs
- [Grab-Site](https://github.com/ArchiveTeam/grab-site) An easy preconfigured web crawler designed for backing up websites
- [WPull](https://github.com/ArchiveTeam/wpull) A pure python implementation of wget with WARC saving
- [More on their GitHub...](https://github.com/internetarchive)
---
### From Webrecorder
<img src="https://github.com/webrecorder.png" width="128px" align="right" style="float: right; margin: 5px"/>
[Webrecorder](https://webrecorder.net/) develops a suite of open source tools, to capture websites and replay them at a later time as accurately as possible. Webrecorder also publishes the [WACZ file format spec](https://specs.webrecorder.net/wacz/latest).
- **[Browsertrix](https://webrecorder.net/browsertrix)** Fully integrated (self hostable) SaaS web archiving platform
- **[ArchiveWeb.page](https://webrecorder.net/archivewebpage)** Chrome extension for manual, interactive archiving of websites as you browse the web. Good for capturing high-fidelity complex interactions
- **[ReplayWeb.page](https://webrecorder.net/replaywebpage)** Web archive viewer that runs entirely in the browser and doesn't require any server-hosted component to view WARC and WACZ files. Also available as a standalone electron app for local desktop use
- **[Browsertrix Crawler](https://github.com/webrecorder/browsertrix-crawler)** Command-line crawling application that powers Browsertrix's core crawling features
- [pywb](https://github.com/webrecorder/pywb) aka *Python Wayback*, the open source toolkit forked from archive.org for self-hosting your own wayback machine among other web archiving tools
- [warcit](https://github.com/webrecorder/warcit) Create a WARC file out of a folder full of assets
- [warcio](https://github.com/webrecorder/warcio) fast streaming asynchronous WARC reader and writer
- [More on their GitHub...](https://github.com/webrecorder)
---
### From Rhizome.org (Conifer)
<img src="https://github.com/rhizome-conifer.png" width="128px" align="right" style="float: right; margin: 5px"/>
- **[Conifer by Rhizome.org](https://conifer.rhizome.org/)** **An open-source personal archiving server that uses pywb under the hood.** [Previously affiliated with Webrecorder](https://blog.conifer.rhizome.org/2020/06/11/webrecorder-conifer.html)
---
### From the Old Dominion University: Web Science Team
<img src="https://github.com/oduwsdl.png" width="128px" align="right" style="float: right; margin: 5px"/>
- **[ipwb](https://github.com/oduwsdl/ipwb) A distributed web archiving solution using pywb with IPFS for storage**
- **[archivenow](https://github.com/oduwsdl/archivenow) tool that pushes urls into all the online archive services like Archive.is and Archive.org**
- [node-warc](https://github.com/N0taN3rd/node-warc) Parse And Create Web ARChive (WARC) files with node.js
- [WAIL](https://machawk1.github.io/wail/) Web archiver GUI using Heritrix and OpenWayback
- [Squidwarc](https://github.com/N0taN3rd/Squidwarc) User-scriptable, archival crawler using Chrome
- [WAIL (Electron)](https://github.com/n0tan3rd/wail) Electron app version of the original [wail](https://github.com/machawk1/wail) for creating and interacting with web archives
- **[warcreate](https://github.com/machawk1/warcreate) a Chrome extension for creating WARCs from any webpage**
- [More on their GitHub...](https://github.com/oduwsdl)
---
### From the Archives Unleashed Team
<img src="https://github.com/archivesunleashed.png" width="128px" align="right" style="float: right; margin: 5px"/>
- [AUT](https://github.com/archivesunleashed/aut) Archives Unleashed Toolkit for analyzing web archives (formerly WarcBase)
- [Warclight](https://github.com/archivesunleashed/warclight) A Rails engine for finding and searching web archives
- [More on their GitHub...](https://github.com/archivesunleashed)
---
### From the IIPC team
<img src="https://github.com/iipc.png" width="128px" align="right" style="float: right; margin: 5px"/>
- **[OpenWayback](https://github.com/iipc/openwayback/wiki) Open source project developing core Wayback Machine components**
- **[awesome-web-archiving](https://github.com/iipc/awesome-web-archiving) Large list of archiving projects and orgs**
- [JWARC](https://github.com/iipc/jwarc) A Java library for reading and writing WARC files.
- [More on their GitHub...](https://github.com/iipc)
---
### Other Public Archiving Services
<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/1/10/Archive.is.jpg/250px-Archive.is.jpg" width="150px" align="right" style="float: right; margin: 5px"/>
- https://archive.is / https://archive.today
- https://ghostarchive.org
- https://perma.cc
- https://arquivo.pt
- https://www.pagefreezer.com
- https://www.smarsh.com
- https://www.stillio.com
- https://archive.st
- https://theoldnet.com/
- https://timetravel.mementoweb.org/
- https://freezepage.com/
- https://webcitation.org/archive
- https://archiveofourown.org/
- https://megalodon.jp/
- https://www.webarchive.org.uk/ukwa/
- https://github.com/HelloZeroNet/ZeroNet (super cool project)
- Google, Bing, DuckDuckGo, and other [search engine caches](https://www.clickminded.com/google-cache-search/)
---
### Other ArchiveBox Alternatives
> *There are **much more recent** projects listed here: https://github.com/stars/pirate/lists/internet-archiving*
- **[Browsertrix](https://webrecorder.net/browsertrix) + [ArchiveWeb.page](https://webrecorder.net/archivewebpage) + [ReplayWeb.page](https://webrecorder.net/replaywebpage) Webrecorder's archiving suite has the highest fidelity, and can flawlessly archive YouTube, X, Facebook, and other complex, JS-heavy SPAs**
- **[SingleFile](https://github.com/gildas-lormeau/SingleFile/) Web Extension / CLI util for Firefox and Chrome to save a web page as a single HTML file**
- **[Memex by Worldbrain.io](https://github.com/WorldBrain/Memex) a beautiful, user-friendly browser extension that archives all history with full-text search, annotation support, and more**
- **[Hypothes.is](https://web.hypothes.is/) a web/pdf/ebook annotation tool that also archives content**
- **[Reminiscence](https://github.com/kanishka-linux/reminiscence/) extremely similar to ArchiveBox, uses a Django backend + UI and provides auto-tagging and summary features with NLTK**
- **[Shaarchiver](https://github.com/nodiscc/shaarchiver) very similar project that archives Firefox, Shaarli, or Delicious bookmarks and all linked media, generating a markdown/HTML index**
- **[Archivy](https://github.com/archivy/archivy) Python-based self-hosted knowledge base embedded into your filesystem**
- **[Polarized](https://web.archive.org/web/20221225012011/https://getpolarized.io/) a desktop application for bookmarking, annotating, and archiving articles offline**
- **[LinkWarden](https://github.com/linkwarden/linkwarden) Link archival and curation web app, very similar to ArchiveBox**
- **[Photon](https://github.com/s0md3v/Photon) a fast crawler with archiving and asset extraction support**
- **[Scoop](https://github.com/harvard-lil/scoop)** Create high-fidelity WARC/WACZ captures using a playwright browser, with support for signing, media extraction, PDFs, etc. ([by the Perma.cc team](https://lil.law.harvard.edu/blog/2023/04/13/scoop-witnessing-the-web/))
Ones I haven't personally vetted:
- [Shiori](https://github.com/go-shiori/shiori) Simple bookmark manager + readability archiver built with Go (like a clone of Pocket)
- [Percollate](https://github.com/danburzo/percollate) A command-line tool to turn web pages into beautiful, readable PDF, EPUB, or HTML docs.
- [LinkAce](https://www.linkace.org/) A self-hosted bookmark management tool that saves snapshots to archive.org
- [LinkDing](https://github.com/sissbruecker/linkding) Self-hosted bookmark manager that is designed be to be minimal, fast, and easy to set up using Docker.
- [LinkWallet](https://github.com/tardisx/linkwallet) A self-hosted bookmark database with full-text page content search and limited archiving features
- [Espial](https://github.com/jonschoning/espial) Bookmark manager and search tool with limited archiving features
- [Diskernet](https://github.com/dosyago/DiskerNet) Archiving tool that uses the Chrome debugger protocol to save each page as-loaded in the browser** (aka 22120 by c0fe or i5ik)
- [Trilium](https://github.com/zadam/trilium) Personal web UI based knowledge-base with web clipping and note-taking
- [Herodotus](https://github.com/alaskanpuffin/herodotus-core) Django-based web archiving tool with a focus on collecting text-based content
- [Buku](https://github.com/jarun/buku) Browser-independent bookmark manager CLI written in Python3 and SQLite3
- [ReadableWebProxy](https://github.com/fake-name/ReadableWebProxy) A proxying archiver that downloads content from sites and can snapshot multiple versions of sites over time
- [Perkeep](https://perkeep.org/) "Perkeep lets you permanently keep your stuff, for life."
- [Fossilo](https://www.fossilo.com/) A commercial archiving solution that appears to be very similar to ArchiveBox
- [NeonLink](https://github.com/AlexSciFier/neonlink) Simple self-hosted bookmark management + [Benotes](https://noted.lol/benotes/) note-taking app with limited archiving features
- [Archivematica](https://github.com/artefactual/archivematica) web GUI for institutional long-term archiving of web and other content
- [Headless Chrome Crawler](https://github.com/yujiosaka/headless-chrome-crawler) distributed web crawler built on puppeteer with screenshots
- [WWWofle](http://www.gedanken.org.uk/software/wwwoffle/) old proxying recorder software similar to ArchiveBox
- [Erised](https://github.com/marvelm/erised) Super simple CLI utility to bookmark and archive webpages
- [Zotero](https://www.zotero.org/) collect, organize, cite, and share research (mainly for technical/scientific papers & citations)
- [TiddlyWiki](https://tiddlywiki.com/) Non-linear bookmark and note-taking tool with archiving support
- [Joplin](https://joplinapp.org/) Desktop + mobile app for knowledge-base-style info collection and notes (w/ optional plugin for archiving)
- [Hunchly](https://www.hunch.ly/) A paid web archiving / session recording tool design for OSINT
- [Monolith](https://github.com/Y2Z/monolith) CLI tool for saving complete web pages as a single HTML file
- [Obelisk](https://github.com/go-shiori/obelisk) Go package and CLI tool for saving web page as single HTML file
- [Munin Archiver](https://github.com/peterk/munin-indexer) Social media archiver for Facebook, Instagram and VKontakte accounts.
- **[Wayback](https://github.com/wabarc/wayback) Archiving in style like ArchiveBox, but with a chat.**
---
### Smaller Utilities
Random helpful utilities for web archiving, WARC creation and replay, and more...
- https://github.com/TheCakeIsNaOH/xbs-to-archivebox A utility to sync xBrowserSync bookmarks with ArchiveBox
- https://github.com/karlicoss/promnesia A browser extension that [collects and collates all the URLs you visit](https://beepb00p.xyz/promnesia.html) into a hierarchical/graph structure with metadata
- https://github.com/vrtdev/save-page-state A Chrome extension for saving the state of a page in multiple formats
- https://github.com/jsvine/waybackpack command-line tool that lets you download the entire Wayback Machine archive for a given URL
- https://github.com/hartator/wayback-machine-downloader Download an entire website from the Internet Archive Wayback Machine.
- https://github.com/Lifesgood123/prevent-link-rot Replace any broken URLs in some content with Wayback machine URL equivalents
- https://en.archivarix.com download an archived page or entire site from the Wayback Machine
- https://proofofexistence.com prove that a certain file existed at a given time using the blockchain
- https://github.com/chfoo/warcat for merging, extracting, and verifying WARC files
- https://github.com/mozilla/readability tool for extracting article contents and text
- https://github.com/mholt/timeliner All your digital life on a single timeline, stored locally
- https://github.com/wkhtmltopdf/wkhtmltopdf Webkit HTML to PDF archiver/saver
- [Sheetsee-Pocket](http://jlord.us/sheetsee-pocket/) project that provides a pretty auto-updating index of your Pocket links (without archiving them)
- [Pocket -> IFTTT -> Dropbox](https://christopher.su/2013/saving-pocket-links-file-day-dropbox-ifttt-launchd/) Post by Christopher Su on his Pocket saving IFTTT recipe
- http://squidman.net/squidman/index.html
- https://wordpress.org/plugins/broken-link-checker/
- https://github.com/ArchiveTeam/wpull
- http://freedup.org/
- https://en.wikipedia.org/wiki/Furl
- https://preservica.com/digital-archive-software-1/active-digital-preservation For-profit company offering a digital preservation software suite
- https://github.com/karlicoss/grasp capture webpages from Firefox and Chrome into Org-mode documents
- https://github.com/dgtlmoon/changedetection.io Change detection and monitoring of web page content changes
- [And many more on the other lists...](#the-master-lists)
---
## Reading List
A collection of blog posts and articles about internet archiving, contact me / open an issue if you want to add a link here!
---
### Blogs Friends of ArchiveBox
<img src="https://media.npr.org/assets/img/2017/06/28/istock-506236357-5961b1f611e5136a7cd3fd5f74d97f4575f48c66-s800-c85.jpg" width="350px" align="right" style="float: right; margin: 5px"/>
- https://blog.archive.org
- https://webrecorder.net/blog
- https://netpreserveblog.wordpress.com
- https://blog.conifer.rhizome.org/
- https://ws-dl.blogspot.com
- https://siarchives.si.edu/blog
- https://parameters.ssrc.org
- https://sr.ithaka.org/publications
- https://ait.blog.archive.org
- https://brewster.kahle.org
- https://ianmilligan.ca
- https://medium.com/@giovannidamiola
---
### Articles We Like About Internet Archiving
- https://items.ssrc.org/parameters/on-the-importance-of-web-archiving/
- https://theconversation.com/your-internet-data-is-rotting-115891
- https://www.bbc.com/future/story/20190401-why-theres-so-little-left-of-the-early-internet
- https://sr.ithaka.org/publications/the-state-of-digital-preservation-in-2018/
- https://gizmodo.com/delete-never-the-digital-hoarders-who-collect-tumblrs-1832900423
- https://siarchives.si.edu/blog/we-are-not-alone-progress-digital-preservation-community
- https://www.gwern.net/Archiving-URLs
- http://brewster.kahle.org/2015/08/11/locking-the-web-open-a-call-for-a-distributed-web-2/
- https://lwn.net/Articles/766374/
- https://en.wikipedia.org/wiki/List_of_Web_archiving_initiatives
- https://medium.com/@giovannidamiola/making-the-internet-archives-full-text-search-faster-30fb11574ea9
- https://xkcd.com/1909/
- https://samsaffron.com/archive/2012/06/07/testing-3-million-hyperlinks-lessons-learned#comment-31366
- https://www.gwern.net/docs/linkrot/2011-muflax-backup.pdf
- https://thoughtstreams.io/higgins/permalinking-vs-transience/
- http://ait.blog.archive.org/files/2014/04/archiveit_life_cycle_model.pdf
- https://blog.archive.org/2016/05/26/web-archiving-with-national-libraries/
- https://blog.archive.org/2014/10/28/building-libraries-together/
- https://ianmilligan.ca/2018/03/27/ethics-and-the-archived-web-presentation-the-ethics-of-studying-geocities/
- https://ianmilligan.ca/2018/05/22/new-article-if-these-crawls-could-talk-studying-and-documenting-web-archives-provenance/
- https://ws-dl.blogspot.com/2019/02/2019-02-08-google-is-being-shuttered.html
If any of these links are dead, you can find an archived version on https://archive.sweeting.me or https://web.archive.org.
---
### ArchiveBox-Specific Posts, Tutorials, and Guides
*Beware: many of these may be outdated, as ArchiveBox has frequent updates and continual improvement.*
- "Install ArchiveBox on SaltBox.dev" https://docs.saltbox.dev/sandbox/apps/archivebox/#3-setup
- "ArchiveBox is an open-source self-hosted web archiving system for the web and the desktop" https://medevel.com/archivebox/
- "Install ArchiveBox on a One-Click Docker Application" https://www.vultr.com/docs/install-archivebox-on-a-oneclick-docker-application/
- "ArchiveBox, una solución para crear nuestro propio Archive.org en miniatura y personalizado" https://www.genbeta.com/herramientas/archivebox-solucion-para-crear-nuestro-propio-archive-org-miniatura-personalizado
- "网页存档的开源工具ArchiveBox，可以将网页文字、图片、媒体文件等都保存下来，供日后查看。基于Python的开源项目，可搭建私人的网络存档服务。" https://www.bilibili.com/s/video/BV1ib4y1X7SL
- "Персональный интернет-архив без боли" https://habr.com/ru/company/vdsina/blog/550180/
- "ArchiveBox, una solución para crear nuestro propio Archive.org en miniatura y personalizado" https://www.genbeta.com/herramientas/archivebox-solucion-para-crear-nuestro-propio-archive-org-miniatura-personalizado
- "Preserve the Internet With ArchiveBox" https://www.cyberpunks.com/preserve-the-internet-with-archivebox/
- "Сам себе архивариус. Изучаем возможности ArchiveBox" https://xakep.ru/2021/02/01/archivebox/
- "使用存档盒制作自己的Internet存档" http://www.diglog.com/story/1045192.html
- "How to Make Your Own Internet Archive With ArchiveBox" https://nixintel.info/osint-tools/make-your-own-internet-archive-with-archive-box/
- "Mit ArchiveBox Webseiten auf der Festplatte archivieren" https://www.linux-community.de/ausgaben/linuxuser/2020/12/mit-archivebox-webseiten-auf-der-festplatte-archivieren/
- "ArchiveBox：开源的WEB存档" https://zhen.bushini.de/14738.html / https://www.1fishsauce.com/?p=4206
- "两个基于爬虫的项目: Kiwix & ArchiveBox" https://blog.csdn.net/JackLang/article/details/108328791
- "如何创建自己的私人自托管即时阅读应用程序" https://www.pcpc.me/tech/self-hosted-read-later-app
- "How to install ArchiveBox to preserve websites you care about"
https://blog.sleeplessbeastie.eu/2019/06/19/how-to-install-archivebox-to-preserve-websites-you-care-about/
- "How to remotely archive websites using ArchiveBox"
https://blog.sleeplessbeastie.eu/2019/06/26/how-to-remotely-archive-websites-using-archivebox/
- "How to Create Your Own Private Self-Hosted Read-It-Later App" https://www.makeuseof.com/tag/self-hosted-read-later-app/
- "How to use CutyCapt inside ArchiveBox"
https://blog.sleeplessbeastie.eu/2019/07/10/how-to-use-cutycapt-inside-archivebox/
- "Automate ArchiveBox with Google Spreadsheet to Backup your internet"
https://manfred.life/archivebox
- "【デモ有♪】ConoHaのArchiveBoxアプリケーションを使ってみたよ"
https://qiita.com/CloudRemix/items/691caf91efa3ef19a7ad
- "WEB-ARCHIV TEIL 8: WALLABAG UND ARCHIVEBOX"
http://webermartin.net/blog/web-archiv-teil-8-wallabag-und-archivebox/
- https://metaxyntax.neocities.org/entries/7.html
### ArchiveBox Discussions in News & Social Media
<img src="https://cdn.dribbble.com/users/896843/screenshots/2560608/news_media_icons-07.png" width="380px" align="right" style="float: right; margin: 5px"/>
- **Aggregators:**
**[ProductHunt](https://www.producthunt.com/posts/archivebox)**, **[AlternativeTo](https://alternativeto.net/software/archivebox/)**, **[SaaSHub](https://www.saashub.com/archivebox)**, [Logiciels](https://www.logiciels.pro/logiciel-saas/archivebox/), [SteemHunt](https://steemhunt.com/@adnan556644/archivebox-the-open-source-self-hosted-internet-archiving-solution), [Recurse Center: The Joy of Computing](https://joy.recurse.com/posts/224-archivebox), [GitHub Changelog](https://changelog.com/news/archivebox-opensource-selfhosted-web-archive-6D0d), [Dev.To Ultra List](https://dev.to/teamxenox/-ultra-list-one-list-to-rule-them-all-march-19-4p4f), [O'Reilly 4 Short Links](https://www.oreilly.com/ideas/four-short-links-15-april-2019), [JaxEnter](https://jaxenter.com/github-trending-march-2019-157470.html)
- **Blog Posts & Podcasts:**
[Korben.info](https://korben.info/archivebox-un-clone-darchive-org-et-de-la-wayback-machine-a-auto-heberger.html), [Defining Desktop Linux Podcast #296 (0:55:00)](https://linuxunplugged.com/296), [Binärgewitter Podcast #221](http://blog.binaergewitter.de/2019/01/18/binaergewitter-talk-number-221-vertieft-in-die-andere-richtung/), [Schrankmonster.de](https://www.schrankmonster.de/2019/04/10/archive-your-slice-of-the-web/), [La Ferme Du Web](https://www.lafermeduweb.net/veille/archivebox-archivez-des-copies-de-sites-en-local-avec-tous-les-medias-lies)
- **Hacker News threads and comments:**
[#1](https://news.ycombinator.com/item?id=14272133), [#2](https://news.ycombinator.com/item?id=18728546), [#3](https://news.ycombinator.com/item?id=18876685), **[#4](https://news.ycombinator.com/item?id=19346985)**, [and many more...](https://www.google.com/search?q=site%3Anews.ycombinator.com+%22archivebox%22)
- **Reddit r/DataHoarder, r/SelfHosted, etc. posts and comments**:
[#1](https://www.reddit.com/r/DataHoarder/comments/69e6i9/archive_a_browseable_copy_of_your_saved_pocket/), [#2](https://www.reddit.com/r/DataHoarder/comments/6kepv6/bookmarkarchiver_now_supports_archiving_all_major/), [#3](https://www.reddit.com/r/DataHoarder/comments/apnud4/continually_archive_websites_and_keep_the_older/), [#4](https://www.reddit.com/r/DataHoarder/comments/azdhd9/archivebox_open_source_selfhosted_web_archive/), [#5](https://www.reddit.com/r/DataHoarder/comments/b0o10h/archivebox_self_hosting_clone_of_archiveorg/) , **[#6](https://www.reddit.com/r/DataHoarder/comments/b4nrlc/in_case_you_havent_seen_it_archivebox_has_a/)**, [#7](https://www.reddit.com/r/selfhosted/comments/69eoi3/pocket_stream_archive_your_own_personal_wayback/), [#8](https://www.reddit.com/r/selfhosted/comments/an2368/archivebox_the_opensource_selfhosted_web_archive/), [and many more...](https://www.google.com/search?q=site%3Areddit.com+%22archivebox%22)
- **Twitter:**
[Python Trending](https://twitter.com/pythontrending/status/1092492387182628865), [PyCoder's Weekly](https://twitter.com/pycoders/status/1105803699799105536), [Python Hub](https://twitter.com/PythonHub/status/1107601343395651589), [Smashing Magazine](https://twitter.com/smashingmag/status/1107990604774928386), <a href="https://twitter.com/search?q=archivebox.io%20OR%20archivebox%2Farchivebox%20OR%20archiveboxapp&src=typed_query&f=live">and many more...</a>
---
## Communities
### Most Active Communities
<img src="https://www.archiveteam.org/images/f/f3/Archive_team.png" width="230px" align="right" style="float: right; margin: 5px"/>
- **[The Internet Archive (Archive.org)](https://archive.org/iathreads/forums.php)** (USA)
- **[International Internet Preservation Consortium (IIPC)](http://netpreserve.org/)** (International)
- **[The Archive Team](https://www.archiveteam.org/), [URL Team](https://www.archiveteam.org/index.php?title=URLTeam), [r/ArchiveTeam](https://reddit.com/r/ArchiveTeam)** (International)
- **[Rhizome.org](http://archive.rhizome.org/)** The digital preservation group that works on [Conifer by Rhizome](https://conifer.rhizome.org/) formerly Webrecorder.io (USA)
- **[Webrecorder](https://webrecorder.net/)** (formerly known[¹](https://blog.conifer.rhizome.org/2020/06/11/webrecorder-conifer.html) as Webrecorder.io) is a company led by Ilya Kreymer, that researches and develops web archiving tools, widely used by the community.
- **[Old Dominion University: Web Science and Digital Libraries (WS-DL @ ODU)](https://ws-dl.cs.odu.edu)** (Virginia, USA)
- **[r/DataHoarder](https://www.reddit.com/r/DataHoarder), [r/Archivists](https://www.reddit.com/r/Archivists/), [r/DHExchange](https://www.reddit.com/r/DHExchange/)** (International)
- [The Eye](https://the-eye.eu) Non-profit working on content archival and long-term preservation (Europe)
- [Digital Preservation Coalition](https://www.dpconline.org/about) & their [Software Tool Registry (COPTR)](http://coptr.digipres.org/Main_Page) (UK & Wales)
- [Archives Unleashed Project](https://archivesunleashed.org/about-project/) and [UAP GitHub](https://github.com/archivesunleashed) (Canada)
---
### Web Archiving Communities
<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/8/8d/Noun_project_community_icon_986427_cc.svg/2000px-Noun_project_community_icon_986427_cc.svg.png" width="230px" align="right" style="float: right; margin: 5px"/>
Follow these technological and organizational archiving hubs for the latest archiving news.
- [Canadian Web Archiving Coalition](https://www.carl-abrc.ca/advancing-research/digital-preservation/cwac/) (Canada)
- [Web Archives for Historical Research Group](https://uwaterloo.ca/web-archive-group/about) (Canada)
- [Smithsonian Institution Archives: Digital Curation](https://siarchives.si.edu/what-we-do/digital-curation) (Washington D.C., USA)
- [National Digital Stewardship Alliance (NDSA)](http://www.digitalpreservation.gov/ndsa/NDSAtoDLF.html) (USA)
- [Digital Library Federation (DLF)](https://www.diglib.org/about/) (USA)
- [Council on Library and Information Resources (CLIR)](http://www.clir.org/about) (USA)
- [Digital Curation Centre (DCC)](http://www.dcc.ac.uk/about-us) (UK)
- [ArchiveMatica](https://www.archivematica.org/en/) & their [Community Wiki](https://wiki.archivematica.org/Community) (International)
- [Professional Development Institutes for Digital Preservation (POWRR)](https://digitalpowrr.niu.edu/) (USA)
- [Institute of Museum and Library Services (IMLS)](https://www.imls.gov/about/mission) (USA)
- [Stanford Libraries Web Archiving](https://library.stanford.edu/projects/web-archiving) (USA)
- [Society of American Archivists: Electronic Records (SAA)](https://www2.archivists.org/groups/electronic-records-section) (USA)
- [BitCurator Consortium (BCC)](https://bitcuratorconsortium.org/mission) (USA)
- [Ethics & Archiving the Web Conference (Rhizome)](https://eaw.rhizome.org/) (USA)
- [Archivists Round Table of NYC](https://www.nycarchivists.org/) (USA)
---
### General Archiving Foundations, Coalitions, Initiatives, and Institutes
<img src="https://us.123rf.com/450wm/drvector/drvector1510/drvector151000331/45755355-government-icons.jpg?ver=6" width="230px" align="right" style="float: right; margin: 5px"/>
Find your local archiving group in the list and see how you can contribute!
- [Community Archives and Heritage Group](https://www.communityarchives.org.uk/content/about/history-and-purpose) (UK & Ireland)
- [Open Preservation Foundation (OPF)](https://openpreservation.org/about/organisation/) (UK & Europe)
- [Software Preservation Network](https://www.softwarepreservationnetwork.org/about/) (International)
- [ITHAKA](https://www.ithaka.org/content/our-mission), [Portico](https://www.portico.org/why-portico/), [JSTOR](https://www.jstor.org/), [ARTSTOR](http://www.artstor.org/), [S+R](https://sr.ithaka.org/our-work/collections-and-preservation/) (USA)
- [Archives and Records Association](https://www2.archivists.org/assoc-orgs/archives-and-records-association-united-kingdom-ireland) (UK & Ireland)
- [Arkivrådet](http://www.arkivradet.se/) (Sweden)
- [Asociación Española de Archiveros, Bibliotecarios, Museologos y Documentalistas (ANABAD)](https://www2.archivists.org/assoc-orgs/asociaci%C3%B3n-espa%C3%B1ola-de-archiveros-bibliotecarios-museologos-y-documentalistas-anabad) (Spain)
- [Associação dos Arquivistas Brasileiros (AAB)](https://www2.archivists.org/assoc-orgs/associacao-dos-arquivistas-brasileiros-aab) (Brazil)
- [Associação Portuguesa de Bibliotecários, Archivistas e Documentalistas (BAD)](https://www2.archivists.org/assoc-orgs/associacao-portuguesa-de-bibliotecarios-archivistas-e-documentalistas-bad) (Portugal)
- [Association des archivistes français (AAF)](https://www2.archivists.org/assoc-orgs/association-des-archivistes-francais-aaf) (France)
- [Associazione Nazionale Archivistica Italiana (ANAI)](https://www2.archivists.org/assoc-orgs/associazione-nazionale-archivistica-italiana-anai) (Italy)
- [Australian Society of Archivists Inc.](https://www2.archivists.org/assoc-orgs/australian-society-of-archivists-inc) (Australia)
- [International Council on Archives (ICA)](https://www2.archivists.org/assoc-orgs/international-council-on-archives-ica)
- [International Records Management Trust (IRMT)](https://www2.archivists.org/assoc-orgs/international-records-management-trust-irmt)
- [Irish Society for Archives](https://www2.archivists.org/assoc-orgs/irish-society-for-archives) (Ireland)
- [Koninklijke Vereniging van Archivarissen in Nederland](https://www2.archivists.org/assoc-orgs/koninklijke-vereniging-van-archivarissen-in-nederland) (Netherlands)
- [State Archives Administration of the People's Republic of China](https://www2.archivists.org/assoc-orgs/state-archives-administration-of-the-peoples-republic-of-china) (China)
- [Academy of Certified Archivists](https://www2.archivists.org/assoc-orgs/academy-of-certified-archivists)
- [Archivists and Librarians in the History of the Health Sciences](https://www2.archivists.org/assoc-orgs/archivists-and-librarians-in-the-history-of-the-health-sciences)
- [Archivists for Congregations of Women Religious](https://www2.archivists.org/assoc-orgs/archivists-for-congregations-of-women-religious)
- [Archivists of Religious Institutions](https://www2.archivists.org/assoc-orgs/archivists-of-religious-institutions)
- [Association of Catholic Diocesan Archivists](https://www2.archivists.org/assoc-orgs/association-of-catholic-diocesan-archivists)
- [Association of Moving Image Archivists](https://www2.archivists.org/assoc-orgs/association-of-moving-image-archivists)
- [Council of State Archivists](https://www2.archivists.org/assoc-orgs/council-of-state-archivists)
- [National Association of Government Archives and Records Administrators](https://www2.archivists.org/assoc-orgs/national-association-of-government-archives-and-records-administrators)
- [National Episcopal Historians and Archivists](https://www2.archivists.org/assoc-orgs/national-episcopal-historians-and-archivists)
- [Archival Education and Research Institute](https://www2.archivists.org/assoc-orgs/archival-education-and-research-institute)
- [Archives Leadership Institute](https://www2.archivists.org/assoc-orgs/archives-leadership-institute)
- [Georgia Archives Institute](https://www2.archivists.org/assoc-orgs/georgia-archives-institute)
- [Modern Archives Institute](https://www2.archivists.org/assoc-orgs/modern-archives-institute)
- [Western Archives Institute](https://www2.archivists.org/assoc-orgs/western-archives-institute)
- [Association des archivistes du Québec](https://www2.archivists.org/assoc-orgs/association-des-archivistes-du-quebec)
- [Association of Canadian Archivists](https://www2.archivists.org/assoc-orgs/association-of-canadian-archivists)
- [Canadian Council of Archives/Conseil canadien des archives](https://www2.archivists.org/assoc-orgs/canadian-council-of-archivesconseil-canadien-des-archives)
- [Archives Association of British Columbia](https://www2.archivists.org/assoc-orgs/archives-association-of-british-columbia)
- [Archives Association of Ontario](https://www2.archivists.org/assoc-orgs/archives-association-of-ontario)
- [Archives Council of Prince Edward Island](https://www2.archivists.org/assoc-orgs/archives-council-of-prince-edward-island)
- [Archives Society of Alberta](https://www2.archivists.org/assoc-orgs/archives-society-of-alberta)
- [Association for Manitoba Archives](https://www2.archivists.org/assoc-orgs/association-for-manitoba-archives)
- [Association of Newfoundland and Labrador Archives](https://www2.archivists.org/assoc-orgs/association-of-newfoundland-and-labrador-archives)
- [Council of Nova Scotia Archives](https://www2.archivists.org/assoc-orgs/council-of-nova-scotia-archives)
- [Réseau des services d'archives du Québec](https://www2.archivists.org/assoc-orgs/reseau-des-services-darchives-du-quebec)
- [Saskatchewan Council for Archives and Archivists](https://www2.archivists.org/assoc-orgs/saskatchewan-council-for-archives-and-archivists)
You can find more organizations and initiatives on these other lists:
- [Wikipedia.org List of Web Archiving Initiatives](https://en.wikipedia.org/wiki/List_of_Web_archiving_initiatives)
- [SAA List of USA & Canada Based Archiving Organizations](https://www2.archivists.org/assoc-orgs/directory)
- [SAA List of International Archiving Organizations](https://www2.archivists.org/assoc-orgs/i_a_o)
- [Digital Preservation Coalition's Member List](https://www.dpconline.org/about/members)
---
## ArchiveBox Community Resources
### ArchiveBox Chat Rooms
- [Official ArchiveBox Zulip Chat Server](https://zulip.archivebox.io)
- [Unofficial ArchiveBox Matrix chat room](https://matrix.to/#/#archivebox:matrix.org) (old)
- [GitHub Discussions](https://github.com/ArchiveBox/ArchiveBox/discussions)
### ArchiveBox on Social Media
- [Twitter: @ArchiveBoxApp](https://twitter.com/ArchiveBoxApp)
- [LinkedIn: ArchiveBox](https://www.linkedin.com/company/archivebox/)
- [YouTube: @ArchiveBoxApp](https://www.youtube.com/@ArchiveBoxApp)
- [Reddit: r/ArchiveBox](https://www.reddit.com/r/ArchiveBox/)
- [Alternative.to](https://alternativeto.net/software/archivebox/about/)
- [ReposHub](https://reposhub.com/python/web-crawling/pirate-ArchiveBox.html)
### ArchiveBox on Package Distribution Platforms
- [Python PyPI](https://pypi.org/project/archivebox/)
- [Docker Hub](https://hub.docker.com/r/archivebox/archivebox)
- [ArchLinux AUR](https://aur.archlinux.org/packages/archivebox)
- [Ubuntu Launchpad PPA](https://launchpad.net/~archivebox/+archive/ubuntu/archivebox)
---
<div align="center">
[![](https://img.shields.io/badge/Donate-ArchiveBox.io-%23DD5D76.svg)](https://www.patreon.com/theSquashSH)
[![](https://img.shields.io/badge/Donate-Archive.org-%23115D76.svg)](https://archive.org/donate/)
<br/><br/>
<small><a href="#contents">^ &nbsp; Back to Top &nbsp; ^</a></small>
</div>

7
docs/_Footer.md
View File

@ -1,7 +0,0 @@
<div align="center">
[✏️ Help improve our documentation...](https://github.com/ArchiveBox/ArchiveBox/issues/new?template=3-documentation_change.yml)
</div>
![](https://imgur.zervice.io/8y6hvZa.png)

58
docs/_Sidebar.md
View File

@ -1,58 +0,0 @@
[![](https://github.com/ArchiveBox/ArchiveBox/assets/511499/acffcee3-d1ec-439d-8278-e481101c3d0d)](Home)
# [Getting Started](Quickstart)
- 🔢 [[Quickstart]]
- 🖥️ [[Install]]
- 🐳 [[Docker]]
- ➡️ [Supported Sources](https://github.com/ArchiveBox/ArchiveBox/wiki/Quickstart#2-get-your-list-of-urls-to-archive)
- ⬅️ [Supported Outputs](https://github.com/ArchiveBox/ArchiveBox#output-formats)
# [[Usage]]
- ﹩[Command Line](Usage#cli-usage)
- 🌐 [Web UI](Usage#ui-usage)
- 🧩 [Browser Extension](Usage#browser-extension-usage)
- 👾 [REST API](https://github.com/ArchiveBox/ArchiveBox/issues/496#issuecomment-2080174235) / [Webhooks](https://github.com/ArchiveBox/ArchiveBox/pull/1418)
- 📜 [Python API](https://docs.archivebox.io/dev/apidocs/index.html) / [REPL](Usage#python-shell-usage) / [SQL API](Usage#sql-shell-usage)
# Reference
- ⚙️ [[Configuration]]
- 📦 [Dependencies](https://github.com/ArchiveBox/ArchiveBox#dependencies)
- 💿 [Disk Layout](https://github.com/ArchiveBox/ArchiveBox#archive-layout)
- 🔒 [[Security Overview]]
- 📝 [Developer Documentation](https://github.com/ArchiveBox/ArchiveBox#archivebox-development)
# Guides
- [[Upgrading]]
- [[Setting up Storage]] <small>(NFS/SMB/S3/etc)</small>
- [[Setting up Authentication]] <small>(SSO/LDAP/etc)</small>
- [[Setting up Search]] <small>(rg/sonic/etc)</small>
- [[Scheduled Archiving]]
- [[Publishing Your Archive]]
- [[Chromium Install]]
- [Cookies & Sessions Setup](https://github.com/ArchiveBox/ArchiveBox/wiki/Chromium-Install#setting-up-a-chromium-user-profile)
- [[Merging Collections]]
- [[Troubleshooting]]
# More Info
- ⭐️ [[Web Archiving Community]]
- [Background & Motivation](https://github.com/ArchiveBox/ArchiveBox#background--motivation)
- [Comparison to Other Tools](https://github.com/ArchiveBox/ArchiveBox#comparison-to-other-projects)
- [Architecture Diagram](https://github.com/ArchiveBox/ArchiveBox/wiki/ArchiveBox-Architecture-Diagrams)
- [Changelog](https://github.com/ArchiveBox/ArchiveBox/releases) & [[Roadmap]]
---
<p align="center">
<a href="https://archivebox.io"><img src="https://github.com/ArchiveBox/ArchiveBox/assets/511499/fd4d3161-3860-4b31-a4e9-251c05f75cdf" height="30px"/></a>
<br/><br/>
<a href="https://github.com/ArchiveBox/ArchiveBox"><img src="https://img.shields.io/github/stars/ArchiveBox/ArchiveBox.svg?logo=github&label=Stars&logoColor=blue"/></a> &nbsp; <a href="https://archivebox-shop.fourthwall.com/"><img src="https://img.shields.io/badge/Merch-%23903851.svg"/></a>
<br/>
<a href="https://hcb.hackclub.com/donations/start/archivebox"><img src="https://img.shields.io/badge/Donate-Directly-%13DE5D26.svg"/></a> &nbsp; <a href="https://github.com/sponsors/pirate"><img src="https://img.shields.io/badge/Github_Sponsors-%23B7CDFE.svg"/></a>
<br/><br/>
<a href="https://zulip.archivebox.io"><img src="https://img.shields.io/badge/Community_Chat_Forum-Zulip-%2328A745.svg"/></a>
</p>

6154
docs/_static/css/theme.css vendored
View File

File diff suppressed because it is too large Load Diff

BIN
docs/_static/icon.png vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 10 KiB

13
docs/_templates/layout.html vendored
View File

@ -1,13 +0,0 @@
{% extends "!layout.html" %}
{% block body %}
{% if READTHEDOCS and current_version != "stable" %}
<div class="admonition warning">
<p class="admonition-title">Development Docs</p>
<p>You are reading docs for <strong>ArchiveBox {{ version }}</strong> (pre-release).
These docs may include unreleased features and breaking changes.
For the latest stable release, see the <a href="/en/stable/">stable docs</a>.</p>
</div>
{% endif %}
{{ super() }}
{% endblock %}

33
docs/apidocs/archivebox/archivebox.__main__.md
View File

@ -1,33 +0,0 @@
# {py:mod}`archivebox.__main__`
```{py:module} archivebox.__main__
```
```{autodoc2-docstring} archivebox.__main__
:allowtitles:
```
## Module Contents
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`ASCII_LOGO_MINI <archivebox.__main__.ASCII_LOGO_MINI>`
- ```{autodoc2-docstring} archivebox.__main__.ASCII_LOGO_MINI
:summary:
```
````
### API
````{py:data} ASCII_LOGO_MINI
:canonical: archivebox.__main__.ASCII_LOGO_MINI
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.__main__.ASCII_LOGO_MINI
```
````

215
docs/apidocs/archivebox/archivebox.api.admin.md
View File

@ -1,215 +0,0 @@
# {py:mod}`archivebox.api.admin`
```{py:module} archivebox.api.admin
```
```{autodoc2-docstring} archivebox.api.admin
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`APITokenAdmin <archivebox.api.admin.APITokenAdmin>`
-
* - {py:obj}`OutboundWebhookAdminForm <archivebox.api.admin.OutboundWebhookAdminForm>`
-
* - {py:obj}`CustomWebhookAdmin <archivebox.api.admin.CustomWebhookAdmin>`
-
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_webhook_fields <archivebox.api.admin._webhook_fields>`
- ```{autodoc2-docstring} archivebox.api.admin._webhook_fields
:summary:
```
* - {py:obj}`register_admin <archivebox.api.admin.register_admin>`
- ```{autodoc2-docstring} archivebox.api.admin.register_admin
:summary:
```
````
### API
````{py:function} _webhook_fields(*names: str) -> tuple[str, ...]
:canonical: archivebox.api.admin._webhook_fields
```{autodoc2-docstring} archivebox.api.admin._webhook_fields
```
````
`````{py:class} APITokenAdmin(model, admin_site)
:canonical: archivebox.api.admin.APITokenAdmin
Bases: {py:obj}`archivebox.base_models.admin.BaseModelAdmin`
````{py:attribute} list_display
:canonical: archivebox.api.admin.APITokenAdmin.list_display
:value: >
('created_at', 'id', 'created_by', 'token_redacted', 'expires')
```{autodoc2-docstring} archivebox.api.admin.APITokenAdmin.list_display
```
````
````{py:attribute} sort_fields
:canonical: archivebox.api.admin.APITokenAdmin.sort_fields
:value: >
('id', 'created_at', 'created_by', 'expires')
```{autodoc2-docstring} archivebox.api.admin.APITokenAdmin.sort_fields
```
````
````{py:attribute} readonly_fields
:canonical: archivebox.api.admin.APITokenAdmin.readonly_fields
:value: >
('created_at', 'modified_at')
```{autodoc2-docstring} archivebox.api.admin.APITokenAdmin.readonly_fields
```
````
````{py:attribute} search_fields
:canonical: archivebox.api.admin.APITokenAdmin.search_fields
:value: >
('id', 'created_by__username', 'token')
```{autodoc2-docstring} archivebox.api.admin.APITokenAdmin.search_fields
```
````
````{py:attribute} fieldsets
:canonical: archivebox.api.admin.APITokenAdmin.fieldsets
:value: >
(('Token',), ('Owner',), ('Timestamps',))
```{autodoc2-docstring} archivebox.api.admin.APITokenAdmin.fieldsets
```
````
````{py:attribute} list_filter
:canonical: archivebox.api.admin.APITokenAdmin.list_filter
:value: >
('created_by',)
```{autodoc2-docstring} archivebox.api.admin.APITokenAdmin.list_filter
```
````
````{py:attribute} ordering
:canonical: archivebox.api.admin.APITokenAdmin.ordering
:value: >
['-created_at']
```{autodoc2-docstring} archivebox.api.admin.APITokenAdmin.ordering
```
````
````{py:attribute} list_per_page
:canonical: archivebox.api.admin.APITokenAdmin.list_per_page
:value: >
100
```{autodoc2-docstring} archivebox.api.admin.APITokenAdmin.list_per_page
```
````
`````
```{py:class} OutboundWebhookAdminForm(*args, **kwargs)
:canonical: archivebox.api.admin.OutboundWebhookAdminForm
Bases: {py:obj}`signal_webhooks.admin.WebhookModelForm`
```
`````{py:class} CustomWebhookAdmin(model, admin_site)
:canonical: archivebox.api.admin.CustomWebhookAdmin
Bases: {py:obj}`signal_webhooks.admin.WebhookAdmin`, {py:obj}`archivebox.base_models.admin.BaseModelAdmin`
````{py:attribute} form
:canonical: archivebox.api.admin.CustomWebhookAdmin.form
:value: >
None
```{autodoc2-docstring} archivebox.api.admin.CustomWebhookAdmin.form
```
````
````{py:attribute} list_display
:canonical: archivebox.api.admin.CustomWebhookAdmin.list_display
:value: >
('created_at', 'created_by', 'id')
```{autodoc2-docstring} archivebox.api.admin.CustomWebhookAdmin.list_display
```
````
````{py:attribute} sort_fields
:canonical: archivebox.api.admin.CustomWebhookAdmin.sort_fields
:value: >
'_webhook_fields(...)'
```{autodoc2-docstring} archivebox.api.admin.CustomWebhookAdmin.sort_fields
```
````
````{py:attribute} readonly_fields
:canonical: archivebox.api.admin.CustomWebhookAdmin.readonly_fields
:value: >
'_webhook_fields(...)'
```{autodoc2-docstring} archivebox.api.admin.CustomWebhookAdmin.readonly_fields
```
````
````{py:attribute} fieldsets
:canonical: archivebox.api.admin.CustomWebhookAdmin.fieldsets
:value: >
(('Webhook',), ('Authentication',), ('Status',), ('Owner',), ('Timestamps',))
```{autodoc2-docstring} archivebox.api.admin.CustomWebhookAdmin.fieldsets
```
````
````{py:method} lookup_allowed(lookup: str, value: str, request: django.http.HttpRequest | None = None) -> bool
:canonical: archivebox.api.admin.CustomWebhookAdmin.lookup_allowed
```{autodoc2-docstring} archivebox.api.admin.CustomWebhookAdmin.lookup_allowed
```
````
`````
````{py:function} register_admin(admin_site: django.contrib.admin.AdminSite) -> None
:canonical: archivebox.api.admin.register_admin
```{autodoc2-docstring} archivebox.api.admin.register_admin
```
````

68
docs/apidocs/archivebox/archivebox.api.apps.md
View File

@ -1,68 +0,0 @@
# {py:mod}`archivebox.api.apps`
```{py:module} archivebox.api.apps
```
```{autodoc2-docstring} archivebox.api.apps
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`APIConfig <archivebox.api.apps.APIConfig>`
-
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`register_admin <archivebox.api.apps.register_admin>`
- ```{autodoc2-docstring} archivebox.api.apps.register_admin
:summary:
```
````
### API
`````{py:class} APIConfig(app_name, app_module)
:canonical: archivebox.api.apps.APIConfig
Bases: {py:obj}`django.apps.AppConfig`
````{py:attribute} name
:canonical: archivebox.api.apps.APIConfig.name
:value: >
'archivebox.api'
```{autodoc2-docstring} archivebox.api.apps.APIConfig.name
```
````
````{py:attribute} label
:canonical: archivebox.api.apps.APIConfig.label
:value: >
'api'
```{autodoc2-docstring} archivebox.api.apps.APIConfig.label
```
````
`````
````{py:function} register_admin(admin_site)
:canonical: archivebox.api.apps.register_admin
```{autodoc2-docstring} archivebox.api.apps.register_admin
```
````

198
docs/apidocs/archivebox/archivebox.api.auth.md
View File

@ -1,198 +0,0 @@
# {py:mod}`archivebox.api.auth`
```{py:module} archivebox.api.auth
```
```{autodoc2-docstring} archivebox.api.auth
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`HeaderTokenAuth <archivebox.api.auth.HeaderTokenAuth>`
- ```{autodoc2-docstring} archivebox.api.auth.HeaderTokenAuth
:summary:
```
* - {py:obj}`BearerTokenAuth <archivebox.api.auth.BearerTokenAuth>`
- ```{autodoc2-docstring} archivebox.api.auth.BearerTokenAuth
:summary:
```
* - {py:obj}`QueryParamTokenAuth <archivebox.api.auth.QueryParamTokenAuth>`
- ```{autodoc2-docstring} archivebox.api.auth.QueryParamTokenAuth
:summary:
```
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`get_or_create_api_token <archivebox.api.auth.get_or_create_api_token>`
- ```{autodoc2-docstring} archivebox.api.auth.get_or_create_api_token
:summary:
```
* - {py:obj}`auth_using_token <archivebox.api.auth.auth_using_token>`
- ```{autodoc2-docstring} archivebox.api.auth.auth_using_token
:summary:
```
* - {py:obj}`auth_using_password <archivebox.api.auth.auth_using_password>`
- ```{autodoc2-docstring} archivebox.api.auth.auth_using_password
:summary:
```
* - {py:obj}`_require_superuser <archivebox.api.auth._require_superuser>`
- ```{autodoc2-docstring} archivebox.api.auth._require_superuser
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`API_AUTH_METHODS <archivebox.api.auth.API_AUTH_METHODS>`
- ```{autodoc2-docstring} archivebox.api.auth.API_AUTH_METHODS
:summary:
```
````
### API
````{py:function} get_or_create_api_token(user: django.contrib.auth.models.User | None)
:canonical: archivebox.api.auth.get_or_create_api_token
```{autodoc2-docstring} archivebox.api.auth.get_or_create_api_token
```
````
````{py:function} auth_using_token(token: str | None, request: django.http.HttpRequest | None = None) -> django.contrib.auth.models.User | None
:canonical: archivebox.api.auth.auth_using_token
```{autodoc2-docstring} archivebox.api.auth.auth_using_token
```
````
````{py:function} auth_using_password(username: str | None, password: str | None, request: django.http.HttpRequest | None = None) -> django.contrib.auth.models.User | None
:canonical: archivebox.api.auth.auth_using_password
```{autodoc2-docstring} archivebox.api.auth.auth_using_password
```
````
````{py:function} _require_superuser(user: django.contrib.auth.models.User | None, request: django.http.HttpRequest, auth_method: str) -> django.contrib.auth.models.User | None
:canonical: archivebox.api.auth._require_superuser
```{autodoc2-docstring} archivebox.api.auth._require_superuser
```
````
`````{py:class} HeaderTokenAuth()
:canonical: archivebox.api.auth.HeaderTokenAuth
Bases: {py:obj}`ninja.security.APIKeyHeader`
```{autodoc2-docstring} archivebox.api.auth.HeaderTokenAuth
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.api.auth.HeaderTokenAuth.__init__
```
````{py:attribute} param_name
:canonical: archivebox.api.auth.HeaderTokenAuth.param_name
:value: >
'X-ArchiveBox-API-Key'
```{autodoc2-docstring} archivebox.api.auth.HeaderTokenAuth.param_name
```
````
````{py:method} authenticate(request: django.http.HttpRequest, key: str | None) -> django.contrib.auth.models.User | None
:canonical: archivebox.api.auth.HeaderTokenAuth.authenticate
```{autodoc2-docstring} archivebox.api.auth.HeaderTokenAuth.authenticate
```
````
`````
`````{py:class} BearerTokenAuth()
:canonical: archivebox.api.auth.BearerTokenAuth
Bases: {py:obj}`ninja.security.HttpBearer`
```{autodoc2-docstring} archivebox.api.auth.BearerTokenAuth
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.api.auth.BearerTokenAuth.__init__
```
````{py:method} authenticate(request: django.http.HttpRequest, token: str) -> django.contrib.auth.models.User | None
:canonical: archivebox.api.auth.BearerTokenAuth.authenticate
```{autodoc2-docstring} archivebox.api.auth.BearerTokenAuth.authenticate
```
````
`````
`````{py:class} QueryParamTokenAuth()
:canonical: archivebox.api.auth.QueryParamTokenAuth
Bases: {py:obj}`ninja.security.APIKeyQuery`
```{autodoc2-docstring} archivebox.api.auth.QueryParamTokenAuth
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.api.auth.QueryParamTokenAuth.__init__
```
````{py:attribute} param_name
:canonical: archivebox.api.auth.QueryParamTokenAuth.param_name
:value: >
'api_key'
```{autodoc2-docstring} archivebox.api.auth.QueryParamTokenAuth.param_name
```
````
````{py:method} authenticate(request: django.http.HttpRequest, key: str | None) -> django.contrib.auth.models.User | None
:canonical: archivebox.api.auth.QueryParamTokenAuth.authenticate
```{autodoc2-docstring} archivebox.api.auth.QueryParamTokenAuth.authenticate
```
````
`````
````{py:data} API_AUTH_METHODS
:canonical: archivebox.api.auth.API_AUTH_METHODS
:value: >
None
```{autodoc2-docstring} archivebox.api.auth.API_AUTH_METHODS
```
````

30
docs/apidocs/archivebox/archivebox.api.md
View File

@ -1,30 +0,0 @@
# {py:mod}`archivebox.api`
```{py:module} archivebox.api
```
```{autodoc2-docstring} archivebox.api
:allowtitles:
```
## Submodules
```{toctree}
:titlesonly:
:maxdepth: 1
archivebox.api.auth
archivebox.api.v1_auth
archivebox.api.v1_api
archivebox.api.models
archivebox.api.v1_cli
archivebox.api.v1_core
archivebox.api.apps
archivebox.api.admin
archivebox.api.v1_personas
archivebox.api.webhooks
archivebox.api.urls
archivebox.api.v1_machine
archivebox.api.middleware
archivebox.api.v1_crawls
```

54
docs/apidocs/archivebox/archivebox.api.middleware.md
View File

@ -1,54 +0,0 @@
# {py:mod}`archivebox.api.middleware`
```{py:module} archivebox.api.middleware
```
```{autodoc2-docstring} archivebox.api.middleware
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`ApiCorsMiddleware <archivebox.api.middleware.ApiCorsMiddleware>`
- ```{autodoc2-docstring} archivebox.api.middleware.ApiCorsMiddleware
:summary:
```
````
### API
`````{py:class} ApiCorsMiddleware(get_response)
:canonical: archivebox.api.middleware.ApiCorsMiddleware
```{autodoc2-docstring} archivebox.api.middleware.ApiCorsMiddleware
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.api.middleware.ApiCorsMiddleware.__init__
```
````{py:method} __call__(request)
:canonical: archivebox.api.middleware.ApiCorsMiddleware.__call__
```{autodoc2-docstring} archivebox.api.middleware.ApiCorsMiddleware.__call__
```
````
````{py:method} _add_cors_headers(request, response)
:canonical: archivebox.api.middleware.ApiCorsMiddleware._add_cors_headers
```{autodoc2-docstring} archivebox.api.middleware.ApiCorsMiddleware._add_cors_headers
```
````
`````

250
docs/apidocs/archivebox/archivebox.api.models.md
View File

@ -1,250 +0,0 @@
# {py:mod}`archivebox.api.models`
```{py:module} archivebox.api.models
```
```{autodoc2-docstring} archivebox.api.models
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`APIToken <archivebox.api.models.APIToken>`
-
* - {py:obj}`OutboundWebhook <archivebox.api.models.OutboundWebhook>`
-
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`generate_secret_token <archivebox.api.models.generate_secret_token>`
- ```{autodoc2-docstring} archivebox.api.models.generate_secret_token
:summary:
```
````
### API
````{py:function} generate_secret_token() -> str
:canonical: archivebox.api.models.generate_secret_token
```{autodoc2-docstring} archivebox.api.models.generate_secret_token
```
````
``````{py:class} APIToken(*args, **kwargs)
:canonical: archivebox.api.models.APIToken
Bases: {py:obj}`django.db.models.Model`
````{py:attribute} id
:canonical: archivebox.api.models.APIToken.id
:value: >
'UUIDField(...)'
```{autodoc2-docstring} archivebox.api.models.APIToken.id
```
````
````{py:attribute} created_by
:canonical: archivebox.api.models.APIToken.created_by
:value: >
'ForeignKey(...)'
```{autodoc2-docstring} archivebox.api.models.APIToken.created_by
```
````
````{py:attribute} created_at
:canonical: archivebox.api.models.APIToken.created_at
:value: >
'DateTimeField(...)'
```{autodoc2-docstring} archivebox.api.models.APIToken.created_at
```
````
````{py:attribute} modified_at
:canonical: archivebox.api.models.APIToken.modified_at
:value: >
'DateTimeField(...)'
```{autodoc2-docstring} archivebox.api.models.APIToken.modified_at
```
````
````{py:attribute} token
:canonical: archivebox.api.models.APIToken.token
:value: >
'CharField(...)'
```{autodoc2-docstring} archivebox.api.models.APIToken.token
```
````
````{py:attribute} expires
:canonical: archivebox.api.models.APIToken.expires
:value: >
'DateTimeField(...)'
```{autodoc2-docstring} archivebox.api.models.APIToken.expires
```
````
`````{py:class} Meta
:canonical: archivebox.api.models.APIToken.Meta
Bases: {py:obj}`django_stubs_ext.db.models.TypedModelMeta`
````{py:attribute} app_label
:canonical: archivebox.api.models.APIToken.Meta.app_label
:value: >
'api'
```{autodoc2-docstring} archivebox.api.models.APIToken.Meta.app_label
```
````
````{py:attribute} verbose_name
:canonical: archivebox.api.models.APIToken.Meta.verbose_name
:value: >
'API Key'
```{autodoc2-docstring} archivebox.api.models.APIToken.Meta.verbose_name
```
````
````{py:attribute} verbose_name_plural
:canonical: archivebox.api.models.APIToken.Meta.verbose_name_plural
:value: >
'API Keys'
```{autodoc2-docstring} archivebox.api.models.APIToken.Meta.verbose_name_plural
```
````
`````
````{py:method} __str__() -> str
:canonical: archivebox.api.models.APIToken.__str__
````
````{py:property} token_redacted
:canonical: archivebox.api.models.APIToken.token_redacted
```{autodoc2-docstring} archivebox.api.models.APIToken.token_redacted
```
````
````{py:method} is_valid(for_date=None)
:canonical: archivebox.api.models.APIToken.is_valid
```{autodoc2-docstring} archivebox.api.models.APIToken.is_valid
```
````
``````
``````{py:class} OutboundWebhook(*args, **kwargs)
:canonical: archivebox.api.models.OutboundWebhook
Bases: {py:obj}`signal_webhooks.models.WebhookBase`
````{py:attribute} id
:canonical: archivebox.api.models.OutboundWebhook.id
:value: >
'UUIDField(...)'
```{autodoc2-docstring} archivebox.api.models.OutboundWebhook.id
```
````
````{py:attribute} created_by
:canonical: archivebox.api.models.OutboundWebhook.created_by
:value: >
'ForeignKey(...)'
```{autodoc2-docstring} archivebox.api.models.OutboundWebhook.created_by
```
````
````{py:attribute} created_at
:canonical: archivebox.api.models.OutboundWebhook.created_at
:value: >
'DateTimeField(...)'
```{autodoc2-docstring} archivebox.api.models.OutboundWebhook.created_at
```
````
````{py:attribute} modified_at
:canonical: archivebox.api.models.OutboundWebhook.modified_at
:value: >
'DateTimeField(...)'
```{autodoc2-docstring} archivebox.api.models.OutboundWebhook.modified_at
```
````
`````{py:class} Meta
:canonical: archivebox.api.models.OutboundWebhook.Meta
Bases: {py:obj}`signal_webhooks.models.WebhookBase.Meta`
```{autodoc2-docstring} archivebox.api.models.OutboundWebhook.Meta
```
````{py:attribute} app_label
:canonical: archivebox.api.models.OutboundWebhook.Meta.app_label
:value: >
'api'
```{autodoc2-docstring} archivebox.api.models.OutboundWebhook.Meta.app_label
```
````
````{py:attribute} verbose_name
:canonical: archivebox.api.models.OutboundWebhook.Meta.verbose_name
:value: >
'API Outbound Webhook'
```{autodoc2-docstring} archivebox.api.models.OutboundWebhook.Meta.verbose_name
```
````
`````
````{py:method} __str__() -> str
:canonical: archivebox.api.models.OutboundWebhook.__str__
````
``````

53
docs/apidocs/archivebox/archivebox.api.urls.md
View File

@ -1,53 +0,0 @@
# {py:mod}`archivebox.api.urls`
```{py:module} archivebox.api.urls
```
```{autodoc2-docstring} archivebox.api.urls
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`archive_redirect_view <archivebox.api.urls.archive_redirect_view>`
- ```{autodoc2-docstring} archivebox.api.urls.archive_redirect_view
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`urlpatterns <archivebox.api.urls.urlpatterns>`
- ```{autodoc2-docstring} archivebox.api.urls.urlpatterns
:summary:
```
````
### API
````{py:function} archive_redirect_view(request: django.http.HttpRequest, url: str) -> django.http.HttpResponseRedirect
:canonical: archivebox.api.urls.archive_redirect_view
```{autodoc2-docstring} archivebox.api.urls.archive_redirect_view
```
````
````{py:data} urlpatterns
:canonical: archivebox.api.urls.urlpatterns
:value: >
None
```{autodoc2-docstring} archivebox.api.urls.urlpatterns
```
````

131
docs/apidocs/archivebox/archivebox.api.v1_api.md
View File

@ -1,131 +0,0 @@
# {py:mod}`archivebox.api.v1_api`
```{py:module} archivebox.api.v1_api
```
```{autodoc2-docstring} archivebox.api.v1_api
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`NinjaAPIWithIOCapture <archivebox.api.v1_api.NinjaAPIWithIOCapture>`
-
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`register_urls <archivebox.api.v1_api.register_urls>`
- ```{autodoc2-docstring} archivebox.api.v1_api.register_urls
:summary:
```
* - {py:obj}`generic_exception_handler <archivebox.api.v1_api.generic_exception_handler>`
- ```{autodoc2-docstring} archivebox.api.v1_api.generic_exception_handler
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`COMMIT_HASH <archivebox.api.v1_api.COMMIT_HASH>`
- ```{autodoc2-docstring} archivebox.api.v1_api.COMMIT_HASH
:summary:
```
* - {py:obj}`html_description <archivebox.api.v1_api.html_description>`
- ```{autodoc2-docstring} archivebox.api.v1_api.html_description
:summary:
```
* - {py:obj}`api <archivebox.api.v1_api.api>`
- ```{autodoc2-docstring} archivebox.api.v1_api.api
:summary:
```
* - {py:obj}`urls <archivebox.api.v1_api.urls>`
- ```{autodoc2-docstring} archivebox.api.v1_api.urls
:summary:
```
````
### API
````{py:data} COMMIT_HASH
:canonical: archivebox.api.v1_api.COMMIT_HASH
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_api.COMMIT_HASH
```
````
````{py:data} html_description
:canonical: archivebox.api.v1_api.html_description
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_api.html_description
```
````
````{py:function} register_urls(api: ninja.NinjaAPI) -> ninja.NinjaAPI
:canonical: archivebox.api.v1_api.register_urls
```{autodoc2-docstring} archivebox.api.v1_api.register_urls
```
````
`````{py:class} NinjaAPIWithIOCapture(*, title: str = 'NinjaAPI', version: str = '1.0.0', description: str = '', openapi_url: typing.Optional[str] = '/openapi.json', docs: ninja.openapi.docs.DocsBase = Swagger(), docs_url: typing.Optional[str] = '/docs', docs_decorator: typing.Optional[typing.Callable[[ninja.types.TCallable], ninja.types.TCallable]] = None, servers: typing.Optional[typing.List[ninja.types.DictStrAny]] = None, urls_namespace: typing.Optional[str] = None, auth: typing.Optional[typing.Union[typing.Sequence[typing.Callable], typing.Callable, ninja.constants.NOT_SET_TYPE]] = NOT_SET, throttle: typing.Union[ninja.throttling.BaseThrottle, typing.List[ninja.throttling.BaseThrottle], ninja.constants.NOT_SET_TYPE] = NOT_SET, renderer: typing.Optional[ninja.renderers.BaseRenderer] = None, parser: typing.Optional[ninja.parser.Parser] = None, default_router: typing.Optional[ninja.router.Router] = None, openapi_extra: typing.Optional[typing.Dict[str, typing.Any]] = None)
:canonical: archivebox.api.v1_api.NinjaAPIWithIOCapture
Bases: {py:obj}`ninja.NinjaAPI`
````{py:method} create_temporal_response(request: django.http.HttpRequest) -> django.http.HttpResponse
:canonical: archivebox.api.v1_api.NinjaAPIWithIOCapture.create_temporal_response
```{autodoc2-docstring} archivebox.api.v1_api.NinjaAPIWithIOCapture.create_temporal_response
```
````
`````
````{py:data} api
:canonical: archivebox.api.v1_api.api
:value: >
'NinjaAPIWithIOCapture(...)'
```{autodoc2-docstring} archivebox.api.v1_api.api
```
````
````{py:data} urls
:canonical: archivebox.api.v1_api.urls
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_api.urls
```
````
````{py:function} generic_exception_handler(request, err)
:canonical: archivebox.api.v1_api.generic_exception_handler
```{autodoc2-docstring} archivebox.api.v1_api.generic_exception_handler
```
````

145
docs/apidocs/archivebox/archivebox.api.v1_auth.md
View File

@ -1,145 +0,0 @@
# {py:mod}`archivebox.api.v1_auth`
```{py:module} archivebox.api.v1_auth
```
```{autodoc2-docstring} archivebox.api.v1_auth
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`PasswordAuthSchema <archivebox.api.v1_auth.PasswordAuthSchema>`
- ```{autodoc2-docstring} archivebox.api.v1_auth.PasswordAuthSchema
:summary:
```
* - {py:obj}`TokenAuthSchema <archivebox.api.v1_auth.TokenAuthSchema>`
- ```{autodoc2-docstring} archivebox.api.v1_auth.TokenAuthSchema
:summary:
```
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`get_api_token <archivebox.api.v1_auth.get_api_token>`
- ```{autodoc2-docstring} archivebox.api.v1_auth.get_api_token
:summary:
```
* - {py:obj}`check_api_token <archivebox.api.v1_auth.check_api_token>`
- ```{autodoc2-docstring} archivebox.api.v1_auth.check_api_token
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`router <archivebox.api.v1_auth.router>`
- ```{autodoc2-docstring} archivebox.api.v1_auth.router
:summary:
```
````
### API
````{py:data} router
:canonical: archivebox.api.v1_auth.router
:value: >
'Router(...)'
```{autodoc2-docstring} archivebox.api.v1_auth.router
```
````
`````{py:class} PasswordAuthSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_auth.PasswordAuthSchema
Bases: {py:obj}`ninja.Schema`
```{autodoc2-docstring} archivebox.api.v1_auth.PasswordAuthSchema
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.api.v1_auth.PasswordAuthSchema.__init__
```
````{py:attribute} username
:canonical: archivebox.api.v1_auth.PasswordAuthSchema.username
:type: str | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_auth.PasswordAuthSchema.username
```
````
````{py:attribute} password
:canonical: archivebox.api.v1_auth.PasswordAuthSchema.password
:type: str | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_auth.PasswordAuthSchema.password
```
````
`````
````{py:function} get_api_token(request: django.http.HttpRequest, auth_data: archivebox.api.v1_auth.PasswordAuthSchema)
:canonical: archivebox.api.v1_auth.get_api_token
```{autodoc2-docstring} archivebox.api.v1_auth.get_api_token
```
````
`````{py:class} TokenAuthSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_auth.TokenAuthSchema
Bases: {py:obj}`ninja.Schema`
```{autodoc2-docstring} archivebox.api.v1_auth.TokenAuthSchema
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.api.v1_auth.TokenAuthSchema.__init__
```
````{py:attribute} token
:canonical: archivebox.api.v1_auth.TokenAuthSchema.token
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_auth.TokenAuthSchema.token
```
````
`````
````{py:function} check_api_token(request: django.http.HttpRequest, token_data: archivebox.api.v1_auth.TokenAuthSchema)
:canonical: archivebox.api.v1_auth.check_api_token
```{autodoc2-docstring} archivebox.api.v1_auth.check_api_token
```
````

898
docs/apidocs/archivebox/archivebox.api.v1_cli.md
View File

@ -1,898 +0,0 @@
# {py:mod}`archivebox.api.v1_cli`
```{py:module} archivebox.api.v1_cli
```
```{autodoc2-docstring} archivebox.api.v1_cli
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`CLICommandResponseSchema <archivebox.api.v1_cli.CLICommandResponseSchema>`
-
* - {py:obj}`FilterTypeChoices <archivebox.api.v1_cli.FilterTypeChoices>`
-
* - {py:obj}`StatusChoices <archivebox.api.v1_cli.StatusChoices>`
-
* - {py:obj}`AddCommandSchema <archivebox.api.v1_cli.AddCommandSchema>`
-
* - {py:obj}`UpdateCommandSchema <archivebox.api.v1_cli.UpdateCommandSchema>`
-
* - {py:obj}`ScheduleCommandSchema <archivebox.api.v1_cli.ScheduleCommandSchema>`
-
* - {py:obj}`ListCommandSchema <archivebox.api.v1_cli.ListCommandSchema>`
-
* - {py:obj}`RemoveCommandSchema <archivebox.api.v1_cli.RemoveCommandSchema>`
-
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`cli_add <archivebox.api.v1_cli.cli_add>`
- ```{autodoc2-docstring} archivebox.api.v1_cli.cli_add
:summary:
```
* - {py:obj}`cli_update <archivebox.api.v1_cli.cli_update>`
- ```{autodoc2-docstring} archivebox.api.v1_cli.cli_update
:summary:
```
* - {py:obj}`cli_schedule <archivebox.api.v1_cli.cli_schedule>`
- ```{autodoc2-docstring} archivebox.api.v1_cli.cli_schedule
:summary:
```
* - {py:obj}`cli_search <archivebox.api.v1_cli.cli_search>`
- ```{autodoc2-docstring} archivebox.api.v1_cli.cli_search
:summary:
```
* - {py:obj}`cli_remove <archivebox.api.v1_cli.cli_remove>`
- ```{autodoc2-docstring} archivebox.api.v1_cli.cli_remove
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`router <archivebox.api.v1_cli.router>`
- ```{autodoc2-docstring} archivebox.api.v1_cli.router
:summary:
```
* - {py:obj}`JSONType <archivebox.api.v1_cli.JSONType>`
- ```{autodoc2-docstring} archivebox.api.v1_cli.JSONType
:summary:
```
````
### API
````{py:data} router
:canonical: archivebox.api.v1_cli.router
:value: >
'Router(...)'
```{autodoc2-docstring} archivebox.api.v1_cli.router
```
````
````{py:data} JSONType
:canonical: archivebox.api.v1_cli.JSONType
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.JSONType
```
````
`````{py:class} CLICommandResponseSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_cli.CLICommandResponseSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} success
:canonical: archivebox.api.v1_cli.CLICommandResponseSchema.success
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.CLICommandResponseSchema.success
```
````
````{py:attribute} errors
:canonical: archivebox.api.v1_cli.CLICommandResponseSchema.errors
:type: list[str]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.CLICommandResponseSchema.errors
```
````
````{py:attribute} result
:canonical: archivebox.api.v1_cli.CLICommandResponseSchema.result
:type: archivebox.api.v1_cli.JSONType
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.CLICommandResponseSchema.result
```
````
````{py:attribute} result_format
:canonical: archivebox.api.v1_cli.CLICommandResponseSchema.result_format
:type: str
:value: >
'str'
```{autodoc2-docstring} archivebox.api.v1_cli.CLICommandResponseSchema.result_format
```
````
````{py:attribute} stdout
:canonical: archivebox.api.v1_cli.CLICommandResponseSchema.stdout
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.CLICommandResponseSchema.stdout
```
````
````{py:attribute} stderr
:canonical: archivebox.api.v1_cli.CLICommandResponseSchema.stderr
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.CLICommandResponseSchema.stderr
```
````
`````
`````{py:class} FilterTypeChoices()
:canonical: archivebox.api.v1_cli.FilterTypeChoices
Bases: {py:obj}`str`, {py:obj}`enum.Enum`
````{py:attribute} exact
:canonical: archivebox.api.v1_cli.FilterTypeChoices.exact
:value: >
'exact'
```{autodoc2-docstring} archivebox.api.v1_cli.FilterTypeChoices.exact
```
````
````{py:attribute} substring
:canonical: archivebox.api.v1_cli.FilterTypeChoices.substring
:value: >
'substring'
```{autodoc2-docstring} archivebox.api.v1_cli.FilterTypeChoices.substring
```
````
````{py:attribute} regex
:canonical: archivebox.api.v1_cli.FilterTypeChoices.regex
:value: >
'regex'
```{autodoc2-docstring} archivebox.api.v1_cli.FilterTypeChoices.regex
```
````
````{py:attribute} domain
:canonical: archivebox.api.v1_cli.FilterTypeChoices.domain
:value: >
'domain'
```{autodoc2-docstring} archivebox.api.v1_cli.FilterTypeChoices.domain
```
````
````{py:attribute} tag
:canonical: archivebox.api.v1_cli.FilterTypeChoices.tag
:value: >
'tag'
```{autodoc2-docstring} archivebox.api.v1_cli.FilterTypeChoices.tag
```
````
````{py:attribute} timestamp
:canonical: archivebox.api.v1_cli.FilterTypeChoices.timestamp
:value: >
'timestamp'
```{autodoc2-docstring} archivebox.api.v1_cli.FilterTypeChoices.timestamp
```
````
`````
`````{py:class} StatusChoices()
:canonical: archivebox.api.v1_cli.StatusChoices
Bases: {py:obj}`str`, {py:obj}`enum.Enum`
````{py:attribute} indexed
:canonical: archivebox.api.v1_cli.StatusChoices.indexed
:value: >
'indexed'
```{autodoc2-docstring} archivebox.api.v1_cli.StatusChoices.indexed
```
````
````{py:attribute} archived
:canonical: archivebox.api.v1_cli.StatusChoices.archived
:value: >
'archived'
```{autodoc2-docstring} archivebox.api.v1_cli.StatusChoices.archived
```
````
````{py:attribute} unarchived
:canonical: archivebox.api.v1_cli.StatusChoices.unarchived
:value: >
'unarchived'
```{autodoc2-docstring} archivebox.api.v1_cli.StatusChoices.unarchived
```
````
````{py:attribute} present
:canonical: archivebox.api.v1_cli.StatusChoices.present
:value: >
'present'
```{autodoc2-docstring} archivebox.api.v1_cli.StatusChoices.present
```
````
````{py:attribute} valid
:canonical: archivebox.api.v1_cli.StatusChoices.valid
:value: >
'valid'
```{autodoc2-docstring} archivebox.api.v1_cli.StatusChoices.valid
```
````
````{py:attribute} invalid
:canonical: archivebox.api.v1_cli.StatusChoices.invalid
:value: >
'invalid'
```{autodoc2-docstring} archivebox.api.v1_cli.StatusChoices.invalid
```
````
````{py:attribute} duplicate
:canonical: archivebox.api.v1_cli.StatusChoices.duplicate
:value: >
'duplicate'
```{autodoc2-docstring} archivebox.api.v1_cli.StatusChoices.duplicate
```
````
````{py:attribute} orphaned
:canonical: archivebox.api.v1_cli.StatusChoices.orphaned
:value: >
'orphaned'
```{autodoc2-docstring} archivebox.api.v1_cli.StatusChoices.orphaned
```
````
````{py:attribute} corrupted
:canonical: archivebox.api.v1_cli.StatusChoices.corrupted
:value: >
'corrupted'
```{autodoc2-docstring} archivebox.api.v1_cli.StatusChoices.corrupted
```
````
````{py:attribute} unrecognized
:canonical: archivebox.api.v1_cli.StatusChoices.unrecognized
:value: >
'unrecognized'
```{autodoc2-docstring} archivebox.api.v1_cli.StatusChoices.unrecognized
```
````
`````
`````{py:class} AddCommandSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_cli.AddCommandSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} urls
:canonical: archivebox.api.v1_cli.AddCommandSchema.urls
:type: list[str]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.AddCommandSchema.urls
```
````
````{py:attribute} snapshot_ids
:canonical: archivebox.api.v1_cli.AddCommandSchema.snapshot_ids
:type: list[str] | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.AddCommandSchema.snapshot_ids
```
````
````{py:attribute} tag
:canonical: archivebox.api.v1_cli.AddCommandSchema.tag
:type: str
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.api.v1_cli.AddCommandSchema.tag
```
````
````{py:attribute} depth
:canonical: archivebox.api.v1_cli.AddCommandSchema.depth
:type: int
:value: >
0
```{autodoc2-docstring} archivebox.api.v1_cli.AddCommandSchema.depth
```
````
````{py:attribute} max_urls
:canonical: archivebox.api.v1_cli.AddCommandSchema.max_urls
:type: int
:value: >
0
```{autodoc2-docstring} archivebox.api.v1_cli.AddCommandSchema.max_urls
```
````
````{py:attribute} crawl_max_size
:canonical: archivebox.api.v1_cli.AddCommandSchema.crawl_max_size
:type: int
:value: >
0
```{autodoc2-docstring} archivebox.api.v1_cli.AddCommandSchema.crawl_max_size
```
````
````{py:attribute} crawl_timeout
:canonical: archivebox.api.v1_cli.AddCommandSchema.crawl_timeout
:type: int
:value: >
0
```{autodoc2-docstring} archivebox.api.v1_cli.AddCommandSchema.crawl_timeout
```
````
````{py:attribute} snapshot_max_size
:canonical: archivebox.api.v1_cli.AddCommandSchema.snapshot_max_size
:type: int
:value: >
0
```{autodoc2-docstring} archivebox.api.v1_cli.AddCommandSchema.snapshot_max_size
```
````
````{py:attribute} parser
:canonical: archivebox.api.v1_cli.AddCommandSchema.parser
:type: str
:value: >
'auto'
```{autodoc2-docstring} archivebox.api.v1_cli.AddCommandSchema.parser
```
````
````{py:attribute} plugins
:canonical: archivebox.api.v1_cli.AddCommandSchema.plugins
:type: str
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.api.v1_cli.AddCommandSchema.plugins
```
````
````{py:attribute} only_new
:canonical: archivebox.api.v1_cli.AddCommandSchema.only_new
:type: bool | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.AddCommandSchema.only_new
```
````
````{py:attribute} index_only
:canonical: archivebox.api.v1_cli.AddCommandSchema.index_only
:type: bool
:value: >
False
```{autodoc2-docstring} archivebox.api.v1_cli.AddCommandSchema.index_only
```
````
`````
`````{py:class} UpdateCommandSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_cli.UpdateCommandSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} resume
:canonical: archivebox.api.v1_cli.UpdateCommandSchema.resume
:type: str | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.UpdateCommandSchema.resume
```
````
````{py:attribute} after
:canonical: archivebox.api.v1_cli.UpdateCommandSchema.after
:type: float | None
:value: >
0
```{autodoc2-docstring} archivebox.api.v1_cli.UpdateCommandSchema.after
```
````
````{py:attribute} before
:canonical: archivebox.api.v1_cli.UpdateCommandSchema.before
:type: float | None
:value: >
999999999999999
```{autodoc2-docstring} archivebox.api.v1_cli.UpdateCommandSchema.before
```
````
````{py:attribute} filter_type
:canonical: archivebox.api.v1_cli.UpdateCommandSchema.filter_type
:type: str | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.UpdateCommandSchema.filter_type
```
````
````{py:attribute} filter_patterns
:canonical: archivebox.api.v1_cli.UpdateCommandSchema.filter_patterns
:type: list[str] | None
:value: >
['https://example.com']
```{autodoc2-docstring} archivebox.api.v1_cli.UpdateCommandSchema.filter_patterns
```
````
````{py:attribute} batch_size
:canonical: archivebox.api.v1_cli.UpdateCommandSchema.batch_size
:type: int
:value: >
100
```{autodoc2-docstring} archivebox.api.v1_cli.UpdateCommandSchema.batch_size
```
````
````{py:attribute} continuous
:canonical: archivebox.api.v1_cli.UpdateCommandSchema.continuous
:type: bool
:value: >
False
```{autodoc2-docstring} archivebox.api.v1_cli.UpdateCommandSchema.continuous
```
````
`````
`````{py:class} ScheduleCommandSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_cli.ScheduleCommandSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} import_path
:canonical: archivebox.api.v1_cli.ScheduleCommandSchema.import_path
:type: str | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.ScheduleCommandSchema.import_path
```
````
````{py:attribute} add
:canonical: archivebox.api.v1_cli.ScheduleCommandSchema.add
:type: bool
:value: >
False
```{autodoc2-docstring} archivebox.api.v1_cli.ScheduleCommandSchema.add
```
````
````{py:attribute} show
:canonical: archivebox.api.v1_cli.ScheduleCommandSchema.show
:type: bool
:value: >
False
```{autodoc2-docstring} archivebox.api.v1_cli.ScheduleCommandSchema.show
```
````
````{py:attribute} foreground
:canonical: archivebox.api.v1_cli.ScheduleCommandSchema.foreground
:type: bool
:value: >
False
```{autodoc2-docstring} archivebox.api.v1_cli.ScheduleCommandSchema.foreground
```
````
````{py:attribute} run_all
:canonical: archivebox.api.v1_cli.ScheduleCommandSchema.run_all
:type: bool
:value: >
False
```{autodoc2-docstring} archivebox.api.v1_cli.ScheduleCommandSchema.run_all
```
````
````{py:attribute} quiet
:canonical: archivebox.api.v1_cli.ScheduleCommandSchema.quiet
:type: bool
:value: >
False
```{autodoc2-docstring} archivebox.api.v1_cli.ScheduleCommandSchema.quiet
```
````
````{py:attribute} every
:canonical: archivebox.api.v1_cli.ScheduleCommandSchema.every
:type: str | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.ScheduleCommandSchema.every
```
````
````{py:attribute} tag
:canonical: archivebox.api.v1_cli.ScheduleCommandSchema.tag
:type: str
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.api.v1_cli.ScheduleCommandSchema.tag
```
````
````{py:attribute} depth
:canonical: archivebox.api.v1_cli.ScheduleCommandSchema.depth
:type: int
:value: >
0
```{autodoc2-docstring} archivebox.api.v1_cli.ScheduleCommandSchema.depth
```
````
````{py:attribute} only_new
:canonical: archivebox.api.v1_cli.ScheduleCommandSchema.only_new
:type: bool | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.ScheduleCommandSchema.only_new
```
````
````{py:attribute} clear
:canonical: archivebox.api.v1_cli.ScheduleCommandSchema.clear
:type: bool
:value: >
False
```{autodoc2-docstring} archivebox.api.v1_cli.ScheduleCommandSchema.clear
```
````
`````
`````{py:class} ListCommandSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_cli.ListCommandSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} filter_patterns
:canonical: archivebox.api.v1_cli.ListCommandSchema.filter_patterns
:type: list[str] | None
:value: >
['https://example.com']
```{autodoc2-docstring} archivebox.api.v1_cli.ListCommandSchema.filter_patterns
```
````
````{py:attribute} filter_type
:canonical: archivebox.api.v1_cli.ListCommandSchema.filter_type
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.ListCommandSchema.filter_type
```
````
````{py:attribute} status
:canonical: archivebox.api.v1_cli.ListCommandSchema.status
:type: archivebox.api.v1_cli.StatusChoices
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.ListCommandSchema.status
```
````
````{py:attribute} after
:canonical: archivebox.api.v1_cli.ListCommandSchema.after
:type: float | None
:value: >
0
```{autodoc2-docstring} archivebox.api.v1_cli.ListCommandSchema.after
```
````
````{py:attribute} before
:canonical: archivebox.api.v1_cli.ListCommandSchema.before
:type: float | None
:value: >
999999999999999
```{autodoc2-docstring} archivebox.api.v1_cli.ListCommandSchema.before
```
````
````{py:attribute} sort
:canonical: archivebox.api.v1_cli.ListCommandSchema.sort
:type: str
:value: >
'bookmarked_at'
```{autodoc2-docstring} archivebox.api.v1_cli.ListCommandSchema.sort
```
````
````{py:attribute} as_json
:canonical: archivebox.api.v1_cli.ListCommandSchema.as_json
:type: bool
:value: >
True
```{autodoc2-docstring} archivebox.api.v1_cli.ListCommandSchema.as_json
```
````
````{py:attribute} as_html
:canonical: archivebox.api.v1_cli.ListCommandSchema.as_html
:type: bool
:value: >
False
```{autodoc2-docstring} archivebox.api.v1_cli.ListCommandSchema.as_html
```
````
````{py:attribute} as_csv
:canonical: archivebox.api.v1_cli.ListCommandSchema.as_csv
:type: str | None
:value: >
'timestamp,url'
```{autodoc2-docstring} archivebox.api.v1_cli.ListCommandSchema.as_csv
```
````
````{py:attribute} with_headers
:canonical: archivebox.api.v1_cli.ListCommandSchema.with_headers
:type: bool
:value: >
False
```{autodoc2-docstring} archivebox.api.v1_cli.ListCommandSchema.with_headers
```
````
`````
`````{py:class} RemoveCommandSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_cli.RemoveCommandSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} after
:canonical: archivebox.api.v1_cli.RemoveCommandSchema.after
:type: float | None
:value: >
0
```{autodoc2-docstring} archivebox.api.v1_cli.RemoveCommandSchema.after
```
````
````{py:attribute} before
:canonical: archivebox.api.v1_cli.RemoveCommandSchema.before
:type: float | None
:value: >
999999999999999
```{autodoc2-docstring} archivebox.api.v1_cli.RemoveCommandSchema.before
```
````
````{py:attribute} filter_type
:canonical: archivebox.api.v1_cli.RemoveCommandSchema.filter_type
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_cli.RemoveCommandSchema.filter_type
```
````
````{py:attribute} filter_patterns
:canonical: archivebox.api.v1_cli.RemoveCommandSchema.filter_patterns
:type: list[str] | None
:value: >
['https://example.com']
```{autodoc2-docstring} archivebox.api.v1_cli.RemoveCommandSchema.filter_patterns
```
````
`````
````{py:function} cli_add(request: django.http.HttpRequest, args: archivebox.api.v1_cli.AddCommandSchema)
:canonical: archivebox.api.v1_cli.cli_add
```{autodoc2-docstring} archivebox.api.v1_cli.cli_add
```
````
````{py:function} cli_update(request: django.http.HttpRequest, args: archivebox.api.v1_cli.UpdateCommandSchema)
:canonical: archivebox.api.v1_cli.cli_update
```{autodoc2-docstring} archivebox.api.v1_cli.cli_update
```
````
````{py:function} cli_schedule(request: django.http.HttpRequest, args: archivebox.api.v1_cli.ScheduleCommandSchema)
:canonical: archivebox.api.v1_cli.cli_schedule
```{autodoc2-docstring} archivebox.api.v1_cli.cli_schedule
```
````
````{py:function} cli_search(request: django.http.HttpRequest, args: archivebox.api.v1_cli.ListCommandSchema)
:canonical: archivebox.api.v1_cli.cli_search
```{autodoc2-docstring} archivebox.api.v1_cli.cli_search
```
````
````{py:function} cli_remove(request: django.http.HttpRequest, args: archivebox.api.v1_cli.RemoveCommandSchema)
:canonical: archivebox.api.v1_cli.cli_remove
```{autodoc2-docstring} archivebox.api.v1_cli.cli_remove
```
````

2616
docs/apidocs/archivebox/archivebox.api.v1_core.md
View File

File diff suppressed because it is too large Load Diff

548
docs/apidocs/archivebox/archivebox.api.v1_crawls.md
View File

@ -1,548 +0,0 @@
# {py:mod}`archivebox.api.v1_crawls`
```{py:module} archivebox.api.v1_crawls
```
```{autodoc2-docstring} archivebox.api.v1_crawls
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`CrawlSchema <archivebox.api.v1_crawls.CrawlSchema>`
-
* - {py:obj}`CrawlUpdateSchema <archivebox.api.v1_crawls.CrawlUpdateSchema>`
-
* - {py:obj}`CrawlCreateSchema <archivebox.api.v1_crawls.CrawlCreateSchema>`
-
* - {py:obj}`CrawlDeleteResponseSchema <archivebox.api.v1_crawls.CrawlDeleteResponseSchema>`
-
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`normalize_tag_list <archivebox.api.v1_crawls.normalize_tag_list>`
- ```{autodoc2-docstring} archivebox.api.v1_crawls.normalize_tag_list
:summary:
```
* - {py:obj}`get_crawls <archivebox.api.v1_crawls.get_crawls>`
- ```{autodoc2-docstring} archivebox.api.v1_crawls.get_crawls
:summary:
```
* - {py:obj}`create_crawl <archivebox.api.v1_crawls.create_crawl>`
- ```{autodoc2-docstring} archivebox.api.v1_crawls.create_crawl
:summary:
```
* - {py:obj}`get_crawl <archivebox.api.v1_crawls.get_crawl>`
- ```{autodoc2-docstring} archivebox.api.v1_crawls.get_crawl
:summary:
```
* - {py:obj}`crawl_file <archivebox.api.v1_crawls.crawl_file>`
- ```{autodoc2-docstring} archivebox.api.v1_crawls.crawl_file
:summary:
```
* - {py:obj}`crawl_file_root <archivebox.api.v1_crawls.crawl_file_root>`
- ```{autodoc2-docstring} archivebox.api.v1_crawls.crawl_file_root
:summary:
```
* - {py:obj}`crawl_file_nested_1 <archivebox.api.v1_crawls.crawl_file_nested_1>`
- ```{autodoc2-docstring} archivebox.api.v1_crawls.crawl_file_nested_1
:summary:
```
* - {py:obj}`crawl_file_nested_2 <archivebox.api.v1_crawls.crawl_file_nested_2>`
- ```{autodoc2-docstring} archivebox.api.v1_crawls.crawl_file_nested_2
:summary:
```
* - {py:obj}`patch_crawl <archivebox.api.v1_crawls.patch_crawl>`
- ```{autodoc2-docstring} archivebox.api.v1_crawls.patch_crawl
:summary:
```
* - {py:obj}`delete_crawl <archivebox.api.v1_crawls.delete_crawl>`
- ```{autodoc2-docstring} archivebox.api.v1_crawls.delete_crawl
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`router <archivebox.api.v1_crawls.router>`
- ```{autodoc2-docstring} archivebox.api.v1_crawls.router
:summary:
```
````
### API
````{py:data} router
:canonical: archivebox.api.v1_crawls.router
:value: >
'Router(...)'
```{autodoc2-docstring} archivebox.api.v1_crawls.router
```
````
`````{py:class} CrawlSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_crawls.CrawlSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} TYPE
:canonical: archivebox.api.v1_crawls.CrawlSchema.TYPE
:type: str
:value: >
'crawls.models.Crawl'
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.TYPE
```
````
````{py:attribute} id
:canonical: archivebox.api.v1_crawls.CrawlSchema.id
:type: uuid.UUID
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.id
```
````
````{py:attribute} modified_at
:canonical: archivebox.api.v1_crawls.CrawlSchema.modified_at
:type: datetime.datetime
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.modified_at
```
````
````{py:attribute} created_at
:canonical: archivebox.api.v1_crawls.CrawlSchema.created_at
:type: datetime.datetime
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.created_at
```
````
````{py:attribute} created_by_id
:canonical: archivebox.api.v1_crawls.CrawlSchema.created_by_id
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.created_by_id
```
````
````{py:attribute} created_by_username
:canonical: archivebox.api.v1_crawls.CrawlSchema.created_by_username
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.created_by_username
```
````
````{py:attribute} status
:canonical: archivebox.api.v1_crawls.CrawlSchema.status
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.status
```
````
````{py:attribute} retry_at
:canonical: archivebox.api.v1_crawls.CrawlSchema.retry_at
:type: datetime.datetime | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.retry_at
```
````
````{py:attribute} is_paused
:canonical: archivebox.api.v1_crawls.CrawlSchema.is_paused
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.is_paused
```
````
````{py:attribute} urls
:canonical: archivebox.api.v1_crawls.CrawlSchema.urls
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.urls
```
````
````{py:attribute} max_depth
:canonical: archivebox.api.v1_crawls.CrawlSchema.max_depth
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.max_depth
```
````
````{py:attribute} tags_str
:canonical: archivebox.api.v1_crawls.CrawlSchema.tags_str
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.tags_str
```
````
````{py:attribute} config
:canonical: archivebox.api.v1_crawls.CrawlSchema.config
:type: dict
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.config
```
````
````{py:method} resolve_created_by_id(obj)
:canonical: archivebox.api.v1_crawls.CrawlSchema.resolve_created_by_id
:staticmethod:
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.resolve_created_by_id
```
````
````{py:method} resolve_created_by_username(obj)
:canonical: archivebox.api.v1_crawls.CrawlSchema.resolve_created_by_username
:staticmethod:
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.resolve_created_by_username
```
````
````{py:method} resolve_config(obj)
:canonical: archivebox.api.v1_crawls.CrawlSchema.resolve_config
:staticmethod:
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.resolve_config
```
````
````{py:method} resolve_snapshots(obj, context)
:canonical: archivebox.api.v1_crawls.CrawlSchema.resolve_snapshots
:staticmethod:
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlSchema.resolve_snapshots
```
````
`````
`````{py:class} CrawlUpdateSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_crawls.CrawlUpdateSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} action
:canonical: archivebox.api.v1_crawls.CrawlUpdateSchema.action
:type: str | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlUpdateSchema.action
```
````
````{py:attribute} status
:canonical: archivebox.api.v1_crawls.CrawlUpdateSchema.status
:type: str | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlUpdateSchema.status
```
````
````{py:attribute} retry_at
:canonical: archivebox.api.v1_crawls.CrawlUpdateSchema.retry_at
:type: datetime.datetime | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlUpdateSchema.retry_at
```
````
````{py:attribute} tags
:canonical: archivebox.api.v1_crawls.CrawlUpdateSchema.tags
:type: list[str] | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlUpdateSchema.tags
```
````
````{py:attribute} tags_str
:canonical: archivebox.api.v1_crawls.CrawlUpdateSchema.tags_str
:type: str | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlUpdateSchema.tags_str
```
````
`````
`````{py:class} CrawlCreateSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_crawls.CrawlCreateSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} urls
:canonical: archivebox.api.v1_crawls.CrawlCreateSchema.urls
:type: list[str]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlCreateSchema.urls
```
````
````{py:attribute} max_depth
:canonical: archivebox.api.v1_crawls.CrawlCreateSchema.max_depth
:type: int
:value: >
0
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlCreateSchema.max_depth
```
````
````{py:attribute} tags
:canonical: archivebox.api.v1_crawls.CrawlCreateSchema.tags
:type: list[str] | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlCreateSchema.tags
```
````
````{py:attribute} tags_str
:canonical: archivebox.api.v1_crawls.CrawlCreateSchema.tags_str
:type: str
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlCreateSchema.tags_str
```
````
````{py:attribute} label
:canonical: archivebox.api.v1_crawls.CrawlCreateSchema.label
:type: str
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlCreateSchema.label
```
````
````{py:attribute} notes
:canonical: archivebox.api.v1_crawls.CrawlCreateSchema.notes
:type: str
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlCreateSchema.notes
```
````
````{py:attribute} config
:canonical: archivebox.api.v1_crawls.CrawlCreateSchema.config
:type: dict
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlCreateSchema.config
```
````
`````
`````{py:class} CrawlDeleteResponseSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_crawls.CrawlDeleteResponseSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} success
:canonical: archivebox.api.v1_crawls.CrawlDeleteResponseSchema.success
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlDeleteResponseSchema.success
```
````
````{py:attribute} crawl_id
:canonical: archivebox.api.v1_crawls.CrawlDeleteResponseSchema.crawl_id
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlDeleteResponseSchema.crawl_id
```
````
````{py:attribute} deleted_count
:canonical: archivebox.api.v1_crawls.CrawlDeleteResponseSchema.deleted_count
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlDeleteResponseSchema.deleted_count
```
````
````{py:attribute} deleted_snapshots
:canonical: archivebox.api.v1_crawls.CrawlDeleteResponseSchema.deleted_snapshots
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_crawls.CrawlDeleteResponseSchema.deleted_snapshots
```
````
`````
````{py:function} normalize_tag_list(tags: list[str] | None = None, tags_str: str = '') -> list[str]
:canonical: archivebox.api.v1_crawls.normalize_tag_list
```{autodoc2-docstring} archivebox.api.v1_crawls.normalize_tag_list
```
````
````{py:function} get_crawls(request: django.http.HttpRequest)
:canonical: archivebox.api.v1_crawls.get_crawls
```{autodoc2-docstring} archivebox.api.v1_crawls.get_crawls
```
````
````{py:function} create_crawl(request: django.http.HttpRequest, data: archivebox.api.v1_crawls.CrawlCreateSchema)
:canonical: archivebox.api.v1_crawls.create_crawl
```{autodoc2-docstring} archivebox.api.v1_crawls.create_crawl
```
````
````{py:function} get_crawl(request: django.http.HttpRequest, crawl_id: str, as_rss: bool = False, with_snapshots: bool = False, with_archiveresults: bool = False)
:canonical: archivebox.api.v1_crawls.get_crawl
```{autodoc2-docstring} archivebox.api.v1_crawls.get_crawl
```
````
````{py:function} crawl_file(request: django.http.HttpRequest, crawl_id: str, path: str)
:canonical: archivebox.api.v1_crawls.crawl_file
```{autodoc2-docstring} archivebox.api.v1_crawls.crawl_file
```
````
````{py:function} crawl_file_root(request: django.http.HttpRequest, crawl_id: str, filename: str)
:canonical: archivebox.api.v1_crawls.crawl_file_root
```{autodoc2-docstring} archivebox.api.v1_crawls.crawl_file_root
```
````
````{py:function} crawl_file_nested_1(request: django.http.HttpRequest, crawl_id: str, folder: str, filename: str)
:canonical: archivebox.api.v1_crawls.crawl_file_nested_1
```{autodoc2-docstring} archivebox.api.v1_crawls.crawl_file_nested_1
```
````
````{py:function} crawl_file_nested_2(request: django.http.HttpRequest, crawl_id: str, folder: str, subfolder: str, filename: str)
:canonical: archivebox.api.v1_crawls.crawl_file_nested_2
```{autodoc2-docstring} archivebox.api.v1_crawls.crawl_file_nested_2
```
````
````{py:function} patch_crawl(request: django.http.HttpRequest, crawl_id: str, data: archivebox.api.v1_crawls.CrawlUpdateSchema)
:canonical: archivebox.api.v1_crawls.patch_crawl
```{autodoc2-docstring} archivebox.api.v1_crawls.patch_crawl
```
````
````{py:function} delete_crawl(request: django.http.HttpRequest, crawl_id: str)
:canonical: archivebox.api.v1_crawls.delete_crawl
```{autodoc2-docstring} archivebox.api.v1_crawls.delete_crawl
```
````

720
docs/apidocs/archivebox/archivebox.api.v1_machine.md
View File

@ -1,720 +0,0 @@
# {py:mod}`archivebox.api.v1_machine`
```{py:module} archivebox.api.v1_machine
```
```{autodoc2-docstring} archivebox.api.v1_machine
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`MachineSchema <archivebox.api.v1_machine.MachineSchema>`
- ```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema
:summary:
```
* - {py:obj}`MachineFilterSchema <archivebox.api.v1_machine.MachineFilterSchema>`
-
* - {py:obj}`BinarySchema <archivebox.api.v1_machine.BinarySchema>`
- ```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema
:summary:
```
* - {py:obj}`BinaryFilterSchema <archivebox.api.v1_machine.BinaryFilterSchema>`
-
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`get_machines <archivebox.api.v1_machine.get_machines>`
- ```{autodoc2-docstring} archivebox.api.v1_machine.get_machines
:summary:
```
* - {py:obj}`get_current_machine <archivebox.api.v1_machine.get_current_machine>`
- ```{autodoc2-docstring} archivebox.api.v1_machine.get_current_machine
:summary:
```
* - {py:obj}`get_machine <archivebox.api.v1_machine.get_machine>`
- ```{autodoc2-docstring} archivebox.api.v1_machine.get_machine
:summary:
```
* - {py:obj}`get_binaries <archivebox.api.v1_machine.get_binaries>`
- ```{autodoc2-docstring} archivebox.api.v1_machine.get_binaries
:summary:
```
* - {py:obj}`get_binary <archivebox.api.v1_machine.get_binary>`
- ```{autodoc2-docstring} archivebox.api.v1_machine.get_binary
:summary:
```
* - {py:obj}`get_binaries_by_name <archivebox.api.v1_machine.get_binaries_by_name>`
- ```{autodoc2-docstring} archivebox.api.v1_machine.get_binaries_by_name
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`router <archivebox.api.v1_machine.router>`
- ```{autodoc2-docstring} archivebox.api.v1_machine.router
:summary:
```
````
### API
````{py:data} router
:canonical: archivebox.api.v1_machine.router
:value: >
'Router(...)'
```{autodoc2-docstring} archivebox.api.v1_machine.router
```
````
`````{py:class} MachineSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_machine.MachineSchema
Bases: {py:obj}`ninja.Schema`
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.__init__
```
````{py:attribute} TYPE
:canonical: archivebox.api.v1_machine.MachineSchema.TYPE
:type: str
:value: >
'machine.Machine'
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.TYPE
```
````
````{py:attribute} id
:canonical: archivebox.api.v1_machine.MachineSchema.id
:type: uuid.UUID
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.id
```
````
````{py:attribute} created_at
:canonical: archivebox.api.v1_machine.MachineSchema.created_at
:type: datetime.datetime
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.created_at
```
````
````{py:attribute} modified_at
:canonical: archivebox.api.v1_machine.MachineSchema.modified_at
:type: datetime.datetime
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.modified_at
```
````
````{py:attribute} guid
:canonical: archivebox.api.v1_machine.MachineSchema.guid
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.guid
```
````
````{py:attribute} hostname
:canonical: archivebox.api.v1_machine.MachineSchema.hostname
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.hostname
```
````
````{py:attribute} hw_in_docker
:canonical: archivebox.api.v1_machine.MachineSchema.hw_in_docker
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.hw_in_docker
```
````
````{py:attribute} hw_in_vm
:canonical: archivebox.api.v1_machine.MachineSchema.hw_in_vm
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.hw_in_vm
```
````
````{py:attribute} hw_manufacturer
:canonical: archivebox.api.v1_machine.MachineSchema.hw_manufacturer
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.hw_manufacturer
```
````
````{py:attribute} hw_product
:canonical: archivebox.api.v1_machine.MachineSchema.hw_product
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.hw_product
```
````
````{py:attribute} hw_uuid
:canonical: archivebox.api.v1_machine.MachineSchema.hw_uuid
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.hw_uuid
```
````
````{py:attribute} os_arch
:canonical: archivebox.api.v1_machine.MachineSchema.os_arch
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.os_arch
```
````
````{py:attribute} os_family
:canonical: archivebox.api.v1_machine.MachineSchema.os_family
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.os_family
```
````
````{py:attribute} os_platform
:canonical: archivebox.api.v1_machine.MachineSchema.os_platform
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.os_platform
```
````
````{py:attribute} os_release
:canonical: archivebox.api.v1_machine.MachineSchema.os_release
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.os_release
```
````
````{py:attribute} os_kernel
:canonical: archivebox.api.v1_machine.MachineSchema.os_kernel
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.os_kernel
```
````
````{py:attribute} stats
:canonical: archivebox.api.v1_machine.MachineSchema.stats
:type: dict
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.stats
```
````
````{py:attribute} num_uses_succeeded
:canonical: archivebox.api.v1_machine.MachineSchema.num_uses_succeeded
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.num_uses_succeeded
```
````
````{py:attribute} num_uses_failed
:canonical: archivebox.api.v1_machine.MachineSchema.num_uses_failed
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineSchema.num_uses_failed
```
````
`````
`````{py:class} MachineFilterSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_machine.MachineFilterSchema
Bases: {py:obj}`ninja.FilterSchema`
````{py:attribute} id
:canonical: archivebox.api.v1_machine.MachineFilterSchema.id
:type: typing.Annotated[str | None, FilterLookup('id__startswith')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineFilterSchema.id
```
````
````{py:attribute} hostname
:canonical: archivebox.api.v1_machine.MachineFilterSchema.hostname
:type: typing.Annotated[str | None, FilterLookup('hostname__icontains')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineFilterSchema.hostname
```
````
````{py:attribute} os_platform
:canonical: archivebox.api.v1_machine.MachineFilterSchema.os_platform
:type: typing.Annotated[str | None, FilterLookup('os_platform__icontains')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineFilterSchema.os_platform
```
````
````{py:attribute} os_arch
:canonical: archivebox.api.v1_machine.MachineFilterSchema.os_arch
:type: typing.Annotated[str | None, FilterLookup('os_arch')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineFilterSchema.os_arch
```
````
````{py:attribute} hw_in_docker
:canonical: archivebox.api.v1_machine.MachineFilterSchema.hw_in_docker
:type: typing.Annotated[bool | None, FilterLookup('hw_in_docker')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineFilterSchema.hw_in_docker
```
````
````{py:attribute} hw_in_vm
:canonical: archivebox.api.v1_machine.MachineFilterSchema.hw_in_vm
:type: typing.Annotated[bool | None, FilterLookup('hw_in_vm')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineFilterSchema.hw_in_vm
```
````
````{py:attribute} bin_providers
:canonical: archivebox.api.v1_machine.MachineFilterSchema.bin_providers
:type: typing.Annotated[str | None, FilterLookup('bin_providers__icontains')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.MachineFilterSchema.bin_providers
```
````
`````
`````{py:class} BinarySchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_machine.BinarySchema
Bases: {py:obj}`ninja.Schema`
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.__init__
```
````{py:attribute} TYPE
:canonical: archivebox.api.v1_machine.BinarySchema.TYPE
:type: str
:value: >
'machine.Binary'
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.TYPE
```
````
````{py:attribute} id
:canonical: archivebox.api.v1_machine.BinarySchema.id
:type: uuid.UUID
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.id
```
````
````{py:attribute} created_at
:canonical: archivebox.api.v1_machine.BinarySchema.created_at
:type: datetime.datetime
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.created_at
```
````
````{py:attribute} modified_at
:canonical: archivebox.api.v1_machine.BinarySchema.modified_at
:type: datetime.datetime
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.modified_at
```
````
````{py:attribute} machine_id
:canonical: archivebox.api.v1_machine.BinarySchema.machine_id
:type: uuid.UUID
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.machine_id
```
````
````{py:attribute} machine_hostname
:canonical: archivebox.api.v1_machine.BinarySchema.machine_hostname
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.machine_hostname
```
````
````{py:attribute} name
:canonical: archivebox.api.v1_machine.BinarySchema.name
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.name
```
````
````{py:attribute} binproviders
:canonical: archivebox.api.v1_machine.BinarySchema.binproviders
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.binproviders
```
````
````{py:attribute} binprovider
:canonical: archivebox.api.v1_machine.BinarySchema.binprovider
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.binprovider
```
````
````{py:attribute} abspath
:canonical: archivebox.api.v1_machine.BinarySchema.abspath
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.abspath
```
````
````{py:attribute} version
:canonical: archivebox.api.v1_machine.BinarySchema.version
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.version
```
````
````{py:attribute} sha256
:canonical: archivebox.api.v1_machine.BinarySchema.sha256
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.sha256
```
````
````{py:attribute} status
:canonical: archivebox.api.v1_machine.BinarySchema.status
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.status
```
````
````{py:attribute} is_valid
:canonical: archivebox.api.v1_machine.BinarySchema.is_valid
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.is_valid
```
````
````{py:attribute} num_uses_succeeded
:canonical: archivebox.api.v1_machine.BinarySchema.num_uses_succeeded
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.num_uses_succeeded
```
````
````{py:attribute} num_uses_failed
:canonical: archivebox.api.v1_machine.BinarySchema.num_uses_failed
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.num_uses_failed
```
````
````{py:method} resolve_machine_hostname(obj) -> str
:canonical: archivebox.api.v1_machine.BinarySchema.resolve_machine_hostname
:staticmethod:
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.resolve_machine_hostname
```
````
````{py:method} resolve_is_valid(obj) -> bool
:canonical: archivebox.api.v1_machine.BinarySchema.resolve_is_valid
:staticmethod:
```{autodoc2-docstring} archivebox.api.v1_machine.BinarySchema.resolve_is_valid
```
````
`````
`````{py:class} BinaryFilterSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_machine.BinaryFilterSchema
Bases: {py:obj}`ninja.FilterSchema`
````{py:attribute} id
:canonical: archivebox.api.v1_machine.BinaryFilterSchema.id
:type: typing.Annotated[str | None, FilterLookup('id__startswith')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinaryFilterSchema.id
```
````
````{py:attribute} name
:canonical: archivebox.api.v1_machine.BinaryFilterSchema.name
:type: typing.Annotated[str | None, FilterLookup('name__icontains')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinaryFilterSchema.name
```
````
````{py:attribute} binprovider
:canonical: archivebox.api.v1_machine.BinaryFilterSchema.binprovider
:type: typing.Annotated[str | None, FilterLookup('binprovider')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinaryFilterSchema.binprovider
```
````
````{py:attribute} status
:canonical: archivebox.api.v1_machine.BinaryFilterSchema.status
:type: typing.Annotated[str | None, FilterLookup('status')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinaryFilterSchema.status
```
````
````{py:attribute} machine_id
:canonical: archivebox.api.v1_machine.BinaryFilterSchema.machine_id
:type: typing.Annotated[str | None, FilterLookup('machine_id__startswith')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinaryFilterSchema.machine_id
```
````
````{py:attribute} version
:canonical: archivebox.api.v1_machine.BinaryFilterSchema.version
:type: typing.Annotated[str | None, FilterLookup('version__icontains')]
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_machine.BinaryFilterSchema.version
```
````
`````
````{py:function} get_machines(request: django.http.HttpRequest, filters: ninja.Query[archivebox.api.v1_machine.MachineFilterSchema])
:canonical: archivebox.api.v1_machine.get_machines
```{autodoc2-docstring} archivebox.api.v1_machine.get_machines
```
````
````{py:function} get_current_machine(request: django.http.HttpRequest)
:canonical: archivebox.api.v1_machine.get_current_machine
```{autodoc2-docstring} archivebox.api.v1_machine.get_current_machine
```
````
````{py:function} get_machine(request: django.http.HttpRequest, machine_id: str)
:canonical: archivebox.api.v1_machine.get_machine
```{autodoc2-docstring} archivebox.api.v1_machine.get_machine
```
````
````{py:function} get_binaries(request: django.http.HttpRequest, filters: ninja.Query[archivebox.api.v1_machine.BinaryFilterSchema])
:canonical: archivebox.api.v1_machine.get_binaries
```{autodoc2-docstring} archivebox.api.v1_machine.get_binaries
```
````
````{py:function} get_binary(request: django.http.HttpRequest, binary_id: str)
:canonical: archivebox.api.v1_machine.get_binary
```{autodoc2-docstring} archivebox.api.v1_machine.get_binary
```
````
````{py:function} get_binaries_by_name(request: django.http.HttpRequest, name: str)
:canonical: archivebox.api.v1_machine.get_binaries_by_name
```{autodoc2-docstring} archivebox.api.v1_machine.get_binaries_by_name
```
````

405
docs/apidocs/archivebox/archivebox.api.v1_personas.md
View File

@ -1,405 +0,0 @@
# {py:mod}`archivebox.api.v1_personas`
```{py:module} archivebox.api.v1_personas
```
```{autodoc2-docstring} archivebox.api.v1_personas
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`PersonaBrowserSettingsSchema <archivebox.api.v1_personas.PersonaBrowserSettingsSchema>`
-
* - {py:obj}`PersonaSyncSchema <archivebox.api.v1_personas.PersonaSyncSchema>`
-
* - {py:obj}`PersonaSchema <archivebox.api.v1_personas.PersonaSchema>`
-
* - {py:obj}`PersonaSyncResponseSchema <archivebox.api.v1_personas.PersonaSyncResponseSchema>`
-
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`browser_settings_to_config <archivebox.api.v1_personas.browser_settings_to_config>`
- ```{autodoc2-docstring} archivebox.api.v1_personas.browser_settings_to_config
:summary:
```
* - {py:obj}`find_persona <archivebox.api.v1_personas.find_persona>`
- ```{autodoc2-docstring} archivebox.api.v1_personas.find_persona
:summary:
```
* - {py:obj}`get_personas <archivebox.api.v1_personas.get_personas>`
- ```{autodoc2-docstring} archivebox.api.v1_personas.get_personas
:summary:
```
* - {py:obj}`sync_persona <archivebox.api.v1_personas.sync_persona>`
- ```{autodoc2-docstring} archivebox.api.v1_personas.sync_persona
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`router <archivebox.api.v1_personas.router>`
- ```{autodoc2-docstring} archivebox.api.v1_personas.router
:summary:
```
````
### API
````{py:data} router
:canonical: archivebox.api.v1_personas.router
:value: >
'Router(...)'
```{autodoc2-docstring} archivebox.api.v1_personas.router
```
````
`````{py:class} PersonaBrowserSettingsSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_personas.PersonaBrowserSettingsSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} user_agent
:canonical: archivebox.api.v1_personas.PersonaBrowserSettingsSchema.user_agent
:type: str
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaBrowserSettingsSchema.user_agent
```
````
````{py:attribute} viewport_size
:canonical: archivebox.api.v1_personas.PersonaBrowserSettingsSchema.viewport_size
:type: str
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaBrowserSettingsSchema.viewport_size
```
````
````{py:attribute} viewport_device_scale_factor
:canonical: archivebox.api.v1_personas.PersonaBrowserSettingsSchema.viewport_device_scale_factor
:type: float | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaBrowserSettingsSchema.viewport_device_scale_factor
```
````
````{py:attribute} language
:canonical: archivebox.api.v1_personas.PersonaBrowserSettingsSchema.language
:type: str
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaBrowserSettingsSchema.language
```
````
````{py:attribute} timezone
:canonical: archivebox.api.v1_personas.PersonaBrowserSettingsSchema.timezone
:type: str
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaBrowserSettingsSchema.timezone
```
````
````{py:attribute} geolocation
:canonical: archivebox.api.v1_personas.PersonaBrowserSettingsSchema.geolocation
:type: dict[str, typing.Any] | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaBrowserSettingsSchema.geolocation
```
````
`````
`````{py:class} PersonaSyncSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_personas.PersonaSyncSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} extension_persona_id
:canonical: archivebox.api.v1_personas.PersonaSyncSchema.extension_persona_id
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSyncSchema.extension_persona_id
```
````
````{py:attribute} name
:canonical: archivebox.api.v1_personas.PersonaSyncSchema.name
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSyncSchema.name
```
````
````{py:attribute} settings
:canonical: archivebox.api.v1_personas.PersonaSyncSchema.settings
:type: archivebox.api.v1_personas.PersonaBrowserSettingsSchema
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSyncSchema.settings
```
````
````{py:attribute} cookies_txt
:canonical: archivebox.api.v1_personas.PersonaSyncSchema.cookies_txt
:type: str
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSyncSchema.cookies_txt
```
````
````{py:attribute} auth_json
:canonical: archivebox.api.v1_personas.PersonaSyncSchema.auth_json
:type: dict[str, typing.Any]
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSyncSchema.auth_json
```
````
`````
`````{py:class} PersonaSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_personas.PersonaSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} TYPE
:canonical: archivebox.api.v1_personas.PersonaSchema.TYPE
:type: str
:value: >
'personas.models.Persona'
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSchema.TYPE
```
````
````{py:attribute} id
:canonical: archivebox.api.v1_personas.PersonaSchema.id
:type: uuid.UUID
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSchema.id
```
````
````{py:attribute} name
:canonical: archivebox.api.v1_personas.PersonaSchema.name
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSchema.name
```
````
````{py:attribute} created_at
:canonical: archivebox.api.v1_personas.PersonaSchema.created_at
:type: datetime.datetime
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSchema.created_at
```
````
````{py:attribute} created_by_id
:canonical: archivebox.api.v1_personas.PersonaSchema.created_by_id
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSchema.created_by_id
```
````
````{py:attribute} created_by_username
:canonical: archivebox.api.v1_personas.PersonaSchema.created_by_username
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSchema.created_by_username
```
````
````{py:attribute} config
:canonical: archivebox.api.v1_personas.PersonaSchema.config
:type: dict[str, typing.Any] | None
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSchema.config
```
````
````{py:method} resolve_created_by_id(obj)
:canonical: archivebox.api.v1_personas.PersonaSchema.resolve_created_by_id
:staticmethod:
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSchema.resolve_created_by_id
```
````
````{py:method} resolve_created_by_username(obj) -> str
:canonical: archivebox.api.v1_personas.PersonaSchema.resolve_created_by_username
:staticmethod:
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSchema.resolve_created_by_username
```
````
````{py:method} resolve_config(obj)
:canonical: archivebox.api.v1_personas.PersonaSchema.resolve_config
:staticmethod:
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSchema.resolve_config
```
````
`````
`````{py:class} PersonaSyncResponseSchema(/, **data: typing.Any)
:canonical: archivebox.api.v1_personas.PersonaSyncResponseSchema
Bases: {py:obj}`ninja.Schema`
````{py:attribute} success
:canonical: archivebox.api.v1_personas.PersonaSyncResponseSchema.success
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSyncResponseSchema.success
```
````
````{py:attribute} created
:canonical: archivebox.api.v1_personas.PersonaSyncResponseSchema.created
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSyncResponseSchema.created
```
````
````{py:attribute} persona
:canonical: archivebox.api.v1_personas.PersonaSyncResponseSchema.persona
:type: archivebox.api.v1_personas.PersonaSchema
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSyncResponseSchema.persona
```
````
````{py:attribute} cookies_file_written
:canonical: archivebox.api.v1_personas.PersonaSyncResponseSchema.cookies_file_written
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSyncResponseSchema.cookies_file_written
```
````
````{py:attribute} auth_file_written
:canonical: archivebox.api.v1_personas.PersonaSyncResponseSchema.auth_file_written
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.api.v1_personas.PersonaSyncResponseSchema.auth_file_written
```
````
`````
````{py:function} browser_settings_to_config(extension_persona_id: str, settings: archivebox.api.v1_personas.PersonaBrowserSettingsSchema) -> dict[str, typing.Any]
:canonical: archivebox.api.v1_personas.browser_settings_to_config
```{autodoc2-docstring} archivebox.api.v1_personas.browser_settings_to_config
```
````
````{py:function} find_persona(extension_persona_id: str, name: str) -> archivebox.personas.models.Persona | None
:canonical: archivebox.api.v1_personas.find_persona
```{autodoc2-docstring} archivebox.api.v1_personas.find_persona
```
````
````{py:function} get_personas(request: django.http.HttpRequest)
:canonical: archivebox.api.v1_personas.get_personas
```{autodoc2-docstring} archivebox.api.v1_personas.get_personas
```
````
````{py:function} sync_persona(request: django.http.HttpRequest, payload: archivebox.api.v1_personas.PersonaSyncSchema)
:canonical: archivebox.api.v1_personas.sync_persona
```{autodoc2-docstring} archivebox.api.v1_personas.sync_persona
```
````

64
docs/apidocs/archivebox/archivebox.api.webhooks.md
View File

@ -1,64 +0,0 @@
# {py:mod}`archivebox.api.webhooks`
```{py:module} archivebox.api.webhooks
```
```{autodoc2-docstring} archivebox.api.webhooks
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`warning_error_handler <archivebox.api.webhooks.warning_error_handler>`
- ```{autodoc2-docstring} archivebox.api.webhooks.warning_error_handler
:summary:
```
* - {py:obj}`transaction_on_commit_task_handler <archivebox.api.webhooks.transaction_on_commit_task_handler>`
- ```{autodoc2-docstring} archivebox.api.webhooks.transaction_on_commit_task_handler
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`logger <archivebox.api.webhooks.logger>`
- ```{autodoc2-docstring} archivebox.api.webhooks.logger
:summary:
```
````
### API
````{py:data} logger
:canonical: archivebox.api.webhooks.logger
:value: >
'getLogger(...)'
```{autodoc2-docstring} archivebox.api.webhooks.logger
```
````
````{py:function} warning_error_handler(hook: typing.Any, error: Exception | None) -> None
:canonical: archivebox.api.webhooks.warning_error_handler
```{autodoc2-docstring} archivebox.api.webhooks.warning_error_handler
```
````
````{py:function} transaction_on_commit_task_handler(hook: collections.abc.Callable[..., None], **kwargs: typing.Any) -> None
:canonical: archivebox.api.webhooks.transaction_on_commit_task_handler
```{autodoc2-docstring} archivebox.api.webhooks.transaction_on_commit_task_handler
```
````

350
docs/apidocs/archivebox/archivebox.base_models.admin.md
View File

@ -1,350 +0,0 @@
# {py:mod}`archivebox.base_models.admin`
```{py:module} archivebox.base_models.admin
```
```{autodoc2-docstring} archivebox.base_models.admin
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`HexUUIDConverter <archivebox.base_models.admin.HexUUIDConverter>`
- ```{autodoc2-docstring} archivebox.base_models.admin.HexUUIDConverter
:summary:
```
* - {py:obj}`ConfigOption <archivebox.base_models.admin.ConfigOption>`
-
* - {py:obj}`KeyValueWidget <archivebox.base_models.admin.KeyValueWidget>`
- ```{autodoc2-docstring} archivebox.base_models.admin.KeyValueWidget
:summary:
```
* - {py:obj}`ConfigEditorMixin <archivebox.base_models.admin.ConfigEditorMixin>`
- ```{autodoc2-docstring} archivebox.base_models.admin.ConfigEditorMixin
:summary:
```
* - {py:obj}`BaseModelAdmin <archivebox.base_models.admin.BaseModelAdmin>`
-
````
### API
`````{py:class} HexUUIDConverter
:canonical: archivebox.base_models.admin.HexUUIDConverter
```{autodoc2-docstring} archivebox.base_models.admin.HexUUIDConverter
```
````{py:attribute} regex
:canonical: archivebox.base_models.admin.HexUUIDConverter.regex
:value: >
'[0-9a-fA-F]{32}|[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}'
```{autodoc2-docstring} archivebox.base_models.admin.HexUUIDConverter.regex
```
````
````{py:method} to_python(value: str) -> str
:canonical: archivebox.base_models.admin.HexUUIDConverter.to_python
```{autodoc2-docstring} archivebox.base_models.admin.HexUUIDConverter.to_python
```
````
````{py:method} to_url(value) -> str
:canonical: archivebox.base_models.admin.HexUUIDConverter.to_url
```{autodoc2-docstring} archivebox.base_models.admin.HexUUIDConverter.to_url
```
````
`````
`````{py:class} ConfigOption()
:canonical: archivebox.base_models.admin.ConfigOption
Bases: {py:obj}`typing.TypedDict`
````{py:attribute} plugin
:canonical: archivebox.base_models.admin.ConfigOption.plugin
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.base_models.admin.ConfigOption.plugin
```
````
````{py:attribute} type
:canonical: archivebox.base_models.admin.ConfigOption.type
:type: str | list[str]
:value: >
None
```{autodoc2-docstring} archivebox.base_models.admin.ConfigOption.type
```
````
````{py:attribute} default
:canonical: archivebox.base_models.admin.ConfigOption.default
:type: object
:value: >
None
```{autodoc2-docstring} archivebox.base_models.admin.ConfigOption.default
```
````
````{py:attribute} description
:canonical: archivebox.base_models.admin.ConfigOption.description
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.base_models.admin.ConfigOption.description
```
````
````{py:attribute} enum
:canonical: archivebox.base_models.admin.ConfigOption.enum
:type: typing.NotRequired[list[object]]
:value: >
None
```{autodoc2-docstring} archivebox.base_models.admin.ConfigOption.enum
```
````
````{py:attribute} pattern
:canonical: archivebox.base_models.admin.ConfigOption.pattern
:type: typing.NotRequired[str]
:value: >
None
```{autodoc2-docstring} archivebox.base_models.admin.ConfigOption.pattern
```
````
````{py:attribute} minimum
:canonical: archivebox.base_models.admin.ConfigOption.minimum
:type: typing.NotRequired[int | float]
:value: >
None
```{autodoc2-docstring} archivebox.base_models.admin.ConfigOption.minimum
```
````
````{py:attribute} maximum
:canonical: archivebox.base_models.admin.ConfigOption.maximum
:type: typing.NotRequired[int | float]
:value: >
None
```{autodoc2-docstring} archivebox.base_models.admin.ConfigOption.maximum
```
````
`````
``````{py:class} KeyValueWidget(attrs=None)
:canonical: archivebox.base_models.admin.KeyValueWidget
Bases: {py:obj}`django.forms.Widget`
```{autodoc2-docstring} archivebox.base_models.admin.KeyValueWidget
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.base_models.admin.KeyValueWidget.__init__
```
````{py:attribute} template_name
:canonical: archivebox.base_models.admin.KeyValueWidget.template_name
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.base_models.admin.KeyValueWidget.template_name
```
````
`````{py:class} Media
:canonical: archivebox.base_models.admin.KeyValueWidget.Media
```{autodoc2-docstring} archivebox.base_models.admin.KeyValueWidget.Media
```
````{py:attribute} css
:canonical: archivebox.base_models.admin.KeyValueWidget.Media.css
:value: >
None
```{autodoc2-docstring} archivebox.base_models.admin.KeyValueWidget.Media.css
```
````
````{py:attribute} js
:canonical: archivebox.base_models.admin.KeyValueWidget.Media.js
:value: >
[]
```{autodoc2-docstring} archivebox.base_models.admin.KeyValueWidget.Media.js
```
````
`````
````{py:method} _get_config_options() -> dict[str, archivebox.base_models.admin.ConfigOption]
:canonical: archivebox.base_models.admin.KeyValueWidget._get_config_options
```{autodoc2-docstring} archivebox.base_models.admin.KeyValueWidget._get_config_options
```
````
````{py:method} _parse_value(value: object) -> dict[str, object]
:canonical: archivebox.base_models.admin.KeyValueWidget._parse_value
```{autodoc2-docstring} archivebox.base_models.admin.KeyValueWidget._parse_value
```
````
````{py:method} render(name: str, value: object, attrs: collections.abc.Mapping[str, str] | None = None, renderer: django.forms.renderers.BaseRenderer | None = None) -> django.utils.safestring.SafeString
:canonical: archivebox.base_models.admin.KeyValueWidget.render
````
````{py:method} _render_row(widget_id: str, key: str, value: str) -> str
:canonical: archivebox.base_models.admin.KeyValueWidget._render_row
```{autodoc2-docstring} archivebox.base_models.admin.KeyValueWidget._render_row
```
````
````{py:method} _escape(s: object) -> str
:canonical: archivebox.base_models.admin.KeyValueWidget._escape
```{autodoc2-docstring} archivebox.base_models.admin.KeyValueWidget._escape
```
````
````{py:method} value_from_datadict(data: django.http.QueryDict | collections.abc.Mapping[str, object], files: object, name: str) -> str
:canonical: archivebox.base_models.admin.KeyValueWidget.value_from_datadict
````
``````
`````{py:class} ConfigEditorMixin(model, admin_site)
:canonical: archivebox.base_models.admin.ConfigEditorMixin
Bases: {py:obj}`django.contrib.admin.ModelAdmin`
```{autodoc2-docstring} archivebox.base_models.admin.ConfigEditorMixin
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.base_models.admin.ConfigEditorMixin.__init__
```
````{py:method} formfield_for_dbfield(db_field: django.db.models.Field, request: django.http.HttpRequest, **kwargs: object) -> django.forms.Field | None
:canonical: archivebox.base_models.admin.ConfigEditorMixin.formfield_for_dbfield
```{autodoc2-docstring} archivebox.base_models.admin.ConfigEditorMixin.formfield_for_dbfield
```
````
````{py:method} save_model(request: django.http.HttpRequest, obj, form, change)
:canonical: archivebox.base_models.admin.ConfigEditorMixin.save_model
```{autodoc2-docstring} archivebox.base_models.admin.ConfigEditorMixin.save_model
```
````
`````
`````{py:class} BaseModelAdmin(model, admin_site)
:canonical: archivebox.base_models.admin.BaseModelAdmin
Bases: {py:obj}`django_object_actions.DjangoObjectActions`, {py:obj}`django.contrib.admin.ModelAdmin`
````{py:attribute} list_display
:canonical: archivebox.base_models.admin.BaseModelAdmin.list_display
:value: >
('id', 'created_at', 'created_by')
```{autodoc2-docstring} archivebox.base_models.admin.BaseModelAdmin.list_display
```
````
````{py:attribute} readonly_fields
:canonical: archivebox.base_models.admin.BaseModelAdmin.readonly_fields
:value: >
('id', 'created_at', 'modified_at')
```{autodoc2-docstring} archivebox.base_models.admin.BaseModelAdmin.readonly_fields
```
````
````{py:attribute} show_search_mode_selector
:canonical: archivebox.base_models.admin.BaseModelAdmin.show_search_mode_selector
:value: >
False
```{autodoc2-docstring} archivebox.base_models.admin.BaseModelAdmin.show_search_mode_selector
```
````
````{py:method} get_default_search_mode() -> str
:canonical: archivebox.base_models.admin.BaseModelAdmin.get_default_search_mode
```{autodoc2-docstring} archivebox.base_models.admin.BaseModelAdmin.get_default_search_mode
```
````
````{py:method} get_form(request: django.http.HttpRequest, obj: django.db.models.Model | None = None, change: bool = False, **kwargs: object)
:canonical: archivebox.base_models.admin.BaseModelAdmin.get_form
````
````{py:method} get_urls()
:canonical: archivebox.base_models.admin.BaseModelAdmin.get_urls
```{autodoc2-docstring} archivebox.base_models.admin.BaseModelAdmin.get_urls
```
````
`````

8
docs/apidocs/archivebox/archivebox.base_models.apps.md
View File

@ -1,8 +0,0 @@
# {py:mod}`archivebox.base_models.apps`
```{py:module} archivebox.base_models.apps
```
```{autodoc2-docstring} archivebox.base_models.apps
:allowtitles:
```

19
docs/apidocs/archivebox/archivebox.base_models.md
View File

@ -1,19 +0,0 @@
# {py:mod}`archivebox.base_models`
```{py:module} archivebox.base_models
```
```{autodoc2-docstring} archivebox.base_models
:allowtitles:
```
## Submodules
```{toctree}
:titlesonly:
:maxdepth: 1
archivebox.base_models.models
archivebox.base_models.apps
archivebox.base_models.admin
```

529
docs/apidocs/archivebox/archivebox.base_models.models.md
View File

@ -1,529 +0,0 @@
# {py:mod}`archivebox.base_models.models`
```{py:module} archivebox.base_models.models
```
```{autodoc2-docstring} archivebox.base_models.models
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`AutoDateTimeField <archivebox.base_models.models.AutoDateTimeField>`
- ```{autodoc2-docstring} archivebox.base_models.models.AutoDateTimeField
:summary:
```
* - {py:obj}`ModelWithUUID <archivebox.base_models.models.ModelWithUUID>`
-
* - {py:obj}`ModelWithNotes <archivebox.base_models.models.ModelWithNotes>`
- ```{autodoc2-docstring} archivebox.base_models.models.ModelWithNotes
:summary:
```
* - {py:obj}`ModelWithHealthStats <archivebox.base_models.models.ModelWithHealthStats>`
- ```{autodoc2-docstring} archivebox.base_models.models.ModelWithHealthStats
:summary:
```
* - {py:obj}`ModelWithConfig <archivebox.base_models.models.ModelWithConfig>`
- ```{autodoc2-docstring} archivebox.base_models.models.ModelWithConfig
:summary:
```
* - {py:obj}`ModelWithDeleteAfter <archivebox.base_models.models.ModelWithDeleteAfter>`
-
* - {py:obj}`ModelWithOutputDir <archivebox.base_models.models.ModelWithOutputDir>`
-
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`get_or_create_system_user_pk <archivebox.base_models.models.get_or_create_system_user_pk>`
- ```{autodoc2-docstring} archivebox.base_models.models.get_or_create_system_user_pk
:summary:
```
````
### API
````{py:function} get_or_create_system_user_pk(username='system')
:canonical: archivebox.base_models.models.get_or_create_system_user_pk
```{autodoc2-docstring} archivebox.base_models.models.get_or_create_system_user_pk
```
````
`````{py:class} AutoDateTimeField(verbose_name=None, name=None, auto_now=False, auto_now_add=False, **kwargs)
:canonical: archivebox.base_models.models.AutoDateTimeField
Bases: {py:obj}`django.db.models.DateTimeField`
```{autodoc2-docstring} archivebox.base_models.models.AutoDateTimeField
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.base_models.models.AutoDateTimeField.__init__
```
````{py:method} pre_save(model_instance, add)
:canonical: archivebox.base_models.models.AutoDateTimeField.pre_save
````
`````
``````{py:class} ModelWithUUID(*args, **kwargs)
:canonical: archivebox.base_models.models.ModelWithUUID
Bases: {py:obj}`django.db.models.Model`
````{py:attribute} id
:canonical: archivebox.base_models.models.ModelWithUUID.id
:value: >
'UUIDField(...)'
```{autodoc2-docstring} archivebox.base_models.models.ModelWithUUID.id
```
````
````{py:attribute} created_at
:canonical: archivebox.base_models.models.ModelWithUUID.created_at
:value: >
'DateTimeField(...)'
```{autodoc2-docstring} archivebox.base_models.models.ModelWithUUID.created_at
```
````
````{py:attribute} modified_at
:canonical: archivebox.base_models.models.ModelWithUUID.modified_at
:value: >
'DateTimeField(...)'
```{autodoc2-docstring} archivebox.base_models.models.ModelWithUUID.modified_at
```
````
````{py:attribute} created_by
:canonical: archivebox.base_models.models.ModelWithUUID.created_by
:value: >
'ForeignKey(...)'
```{autodoc2-docstring} archivebox.base_models.models.ModelWithUUID.created_by
```
````
`````{py:class} Meta
:canonical: archivebox.base_models.models.ModelWithUUID.Meta
Bases: {py:obj}`django_stubs_ext.db.models.TypedModelMeta`
````{py:attribute} abstract
:canonical: archivebox.base_models.models.ModelWithUUID.Meta.abstract
:value: >
True
```{autodoc2-docstring} archivebox.base_models.models.ModelWithUUID.Meta.abstract
```
````
`````
````{py:method} __str__() -> str
:canonical: archivebox.base_models.models.ModelWithUUID.__str__
````
````{py:property} admin_change_url
:canonical: archivebox.base_models.models.ModelWithUUID.admin_change_url
:type: str
```{autodoc2-docstring} archivebox.base_models.models.ModelWithUUID.admin_change_url
```
````
````{py:property} api_url
:canonical: archivebox.base_models.models.ModelWithUUID.api_url
:type: str
```{autodoc2-docstring} archivebox.base_models.models.ModelWithUUID.api_url
```
````
````{py:property} api_docs_url
:canonical: archivebox.base_models.models.ModelWithUUID.api_docs_url
:type: str
```{autodoc2-docstring} archivebox.base_models.models.ModelWithUUID.api_docs_url
```
````
``````
``````{py:class} ModelWithNotes(*args, **kwargs)
:canonical: archivebox.base_models.models.ModelWithNotes
Bases: {py:obj}`django.db.models.Model`
```{autodoc2-docstring} archivebox.base_models.models.ModelWithNotes
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.base_models.models.ModelWithNotes.__init__
```
````{py:attribute} notes
:canonical: archivebox.base_models.models.ModelWithNotes.notes
:value: >
'TextField(...)'
```{autodoc2-docstring} archivebox.base_models.models.ModelWithNotes.notes
```
````
`````{py:class} Meta
:canonical: archivebox.base_models.models.ModelWithNotes.Meta
Bases: {py:obj}`django_stubs_ext.db.models.TypedModelMeta`
````{py:attribute} abstract
:canonical: archivebox.base_models.models.ModelWithNotes.Meta.abstract
:value: >
True
```{autodoc2-docstring} archivebox.base_models.models.ModelWithNotes.Meta.abstract
```
````
`````
``````
``````{py:class} ModelWithHealthStats(*args, **kwargs)
:canonical: archivebox.base_models.models.ModelWithHealthStats
Bases: {py:obj}`django.db.models.Model`
```{autodoc2-docstring} archivebox.base_models.models.ModelWithHealthStats
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.base_models.models.ModelWithHealthStats.__init__
```
````{py:attribute} num_uses_failed
:canonical: archivebox.base_models.models.ModelWithHealthStats.num_uses_failed
:value: >
'PositiveIntegerField(...)'
```{autodoc2-docstring} archivebox.base_models.models.ModelWithHealthStats.num_uses_failed
```
````
````{py:attribute} num_uses_succeeded
:canonical: archivebox.base_models.models.ModelWithHealthStats.num_uses_succeeded
:value: >
'PositiveIntegerField(...)'
```{autodoc2-docstring} archivebox.base_models.models.ModelWithHealthStats.num_uses_succeeded
```
````
`````{py:class} Meta
:canonical: archivebox.base_models.models.ModelWithHealthStats.Meta
Bases: {py:obj}`django_stubs_ext.db.models.TypedModelMeta`
````{py:attribute} abstract
:canonical: archivebox.base_models.models.ModelWithHealthStats.Meta.abstract
:value: >
True
```{autodoc2-docstring} archivebox.base_models.models.ModelWithHealthStats.Meta.abstract
```
````
`````
````{py:property} health
:canonical: archivebox.base_models.models.ModelWithHealthStats.health
:type: int
```{autodoc2-docstring} archivebox.base_models.models.ModelWithHealthStats.health
```
````
````{py:method} increment_health_stats(success: bool)
:canonical: archivebox.base_models.models.ModelWithHealthStats.increment_health_stats
```{autodoc2-docstring} archivebox.base_models.models.ModelWithHealthStats.increment_health_stats
```
````
``````
``````{py:class} ModelWithConfig(*args, **kwargs)
:canonical: archivebox.base_models.models.ModelWithConfig
Bases: {py:obj}`django.db.models.Model`
```{autodoc2-docstring} archivebox.base_models.models.ModelWithConfig
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.base_models.models.ModelWithConfig.__init__
```
````{py:attribute} config
:canonical: archivebox.base_models.models.ModelWithConfig.config
:value: >
'JSONField(...)'
```{autodoc2-docstring} archivebox.base_models.models.ModelWithConfig.config
```
````
`````{py:class} Meta
:canonical: archivebox.base_models.models.ModelWithConfig.Meta
Bases: {py:obj}`django_stubs_ext.db.models.TypedModelMeta`
````{py:attribute} abstract
:canonical: archivebox.base_models.models.ModelWithConfig.Meta.abstract
:value: >
True
```{autodoc2-docstring} archivebox.base_models.models.ModelWithConfig.Meta.abstract
```
````
`````
``````
``````{py:class} ModelWithDeleteAfter(*args, **kwargs)
:canonical: archivebox.base_models.models.ModelWithDeleteAfter
Bases: {py:obj}`django.db.models.Model`
````{py:attribute} delete_after_final_statuses
:canonical: archivebox.base_models.models.ModelWithDeleteAfter.delete_after_final_statuses
:type: tuple[str, ...]
:value: >
()
```{autodoc2-docstring} archivebox.base_models.models.ModelWithDeleteAfter.delete_after_final_statuses
```
````
````{py:attribute} delete_at
:canonical: archivebox.base_models.models.ModelWithDeleteAfter.delete_at
:value: >
'DateTimeField(...)'
```{autodoc2-docstring} archivebox.base_models.models.ModelWithDeleteAfter.delete_at
```
````
`````{py:class} Meta
:canonical: archivebox.base_models.models.ModelWithDeleteAfter.Meta
Bases: {py:obj}`django_stubs_ext.db.models.TypedModelMeta`
````{py:attribute} abstract
:canonical: archivebox.base_models.models.ModelWithDeleteAfter.Meta.abstract
:value: >
True
```{autodoc2-docstring} archivebox.base_models.models.ModelWithDeleteAfter.Meta.abstract
```
````
`````
````{py:method} save(*args, **kwargs)
:canonical: archivebox.base_models.models.ModelWithDeleteAfter.save
````
````{py:method} get_delete_after_config_value()
:canonical: archivebox.base_models.models.ModelWithDeleteAfter.get_delete_after_config_value
```{autodoc2-docstring} archivebox.base_models.models.ModelWithDeleteAfter.get_delete_after_config_value
```
````
````{py:method} set_delete_at_from_config(config_value=None) -> bool
:canonical: archivebox.base_models.models.ModelWithDeleteAfter.set_delete_at_from_config
```{autodoc2-docstring} archivebox.base_models.models.ModelWithDeleteAfter.set_delete_at_from_config
```
````
````{py:method} missing_delete_at_candidates()
:canonical: archivebox.base_models.models.ModelWithDeleteAfter.missing_delete_at_candidates
:classmethod:
```{autodoc2-docstring} archivebox.base_models.models.ModelWithDeleteAfter.missing_delete_at_candidates
```
````
````{py:method} delete_expired(*, batch_size: int = 100, backfill_missing: bool = True) -> int
:canonical: archivebox.base_models.models.ModelWithDeleteAfter.delete_expired
:classmethod:
```{autodoc2-docstring} archivebox.base_models.models.ModelWithDeleteAfter.delete_expired
```
````
``````
``````{py:class} ModelWithOutputDir(*args, **kwargs)
:canonical: archivebox.base_models.models.ModelWithOutputDir
Bases: {py:obj}`archivebox.base_models.models.ModelWithUUID`
`````{py:class} Meta
:canonical: archivebox.base_models.models.ModelWithOutputDir.Meta
Bases: {py:obj}`archivebox.base_models.models.ModelWithUUID`
````{py:attribute} abstract
:canonical: archivebox.base_models.models.ModelWithOutputDir.Meta.abstract
:value: >
True
```{autodoc2-docstring} archivebox.base_models.models.ModelWithOutputDir.Meta.abstract
```
````
`````
````{py:attribute} _delete_signal_registered
:canonical: archivebox.base_models.models.ModelWithOutputDir._delete_signal_registered
:value: >
False
```{autodoc2-docstring} archivebox.base_models.models.ModelWithOutputDir._delete_signal_registered
```
````
````{py:method} save(*args, **kwargs)
:canonical: archivebox.base_models.models.ModelWithOutputDir.save
````
````{py:property} output_dir_parent
:canonical: archivebox.base_models.models.ModelWithOutputDir.output_dir_parent
:type: str
```{autodoc2-docstring} archivebox.base_models.models.ModelWithOutputDir.output_dir_parent
```
````
````{py:property} output_dir_name
:canonical: archivebox.base_models.models.ModelWithOutputDir.output_dir_name
:type: str
```{autodoc2-docstring} archivebox.base_models.models.ModelWithOutputDir.output_dir_name
```
````
````{py:property} output_dir_str
:canonical: archivebox.base_models.models.ModelWithOutputDir.output_dir_str
:type: str
```{autodoc2-docstring} archivebox.base_models.models.ModelWithOutputDir.output_dir_str
```
````
````{py:property} output_dir
:canonical: archivebox.base_models.models.ModelWithOutputDir.output_dir
:abstractmethod:
:type: pathlib.Path
```{autodoc2-docstring} archivebox.base_models.models.ModelWithOutputDir.output_dir
```
````
````{py:method} output_paths_for_delete() -> tuple[pathlib.Path, ...]
:canonical: archivebox.base_models.models.ModelWithOutputDir.output_paths_for_delete
```{autodoc2-docstring} archivebox.base_models.models.ModelWithOutputDir.output_paths_for_delete
```
````
````{py:method} validate_output_paths_for_delete(paths) -> tuple[pathlib.Path, ...]
:canonical: archivebox.base_models.models.ModelWithOutputDir.validate_output_paths_for_delete
:classmethod:
```{autodoc2-docstring} archivebox.base_models.models.ModelWithOutputDir.validate_output_paths_for_delete
```
````
````{py:method} delete_output_paths(paths) -> None
:canonical: archivebox.base_models.models.ModelWithOutputDir.delete_output_paths
:classmethod:
```{autodoc2-docstring} archivebox.base_models.models.ModelWithOutputDir.delete_output_paths
```
````
````{py:method} register_delete_signal() -> None
:canonical: archivebox.base_models.models.ModelWithOutputDir.register_delete_signal
:classmethod:
```{autodoc2-docstring} archivebox.base_models.models.ModelWithOutputDir.register_delete_signal
```
````
``````

75
docs/apidocs/archivebox/archivebox.cli.archivebox_add.md
View File

@ -1,75 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_add`
```{py:module} archivebox.cli.archivebox_add
```
```{autodoc2-docstring} archivebox.cli.archivebox_add
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_collect_input_urls <archivebox.cli.archivebox_add._collect_input_urls>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_add._collect_input_urls
:summary:
```
* - {py:obj}`add <archivebox.cli.archivebox_add.add>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_add.add
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_add.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_add.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_add.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_add.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_add.__command__
:value: >
'archivebox add'
```{autodoc2-docstring} archivebox.cli.archivebox_add.__command__
```
````
````{py:function} _collect_input_urls(args: tuple[str, ...]) -> list[str]
:canonical: archivebox.cli.archivebox_add._collect_input_urls
```{autodoc2-docstring} archivebox.cli.archivebox_add._collect_input_urls
```
````
````{py:function} add(urls: str | list[str], snapshot_ids: list[str] | None = None, depth: int | str = 0, max_urls: int = 0, crawl_max_size: int | str = 0, crawl_timeout: int = 0, snapshot_max_size: int | str = 0, crawl_max_concurrent_snapshots: int | None = None, tag: str = '', url_allowlist: str = '', url_denylist: str = '', parser: str = 'auto', plugins: str = '', persona: str = 'Default', index_only: bool = False, bg: bool = False, created_by_id: int | None = None, config: dict[str, typing.Any] | None = None) -> tuple[archivebox.crawls.models.Crawl, django.db.models.QuerySet[archivebox.core.models.Snapshot]]
:canonical: archivebox.cli.archivebox_add.add
```{autodoc2-docstring} archivebox.cli.archivebox_add.add
```
````
````{py:function} main(**kwargs)
:canonical: archivebox.cli.archivebox_add.main
```{autodoc2-docstring} archivebox.cli.archivebox_add.main
```
````

152
docs/apidocs/archivebox/archivebox.cli.archivebox_archiveresult.md
View File

@ -1,152 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_archiveresult`
```{py:module} archivebox.cli.archivebox_archiveresult
```
```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`build_archiveresult_request <archivebox.cli.archivebox_archiveresult.build_archiveresult_request>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.build_archiveresult_request
:summary:
```
* - {py:obj}`create_archiveresults <archivebox.cli.archivebox_archiveresult.create_archiveresults>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.create_archiveresults
:summary:
```
* - {py:obj}`list_archiveresults <archivebox.cli.archivebox_archiveresult.list_archiveresults>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.list_archiveresults
:summary:
```
* - {py:obj}`update_archiveresults <archivebox.cli.archivebox_archiveresult.update_archiveresults>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.update_archiveresults
:summary:
```
* - {py:obj}`delete_archiveresults <archivebox.cli.archivebox_archiveresult.delete_archiveresults>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.delete_archiveresults
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_archiveresult.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.main
:summary:
```
* - {py:obj}`create_cmd <archivebox.cli.archivebox_archiveresult.create_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.create_cmd
:summary:
```
* - {py:obj}`list_cmd <archivebox.cli.archivebox_archiveresult.list_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.list_cmd
:summary:
```
* - {py:obj}`update_cmd <archivebox.cli.archivebox_archiveresult.update_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.update_cmd
:summary:
```
* - {py:obj}`delete_cmd <archivebox.cli.archivebox_archiveresult.delete_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.delete_cmd
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_archiveresult.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_archiveresult.__command__
:value: >
'archivebox archiveresult'
```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.__command__
```
````
````{py:function} build_archiveresult_request(snapshot_id: str, plugin: str, hook_name: str = '', status: str = 'queued') -> dict
:canonical: archivebox.cli.archivebox_archiveresult.build_archiveresult_request
```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.build_archiveresult_request
```
````
````{py:function} create_archiveresults(snapshot_id: str | None = None, plugin: str | None = None, status: str = 'queued') -> int
:canonical: archivebox.cli.archivebox_archiveresult.create_archiveresults
```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.create_archiveresults
```
````
````{py:function} list_archiveresults(status: str | None = None, plugin: str | None = None, snapshot_id: str | None = None, limit: int | None = None) -> int
:canonical: archivebox.cli.archivebox_archiveresult.list_archiveresults
```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.list_archiveresults
```
````
````{py:function} update_archiveresults(status: str | None = None) -> int
:canonical: archivebox.cli.archivebox_archiveresult.update_archiveresults
```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.update_archiveresults
```
````
````{py:function} delete_archiveresults(yes: bool = False, dry_run: bool = False) -> int
:canonical: archivebox.cli.archivebox_archiveresult.delete_archiveresults
```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.delete_archiveresults
```
````
````{py:function} main()
:canonical: archivebox.cli.archivebox_archiveresult.main
```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.main
```
````
````{py:function} create_cmd(snapshot_id: str | None, plugin: str | None, status: str)
:canonical: archivebox.cli.archivebox_archiveresult.create_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.create_cmd
```
````
````{py:function} list_cmd(status: str | None, plugin: str | None, snapshot_id: str | None, limit: int | None)
:canonical: archivebox.cli.archivebox_archiveresult.list_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.list_cmd
```
````
````{py:function} update_cmd(status: str | None)
:canonical: archivebox.cli.archivebox_archiveresult.update_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.update_cmd
```
````
````{py:function} delete_cmd(yes: bool, dry_run: bool)
:canonical: archivebox.cli.archivebox_archiveresult.delete_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_archiveresult.delete_cmd
```
````

141
docs/apidocs/archivebox/archivebox.cli.archivebox_binary.md
View File

@ -1,141 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_binary`
```{py:module} archivebox.cli.archivebox_binary
```
```{autodoc2-docstring} archivebox.cli.archivebox_binary
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`create_binary <archivebox.cli.archivebox_binary.create_binary>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_binary.create_binary
:summary:
```
* - {py:obj}`list_binaries <archivebox.cli.archivebox_binary.list_binaries>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_binary.list_binaries
:summary:
```
* - {py:obj}`update_binaries <archivebox.cli.archivebox_binary.update_binaries>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_binary.update_binaries
:summary:
```
* - {py:obj}`delete_binaries <archivebox.cli.archivebox_binary.delete_binaries>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_binary.delete_binaries
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_binary.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_binary.main
:summary:
```
* - {py:obj}`create_cmd <archivebox.cli.archivebox_binary.create_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_binary.create_cmd
:summary:
```
* - {py:obj}`list_cmd <archivebox.cli.archivebox_binary.list_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_binary.list_cmd
:summary:
```
* - {py:obj}`update_cmd <archivebox.cli.archivebox_binary.update_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_binary.update_cmd
:summary:
```
* - {py:obj}`delete_cmd <archivebox.cli.archivebox_binary.delete_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_binary.delete_cmd
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_binary.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_binary.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_binary.__command__
:value: >
'archivebox binary'
```{autodoc2-docstring} archivebox.cli.archivebox_binary.__command__
```
````
````{py:function} create_binary(name: str, abspath: str, version: str = '') -> int
:canonical: archivebox.cli.archivebox_binary.create_binary
```{autodoc2-docstring} archivebox.cli.archivebox_binary.create_binary
```
````
````{py:function} list_binaries(name: str | None = None, abspath__icontains: str | None = None, version__icontains: str | None = None, limit: int | None = None) -> int
:canonical: archivebox.cli.archivebox_binary.list_binaries
```{autodoc2-docstring} archivebox.cli.archivebox_binary.list_binaries
```
````
````{py:function} update_binaries(version: str | None = None, abspath: str | None = None) -> int
:canonical: archivebox.cli.archivebox_binary.update_binaries
```{autodoc2-docstring} archivebox.cli.archivebox_binary.update_binaries
```
````
````{py:function} delete_binaries(yes: bool = False, dry_run: bool = False) -> int
:canonical: archivebox.cli.archivebox_binary.delete_binaries
```{autodoc2-docstring} archivebox.cli.archivebox_binary.delete_binaries
```
````
````{py:function} main()
:canonical: archivebox.cli.archivebox_binary.main
```{autodoc2-docstring} archivebox.cli.archivebox_binary.main
```
````
````{py:function} create_cmd(name: str, abspath: str, version: str)
:canonical: archivebox.cli.archivebox_binary.create_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_binary.create_cmd
```
````
````{py:function} list_cmd(name: str | None, abspath__icontains: str | None, version__icontains: str | None, limit: int | None)
:canonical: archivebox.cli.archivebox_binary.list_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_binary.list_cmd
```
````
````{py:function} update_cmd(version: str | None, abspath: str | None)
:canonical: archivebox.cli.archivebox_binary.update_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_binary.update_cmd
```
````
````{py:function} delete_cmd(yes: bool, dry_run: bool)
:canonical: archivebox.cli.archivebox_binary.delete_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_binary.delete_cmd
```
````

53
docs/apidocs/archivebox/archivebox.cli.archivebox_config.md
View File

@ -1,53 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_config`
```{py:module} archivebox.cli.archivebox_config
```
```{autodoc2-docstring} archivebox.cli.archivebox_config
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_format_toml <archivebox.cli.archivebox_config._format_toml>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_config._format_toml
:summary:
```
* - {py:obj}`config <archivebox.cli.archivebox_config.config>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_config.config
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_config.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_config.main
:summary:
```
````
### API
````{py:function} _format_toml(config: dict) -> str
:canonical: archivebox.cli.archivebox_config._format_toml
```{autodoc2-docstring} archivebox.cli.archivebox_config._format_toml
```
````
````{py:function} config(*keys, get: bool = False, set: bool = False, search: bool = False, reset: bool = False, **kwargs) -> None
:canonical: archivebox.cli.archivebox_config.config
```{autodoc2-docstring} archivebox.cli.archivebox_config.config
```
````
````{py:function} main(**kwargs) -> None
:canonical: archivebox.cli.archivebox_config.main
```{autodoc2-docstring} archivebox.cli.archivebox_config.main
```
````

141
docs/apidocs/archivebox/archivebox.cli.archivebox_crawl.md
View File

@ -1,141 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_crawl`
```{py:module} archivebox.cli.archivebox_crawl
```
```{autodoc2-docstring} archivebox.cli.archivebox_crawl
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`create_crawl <archivebox.cli.archivebox_crawl.create_crawl>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_crawl.create_crawl
:summary:
```
* - {py:obj}`list_crawls <archivebox.cli.archivebox_crawl.list_crawls>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_crawl.list_crawls
:summary:
```
* - {py:obj}`update_crawls <archivebox.cli.archivebox_crawl.update_crawls>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_crawl.update_crawls
:summary:
```
* - {py:obj}`delete_crawls <archivebox.cli.archivebox_crawl.delete_crawls>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_crawl.delete_crawls
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_crawl.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_crawl.main
:summary:
```
* - {py:obj}`create_cmd <archivebox.cli.archivebox_crawl.create_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_crawl.create_cmd
:summary:
```
* - {py:obj}`list_cmd <archivebox.cli.archivebox_crawl.list_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_crawl.list_cmd
:summary:
```
* - {py:obj}`update_cmd <archivebox.cli.archivebox_crawl.update_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_crawl.update_cmd
:summary:
```
* - {py:obj}`delete_cmd <archivebox.cli.archivebox_crawl.delete_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_crawl.delete_cmd
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_crawl.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_crawl.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_crawl.__command__
:value: >
'archivebox crawl'
```{autodoc2-docstring} archivebox.cli.archivebox_crawl.__command__
```
````
````{py:function} create_crawl(urls: collections.abc.Iterable[str], depth: int = 0, tag: str = '', status: str = 'queued', created_by_id: int | None = None) -> int
:canonical: archivebox.cli.archivebox_crawl.create_crawl
```{autodoc2-docstring} archivebox.cli.archivebox_crawl.create_crawl
```
````
````{py:function} list_crawls(status: str | None = None, urls__icontains: str | None = None, max_depth: int | None = None, limit: int | None = None) -> int
:canonical: archivebox.cli.archivebox_crawl.list_crawls
```{autodoc2-docstring} archivebox.cli.archivebox_crawl.list_crawls
```
````
````{py:function} update_crawls(status: str | None = None, max_depth: int | None = None) -> int
:canonical: archivebox.cli.archivebox_crawl.update_crawls
```{autodoc2-docstring} archivebox.cli.archivebox_crawl.update_crawls
```
````
````{py:function} delete_crawls(yes: bool = False, dry_run: bool = False) -> int
:canonical: archivebox.cli.archivebox_crawl.delete_crawls
```{autodoc2-docstring} archivebox.cli.archivebox_crawl.delete_crawls
```
````
````{py:function} main()
:canonical: archivebox.cli.archivebox_crawl.main
```{autodoc2-docstring} archivebox.cli.archivebox_crawl.main
```
````
````{py:function} create_cmd(urls: tuple, depth: int, tag: str, status: str)
:canonical: archivebox.cli.archivebox_crawl.create_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_crawl.create_cmd
```
````
````{py:function} list_cmd(status: str | None, urls__icontains: str | None, max_depth: int | None, limit: int | None)
:canonical: archivebox.cli.archivebox_crawl.list_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_crawl.list_cmd
```
````
````{py:function} update_cmd(status: str | None, max_depth: int | None)
:canonical: archivebox.cli.archivebox_crawl.update_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_crawl.update_cmd
```
````
````{py:function} delete_cmd(yes: bool, dry_run: bool)
:canonical: archivebox.cli.archivebox_crawl.delete_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_crawl.delete_cmd
```
````

53
docs/apidocs/archivebox/archivebox.cli.archivebox_crawl_compat.md
View File

@ -1,53 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_crawl_compat`
```{py:module} archivebox.cli.archivebox_crawl_compat
```
```{autodoc2-docstring} archivebox.cli.archivebox_crawl_compat
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`main <archivebox.cli.archivebox_crawl_compat.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_crawl_compat.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_crawl_compat.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_crawl_compat.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_crawl_compat.__command__
:value: >
'archivebox crawl'
```{autodoc2-docstring} archivebox.cli.archivebox_crawl_compat.__command__
```
````
````{py:function} main(depth: int, tag: str, status: str, wait: bool, urls: tuple[str, ...])
:canonical: archivebox.cli.archivebox_crawl_compat.main
```{autodoc2-docstring} archivebox.cli.archivebox_crawl_compat.main
```
````

86
docs/apidocs/archivebox/archivebox.cli.archivebox_extract.md
View File

@ -1,86 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_extract`
```{py:module} archivebox.cli.archivebox_extract
```
```{autodoc2-docstring} archivebox.cli.archivebox_extract
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`process_archiveresult_by_id <archivebox.cli.archivebox_extract.process_archiveresult_by_id>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_extract.process_archiveresult_by_id
:summary:
```
* - {py:obj}`run_plugins <archivebox.cli.archivebox_extract.run_plugins>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_extract.run_plugins
:summary:
```
* - {py:obj}`is_archiveresult_id <archivebox.cli.archivebox_extract.is_archiveresult_id>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_extract.is_archiveresult_id
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_extract.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_extract.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_extract.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_extract.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_extract.__command__
:value: >
'archivebox extract'
```{autodoc2-docstring} archivebox.cli.archivebox_extract.__command__
```
````
````{py:function} process_archiveresult_by_id(archiveresult_id: str) -> int
:canonical: archivebox.cli.archivebox_extract.process_archiveresult_by_id
```{autodoc2-docstring} archivebox.cli.archivebox_extract.process_archiveresult_by_id
```
````
````{py:function} run_plugins(args: tuple, records: list[dict] | None = None, plugins: str = '', wait: bool = True, emit_results: bool = True, show_progress: bool = True) -> int
:canonical: archivebox.cli.archivebox_extract.run_plugins
```{autodoc2-docstring} archivebox.cli.archivebox_extract.run_plugins
```
````
````{py:function} is_archiveresult_id(value: str) -> bool
:canonical: archivebox.cli.archivebox_extract.is_archiveresult_id
```{autodoc2-docstring} archivebox.cli.archivebox_extract.is_archiveresult_id
```
````
````{py:function} main(plugins: str, wait: bool, args: tuple)
:canonical: archivebox.cli.archivebox_extract.main
```{autodoc2-docstring} archivebox.cli.archivebox_extract.main
```
````

75
docs/apidocs/archivebox/archivebox.cli.archivebox_help.md
View File

@ -1,75 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_help`
```{py:module} archivebox.cli.archivebox_help
```
```{autodoc2-docstring} archivebox.cli.archivebox_help
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_command_doc <archivebox.cli.archivebox_help._command_doc>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_help._command_doc
:summary:
```
* - {py:obj}`help <archivebox.cli.archivebox_help.help>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_help.help
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_help.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_help.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_help.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_help.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_help.__command__
:value: >
'archivebox help'
```{autodoc2-docstring} archivebox.cli.archivebox_help.__command__
```
````
````{py:function} _command_doc(cmd: str, import_path: str) -> str
:canonical: archivebox.cli.archivebox_help._command_doc
```{autodoc2-docstring} archivebox.cli.archivebox_help._command_doc
```
````
````{py:function} help() -> None
:canonical: archivebox.cli.archivebox_help.help
```{autodoc2-docstring} archivebox.cli.archivebox_help.help
```
````
````{py:function} main(**kwargs)
:canonical: archivebox.cli.archivebox_help.main
```{autodoc2-docstring} archivebox.cli.archivebox_help.main
```
````

53
docs/apidocs/archivebox/archivebox.cli.archivebox_init.md
View File

@ -1,53 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_init`
```{py:module} archivebox.cli.archivebox_init
```
```{autodoc2-docstring} archivebox.cli.archivebox_init
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_display_data_path <archivebox.cli.archivebox_init._display_data_path>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_init._display_data_path
:summary:
```
* - {py:obj}`init <archivebox.cli.archivebox_init.init>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_init.init
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_init.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_init.main
:summary:
```
````
### API
````{py:function} _display_data_path(path: pathlib.Path, data_dir: pathlib.Path) -> str
:canonical: archivebox.cli.archivebox_init._display_data_path
```{autodoc2-docstring} archivebox.cli.archivebox_init._display_data_path
```
````
````{py:function} init(force: bool = False, quick: bool = False, install: bool = False) -> None
:canonical: archivebox.cli.archivebox_init.init
```{autodoc2-docstring} archivebox.cli.archivebox_init.init
```
````
````{py:function} main(**kwargs) -> None
:canonical: archivebox.cli.archivebox_init.main
```{autodoc2-docstring} archivebox.cli.archivebox_init.main
```
````

42
docs/apidocs/archivebox/archivebox.cli.archivebox_install.md
View File

@ -1,42 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_install`
```{py:module} archivebox.cli.archivebox_install
```
```{autodoc2-docstring} archivebox.cli.archivebox_install
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`install <archivebox.cli.archivebox_install.install>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_install.install
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_install.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_install.main
:summary:
```
````
### API
````{py:function} install(binaries: tuple[str, ...] = (), binproviders: str = '*', dry_run: bool = False) -> None
:canonical: archivebox.cli.archivebox_install.install
```{autodoc2-docstring} archivebox.cli.archivebox_install.install
```
````
````{py:function} main(**kwargs) -> None
:canonical: archivebox.cli.archivebox_install.main
```{autodoc2-docstring} archivebox.cli.archivebox_install.main
```
````

53
docs/apidocs/archivebox/archivebox.cli.archivebox_list.md
View File

@ -1,53 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_list`
```{py:module} archivebox.cli.archivebox_list
```
```{autodoc2-docstring} archivebox.cli.archivebox_list
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`main <archivebox.cli.archivebox_list.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_list.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_list.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_list.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_list.__command__
:value: >
'archivebox list'
```{autodoc2-docstring} archivebox.cli.archivebox_list.__command__
```
````
````{py:function} main(status: str | None, url__icontains: str | None, url__istartswith: str | None, tag: str | None, crawl_id: str | None, limit: int | None, sort: str | None, csv: str | None, with_headers: bool, search: str | None, query: tuple[str, ...]) -> None
:canonical: archivebox.cli.archivebox_list.main
```{autodoc2-docstring} archivebox.cli.archivebox_list.main
```
````

75
docs/apidocs/archivebox/archivebox.cli.archivebox_machine.md
View File

@ -1,75 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_machine`
```{py:module} archivebox.cli.archivebox_machine
```
```{autodoc2-docstring} archivebox.cli.archivebox_machine
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`list_machines <archivebox.cli.archivebox_machine.list_machines>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_machine.list_machines
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_machine.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_machine.main
:summary:
```
* - {py:obj}`list_cmd <archivebox.cli.archivebox_machine.list_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_machine.list_cmd
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_machine.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_machine.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_machine.__command__
:value: >
'archivebox machine'
```{autodoc2-docstring} archivebox.cli.archivebox_machine.__command__
```
````
````{py:function} list_machines(hostname__icontains: str | None = None, os_platform: str | None = None, limit: int | None = None) -> int
:canonical: archivebox.cli.archivebox_machine.list_machines
```{autodoc2-docstring} archivebox.cli.archivebox_machine.list_machines
```
````
````{py:function} main()
:canonical: archivebox.cli.archivebox_machine.main
```{autodoc2-docstring} archivebox.cli.archivebox_machine.main
```
````
````{py:function} list_cmd(hostname__icontains: str | None, os_platform: str | None, limit: int | None)
:canonical: archivebox.cli.archivebox_machine.list_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_machine.list_cmd
```
````

42
docs/apidocs/archivebox/archivebox.cli.archivebox_manage.md
View File

@ -1,42 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_manage`
```{py:module} archivebox.cli.archivebox_manage
```
```{autodoc2-docstring} archivebox.cli.archivebox_manage
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`manage <archivebox.cli.archivebox_manage.manage>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_manage.manage
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_manage.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_manage.main
:summary:
```
````
### API
````{py:function} manage(args: list[str] | None = None) -> None
:canonical: archivebox.cli.archivebox_manage.manage
```{autodoc2-docstring} archivebox.cli.archivebox_manage.manage
```
````
````{py:function} main(args: list[str] | None = None) -> None
:canonical: archivebox.cli.archivebox_manage.main
```{autodoc2-docstring} archivebox.cli.archivebox_manage.main
```
````

64
docs/apidocs/archivebox/archivebox.cli.archivebox_mcp.md
View File

@ -1,64 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_mcp`
```{py:module} archivebox.cli.archivebox_mcp
```
```{autodoc2-docstring} archivebox.cli.archivebox_mcp
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`mcp <archivebox.cli.archivebox_mcp.mcp>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_mcp.mcp
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_mcp.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_mcp.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_mcp.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_mcp.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_mcp.__command__
:value: >
'archivebox mcp'
```{autodoc2-docstring} archivebox.cli.archivebox_mcp.__command__
```
````
````{py:function} mcp()
:canonical: archivebox.cli.archivebox_mcp.mcp
```{autodoc2-docstring} archivebox.cli.archivebox_mcp.mcp
```
````
````{py:function} main(**kwargs)
:canonical: archivebox.cli.archivebox_mcp.main
```{autodoc2-docstring} archivebox.cli.archivebox_mcp.main
```
````

235
docs/apidocs/archivebox/archivebox.cli.archivebox_persona.md
View File

@ -1,235 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_persona`
```{py:module} archivebox.cli.archivebox_persona
```
```{autodoc2-docstring} archivebox.cli.archivebox_persona
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`get_chrome_user_data_dir <archivebox.cli.archivebox_persona.get_chrome_user_data_dir>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.get_chrome_user_data_dir
:summary:
```
* - {py:obj}`get_brave_user_data_dir <archivebox.cli.archivebox_persona.get_brave_user_data_dir>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.get_brave_user_data_dir
:summary:
```
* - {py:obj}`get_edge_user_data_dir <archivebox.cli.archivebox_persona.get_edge_user_data_dir>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.get_edge_user_data_dir
:summary:
```
* - {py:obj}`get_browser_binary <archivebox.cli.archivebox_persona.get_browser_binary>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.get_browser_binary
:summary:
```
* - {py:obj}`validate_persona_name <archivebox.cli.archivebox_persona.validate_persona_name>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.validate_persona_name
:summary:
```
* - {py:obj}`ensure_path_within_personas_dir <archivebox.cli.archivebox_persona.ensure_path_within_personas_dir>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.ensure_path_within_personas_dir
:summary:
```
* - {py:obj}`create_personas <archivebox.cli.archivebox_persona.create_personas>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.create_personas
:summary:
```
* - {py:obj}`list_personas <archivebox.cli.archivebox_persona.list_personas>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.list_personas
:summary:
```
* - {py:obj}`update_personas <archivebox.cli.archivebox_persona.update_personas>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.update_personas
:summary:
```
* - {py:obj}`delete_personas <archivebox.cli.archivebox_persona.delete_personas>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.delete_personas
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_persona.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.main
:summary:
```
* - {py:obj}`create_cmd <archivebox.cli.archivebox_persona.create_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.create_cmd
:summary:
```
* - {py:obj}`list_cmd <archivebox.cli.archivebox_persona.list_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.list_cmd
:summary:
```
* - {py:obj}`update_cmd <archivebox.cli.archivebox_persona.update_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.update_cmd
:summary:
```
* - {py:obj}`delete_cmd <archivebox.cli.archivebox_persona.delete_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.delete_cmd
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_persona.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.__command__
:summary:
```
* - {py:obj}`BROWSER_PROFILE_FINDERS <archivebox.cli.archivebox_persona.BROWSER_PROFILE_FINDERS>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.BROWSER_PROFILE_FINDERS
:summary:
```
* - {py:obj}`CHROMIUM_BROWSERS <archivebox.cli.archivebox_persona.CHROMIUM_BROWSERS>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_persona.CHROMIUM_BROWSERS
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_persona.__command__
:value: >
'archivebox persona'
```{autodoc2-docstring} archivebox.cli.archivebox_persona.__command__
```
````
````{py:function} get_chrome_user_data_dir() -> pathlib.Path | None
:canonical: archivebox.cli.archivebox_persona.get_chrome_user_data_dir
```{autodoc2-docstring} archivebox.cli.archivebox_persona.get_chrome_user_data_dir
```
````
````{py:function} get_brave_user_data_dir() -> pathlib.Path | None
:canonical: archivebox.cli.archivebox_persona.get_brave_user_data_dir
```{autodoc2-docstring} archivebox.cli.archivebox_persona.get_brave_user_data_dir
```
````
````{py:function} get_edge_user_data_dir() -> pathlib.Path | None
:canonical: archivebox.cli.archivebox_persona.get_edge_user_data_dir
```{autodoc2-docstring} archivebox.cli.archivebox_persona.get_edge_user_data_dir
```
````
````{py:function} get_browser_binary(browser: str) -> str | None
:canonical: archivebox.cli.archivebox_persona.get_browser_binary
```{autodoc2-docstring} archivebox.cli.archivebox_persona.get_browser_binary
```
````
````{py:data} BROWSER_PROFILE_FINDERS
:canonical: archivebox.cli.archivebox_persona.BROWSER_PROFILE_FINDERS
:value: >
None
```{autodoc2-docstring} archivebox.cli.archivebox_persona.BROWSER_PROFILE_FINDERS
```
````
````{py:data} CHROMIUM_BROWSERS
:canonical: archivebox.cli.archivebox_persona.CHROMIUM_BROWSERS
:value: >
None
```{autodoc2-docstring} archivebox.cli.archivebox_persona.CHROMIUM_BROWSERS
```
````
````{py:function} validate_persona_name(name: str) -> tuple[bool, str]
:canonical: archivebox.cli.archivebox_persona.validate_persona_name
```{autodoc2-docstring} archivebox.cli.archivebox_persona.validate_persona_name
```
````
````{py:function} ensure_path_within_personas_dir(persona_path: pathlib.Path) -> bool
:canonical: archivebox.cli.archivebox_persona.ensure_path_within_personas_dir
```{autodoc2-docstring} archivebox.cli.archivebox_persona.ensure_path_within_personas_dir
```
````
````{py:function} create_personas(names: collections.abc.Iterable[str], import_from: str | None = None, profile: str | None = None) -> int
:canonical: archivebox.cli.archivebox_persona.create_personas
```{autodoc2-docstring} archivebox.cli.archivebox_persona.create_personas
```
````
````{py:function} list_personas(name: str | None = None, name__icontains: str | None = None, limit: int | None = None) -> int
:canonical: archivebox.cli.archivebox_persona.list_personas
```{autodoc2-docstring} archivebox.cli.archivebox_persona.list_personas
```
````
````{py:function} update_personas(name: str | None = None) -> int
:canonical: archivebox.cli.archivebox_persona.update_personas
```{autodoc2-docstring} archivebox.cli.archivebox_persona.update_personas
```
````
````{py:function} delete_personas(yes: bool = False, dry_run: bool = False) -> int
:canonical: archivebox.cli.archivebox_persona.delete_personas
```{autodoc2-docstring} archivebox.cli.archivebox_persona.delete_personas
```
````
````{py:function} main()
:canonical: archivebox.cli.archivebox_persona.main
```{autodoc2-docstring} archivebox.cli.archivebox_persona.main
```
````
````{py:function} create_cmd(names: tuple, import_from: str | None, profile: str | None)
:canonical: archivebox.cli.archivebox_persona.create_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_persona.create_cmd
```
````
````{py:function} list_cmd(name: str | None, name__icontains: str | None, limit: int | None)
:canonical: archivebox.cli.archivebox_persona.list_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_persona.list_cmd
```
````
````{py:function} update_cmd(name: str | None)
:canonical: archivebox.cli.archivebox_persona.update_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_persona.update_cmd
```
````
````{py:function} delete_cmd(yes: bool, dry_run: bool)
:canonical: archivebox.cli.archivebox_persona.delete_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_persona.delete_cmd
```
````

63
docs/apidocs/archivebox/archivebox.cli.archivebox_pluginmap.md
View File

@ -1,63 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_pluginmap`
```{py:module} archivebox.cli.archivebox_pluginmap
```
```{autodoc2-docstring} archivebox.cli.archivebox_pluginmap
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`pluginmap <archivebox.cli.archivebox_pluginmap.pluginmap>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_pluginmap.pluginmap
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_pluginmap.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_pluginmap.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`EVENT_FLOW_DIAGRAM <archivebox.cli.archivebox_pluginmap.EVENT_FLOW_DIAGRAM>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_pluginmap.EVENT_FLOW_DIAGRAM
:summary:
```
````
### API
````{py:data} EVENT_FLOW_DIAGRAM
:canonical: archivebox.cli.archivebox_pluginmap.EVENT_FLOW_DIAGRAM
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.cli.archivebox_pluginmap.EVENT_FLOW_DIAGRAM
```
````
````{py:function} pluginmap(show_disabled: bool = False, event: str | None = None, quiet: bool = False) -> dict
:canonical: archivebox.cli.archivebox_pluginmap.pluginmap
```{autodoc2-docstring} archivebox.cli.archivebox_pluginmap.pluginmap
```
````
````{py:function} main(**kwargs)
:canonical: archivebox.cli.archivebox_pluginmap.main
```{autodoc2-docstring} archivebox.cli.archivebox_pluginmap.main
```
````

75
docs/apidocs/archivebox/archivebox.cli.archivebox_process.md
View File

@ -1,75 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_process`
```{py:module} archivebox.cli.archivebox_process
```
```{autodoc2-docstring} archivebox.cli.archivebox_process
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`list_processes <archivebox.cli.archivebox_process.list_processes>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_process.list_processes
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_process.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_process.main
:summary:
```
* - {py:obj}`list_cmd <archivebox.cli.archivebox_process.list_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_process.list_cmd
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_process.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_process.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_process.__command__
:value: >
'archivebox process'
```{autodoc2-docstring} archivebox.cli.archivebox_process.__command__
```
````
````{py:function} list_processes(binary_name: str | None = None, machine_id: str | None = None, limit: int | None = None) -> int
:canonical: archivebox.cli.archivebox_process.list_processes
```{autodoc2-docstring} archivebox.cli.archivebox_process.list_processes
```
````
````{py:function} main()
:canonical: archivebox.cli.archivebox_process.main
```{autodoc2-docstring} archivebox.cli.archivebox_process.main
```
````
````{py:function} list_cmd(binary_name: str | None, machine_id: str | None, limit: int | None)
:canonical: archivebox.cli.archivebox_process.list_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_process.list_cmd
```
````

64
docs/apidocs/archivebox/archivebox.cli.archivebox_remove.md
View File

@ -1,64 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_remove`
```{py:module} archivebox.cli.archivebox_remove
```
```{autodoc2-docstring} archivebox.cli.archivebox_remove
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`remove <archivebox.cli.archivebox_remove.remove>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_remove.remove
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_remove.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_remove.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_remove.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_remove.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_remove.__command__
:value: >
'archivebox remove'
```{autodoc2-docstring} archivebox.cli.archivebox_remove.__command__
```
````
````{py:function} remove(filter_patterns: collections.abc.Iterable[str] = (), filter_type: str = 'exact', snapshots: django.db.models.QuerySet | None = None, after: float | None = None, before: float | None = None, yes: bool = False, out_dir: pathlib.Path = DATA_DIR) -> django.db.models.QuerySet
:canonical: archivebox.cli.archivebox_remove.remove
```{autodoc2-docstring} archivebox.cli.archivebox_remove.remove
```
````
````{py:function} main(**kwargs)
:canonical: archivebox.cli.archivebox_remove.main
```{autodoc2-docstring} archivebox.cli.archivebox_remove.main
```
````

86
docs/apidocs/archivebox/archivebox.cli.archivebox_run.md
View File

@ -1,86 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_run`
```{py:module} archivebox.cli.archivebox_run
```
```{autodoc2-docstring} archivebox.cli.archivebox_run
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`process_stdin_records <archivebox.cli.archivebox_run.process_stdin_records>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_run.process_stdin_records
:summary:
```
* - {py:obj}`run_runner <archivebox.cli.archivebox_run.run_runner>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_run.run_runner
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_run.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_run.main
:summary:
```
* - {py:obj}`run_snapshot_worker <archivebox.cli.archivebox_run.run_snapshot_worker>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_run.run_snapshot_worker
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_run.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_run.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_run.__command__
:value: >
'archivebox run'
```{autodoc2-docstring} archivebox.cli.archivebox_run.__command__
```
````
````{py:function} process_stdin_records() -> int
:canonical: archivebox.cli.archivebox_run.process_stdin_records
```{autodoc2-docstring} archivebox.cli.archivebox_run.process_stdin_records
```
````
````{py:function} run_runner(daemon: bool = False, crawl_id: str | None = None, maintenance_only: bool = False) -> int
:canonical: archivebox.cli.archivebox_run.run_runner
```{autodoc2-docstring} archivebox.cli.archivebox_run.run_runner
```
````
````{py:function} main(daemon: bool, crawl_id: str, snapshot_id: str, binary_id: str, maintenance_only: bool)
:canonical: archivebox.cli.archivebox_run.main
```{autodoc2-docstring} archivebox.cli.archivebox_run.main
```
````
````{py:function} run_snapshot_worker(snapshot_id: str) -> int
:canonical: archivebox.cli.archivebox_run.run_snapshot_worker
```{autodoc2-docstring} archivebox.cli.archivebox_run.run_snapshot_worker
```
````

42
docs/apidocs/archivebox/archivebox.cli.archivebox_schedule.md
View File

@ -1,42 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_schedule`
```{py:module} archivebox.cli.archivebox_schedule
```
```{autodoc2-docstring} archivebox.cli.archivebox_schedule
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`schedule <archivebox.cli.archivebox_schedule.schedule>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_schedule.schedule
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_schedule.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_schedule.main
:summary:
```
````
### API
````{py:function} schedule(add: bool = False, show: bool = False, clear: bool = False, foreground: bool = False, run_all: bool = False, quiet: bool = False, every: str | None = None, tag: str = '', depth: int | str = 0, import_path: str | None = None, config: dict[str, object] | None = None)
:canonical: archivebox.cli.archivebox_schedule.schedule
```{autodoc2-docstring} archivebox.cli.archivebox_schedule.schedule
```
````
````{py:function} main(**kwargs)
:canonical: archivebox.cli.archivebox_schedule.main
```{autodoc2-docstring} archivebox.cli.archivebox_schedule.main
```
````

148
docs/apidocs/archivebox/archivebox.cli.archivebox_search.md
View File

@ -1,148 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_search`
```{py:module} archivebox.cli.archivebox_search
```
```{autodoc2-docstring} archivebox.cli.archivebox_search
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_apply_pattern_filters <archivebox.cli.archivebox_search._apply_pattern_filters>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_search._apply_pattern_filters
:summary:
```
* - {py:obj}`_snapshots_to_json <archivebox.cli.archivebox_search._snapshots_to_json>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_search._snapshots_to_json
:summary:
```
* - {py:obj}`_snapshots_to_csv <archivebox.cli.archivebox_search._snapshots_to_csv>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_search._snapshots_to_csv
:summary:
```
* - {py:obj}`_snapshots_to_html <archivebox.cli.archivebox_search._snapshots_to_html>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_search._snapshots_to_html
:summary:
```
* - {py:obj}`get_snapshots <archivebox.cli.archivebox_search.get_snapshots>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_search.get_snapshots
:summary:
```
* - {py:obj}`search <archivebox.cli.archivebox_search.search>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_search.search
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_search.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_search.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_search.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_search.__command__
:summary:
```
* - {py:obj}`LINK_FILTERS <archivebox.cli.archivebox_search.LINK_FILTERS>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_search.LINK_FILTERS
:summary:
```
* - {py:obj}`STATUS_CHOICES <archivebox.cli.archivebox_search.STATUS_CHOICES>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_search.STATUS_CHOICES
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_search.__command__
:value: >
'archivebox search'
```{autodoc2-docstring} archivebox.cli.archivebox_search.__command__
```
````
````{py:data} LINK_FILTERS
:canonical: archivebox.cli.archivebox_search.LINK_FILTERS
:type: dict[str, collections.abc.Callable[[str], django.db.models.Q]]
:value: >
None
```{autodoc2-docstring} archivebox.cli.archivebox_search.LINK_FILTERS
```
````
````{py:data} STATUS_CHOICES
:canonical: archivebox.cli.archivebox_search.STATUS_CHOICES
:value: >
['indexed', 'archived', 'unarchived']
```{autodoc2-docstring} archivebox.cli.archivebox_search.STATUS_CHOICES
```
````
````{py:function} _apply_pattern_filters(snapshots: django.db.models.QuerySet[archivebox.core.models.Snapshot, archivebox.core.models.Snapshot], filter_patterns: list[str], filter_type: str) -> django.db.models.QuerySet[archivebox.core.models.Snapshot, archivebox.core.models.Snapshot]
:canonical: archivebox.cli.archivebox_search._apply_pattern_filters
```{autodoc2-docstring} archivebox.cli.archivebox_search._apply_pattern_filters
```
````
````{py:function} _snapshots_to_json(snapshots: django.db.models.QuerySet[archivebox.core.models.Snapshot, archivebox.core.models.Snapshot], *, with_headers: bool) -> str
:canonical: archivebox.cli.archivebox_search._snapshots_to_json
```{autodoc2-docstring} archivebox.cli.archivebox_search._snapshots_to_json
```
````
````{py:function} _snapshots_to_csv(snapshots: django.db.models.QuerySet[archivebox.core.models.Snapshot, archivebox.core.models.Snapshot], *, cols: list[str], with_headers: bool) -> str
:canonical: archivebox.cli.archivebox_search._snapshots_to_csv
```{autodoc2-docstring} archivebox.cli.archivebox_search._snapshots_to_csv
```
````
````{py:function} _snapshots_to_html(snapshots: django.db.models.QuerySet[archivebox.core.models.Snapshot, archivebox.core.models.Snapshot], *, with_headers: bool) -> str
:canonical: archivebox.cli.archivebox_search._snapshots_to_html
```{autodoc2-docstring} archivebox.cli.archivebox_search._snapshots_to_html
```
````
````{py:function} get_snapshots(snapshots: django.db.models.QuerySet[archivebox.core.models.Snapshot, archivebox.core.models.Snapshot] | None = None, filter_patterns: list[str] | None = None, filter_type: str = 'substring', after: float | None = None, before: float | None = None, out_dir: pathlib.Path = DATA_DIR) -> django.db.models.QuerySet[archivebox.core.models.Snapshot, archivebox.core.models.Snapshot]
:canonical: archivebox.cli.archivebox_search.get_snapshots
```{autodoc2-docstring} archivebox.cli.archivebox_search.get_snapshots
```
````
````{py:function} search(filter_patterns: list[str] | None = None, filter_type: str = 'substring', status: str = 'indexed', before: float | None = None, after: float | None = None, sort: str | None = None, json: bool = False, html: bool = False, csv: str | None = None, with_headers: bool = False)
:canonical: archivebox.cli.archivebox_search.search
```{autodoc2-docstring} archivebox.cli.archivebox_search.search
```
````
````{py:function} main(**kwargs)
:canonical: archivebox.cli.archivebox_search.main
```{autodoc2-docstring} archivebox.cli.archivebox_search.main
```
````

158
docs/apidocs/archivebox/archivebox.cli.archivebox_server.md
View File

@ -1,158 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_server`
```{py:module} archivebox.cli.archivebox_server
```
```{autodoc2-docstring} archivebox.cli.archivebox_server
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_is_ipv4_literal <archivebox.cli.archivebox_server._is_ipv4_literal>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_server._is_ipv4_literal
:summary:
```
* - {py:obj}`_is_ipv6_literal <archivebox.cli.archivebox_server._is_ipv6_literal>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_server._is_ipv6_literal
:summary:
```
* - {py:obj}`_bind_host_looks_like_ip <archivebox.cli.archivebox_server._bind_host_looks_like_ip>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_server._bind_host_looks_like_ip
:summary:
```
* - {py:obj}`_split_bind_spec <archivebox.cli.archivebox_server._split_bind_spec>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_server._split_bind_spec
:summary:
```
* - {py:obj}`_parse_and_validate_bind_spec <archivebox.cli.archivebox_server._parse_and_validate_bind_spec>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_server._parse_and_validate_bind_spec
:summary:
```
* - {py:obj}`_print_server_startup_warnings <archivebox.cli.archivebox_server._print_server_startup_warnings>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_server._print_server_startup_warnings
:summary:
```
* - {py:obj}`server <archivebox.cli.archivebox_server.server>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_server.server
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_server.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_server.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_IPV4_RE <archivebox.cli.archivebox_server._IPV4_RE>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_server._IPV4_RE
:summary:
```
* - {py:obj}`_IPV6_CHARS_RE <archivebox.cli.archivebox_server._IPV6_CHARS_RE>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_server._IPV6_CHARS_RE
:summary:
```
* - {py:obj}`_LOCAL_BIND_HOSTS <archivebox.cli.archivebox_server._LOCAL_BIND_HOSTS>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_server._LOCAL_BIND_HOSTS
:summary:
```
````
### API
````{py:data} _IPV4_RE
:canonical: archivebox.cli.archivebox_server._IPV4_RE
:value: >
'compile(...)'
```{autodoc2-docstring} archivebox.cli.archivebox_server._IPV4_RE
```
````
````{py:data} _IPV6_CHARS_RE
:canonical: archivebox.cli.archivebox_server._IPV6_CHARS_RE
:value: >
'compile(...)'
```{autodoc2-docstring} archivebox.cli.archivebox_server._IPV6_CHARS_RE
```
````
````{py:data} _LOCAL_BIND_HOSTS
:canonical: archivebox.cli.archivebox_server._LOCAL_BIND_HOSTS
:value: >
'frozenset(...)'
```{autodoc2-docstring} archivebox.cli.archivebox_server._LOCAL_BIND_HOSTS
```
````
````{py:function} _is_ipv4_literal(host: str) -> bool
:canonical: archivebox.cli.archivebox_server._is_ipv4_literal
```{autodoc2-docstring} archivebox.cli.archivebox_server._is_ipv4_literal
```
````
````{py:function} _is_ipv6_literal(host: str) -> bool
:canonical: archivebox.cli.archivebox_server._is_ipv6_literal
```{autodoc2-docstring} archivebox.cli.archivebox_server._is_ipv6_literal
```
````
````{py:function} _bind_host_looks_like_ip(host: str) -> bool
:canonical: archivebox.cli.archivebox_server._bind_host_looks_like_ip
```{autodoc2-docstring} archivebox.cli.archivebox_server._bind_host_looks_like_ip
```
````
````{py:function} _split_bind_spec(spec: str) -> tuple[str, str]
:canonical: archivebox.cli.archivebox_server._split_bind_spec
```{autodoc2-docstring} archivebox.cli.archivebox_server._split_bind_spec
```
````
````{py:function} _parse_and_validate_bind_spec(spec: str) -> tuple[str, str]
:canonical: archivebox.cli.archivebox_server._parse_and_validate_bind_spec
```{autodoc2-docstring} archivebox.cli.archivebox_server._parse_and_validate_bind_spec
```
````
````{py:function} _print_server_startup_warnings(config, host: str, port: str) -> None
:canonical: archivebox.cli.archivebox_server._print_server_startup_warnings
```{autodoc2-docstring} archivebox.cli.archivebox_server._print_server_startup_warnings
```
````
````{py:function} server(runserver_args: collections.abc.Iterable[str] | None = None, reload: bool = False, debug: bool = False, daemonize: bool = False, nothreading: bool = False) -> None
:canonical: archivebox.cli.archivebox_server.server
```{autodoc2-docstring} archivebox.cli.archivebox_server.server
```
````
````{py:function} main(**kwargs)
:canonical: archivebox.cli.archivebox_server.main
```{autodoc2-docstring} archivebox.cli.archivebox_server.main
```
````

42
docs/apidocs/archivebox/archivebox.cli.archivebox_shell.md
View File

@ -1,42 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_shell`
```{py:module} archivebox.cli.archivebox_shell
```
```{autodoc2-docstring} archivebox.cli.archivebox_shell
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`shell <archivebox.cli.archivebox_shell.shell>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_shell.shell
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_shell.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_shell.main
:summary:
```
````
### API
````{py:function} shell(args: collections.abc.Iterable[str] = ()) -> None
:canonical: archivebox.cli.archivebox_shell.shell
```{autodoc2-docstring} archivebox.cli.archivebox_shell.shell
```
````
````{py:function} main(args: collections.abc.Iterable[str] = ()) -> None
:canonical: archivebox.cli.archivebox_shell.main
```{autodoc2-docstring} archivebox.cli.archivebox_shell.main
```
````

152
docs/apidocs/archivebox/archivebox.cli.archivebox_snapshot.md
View File

@ -1,152 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_snapshot`
```{py:module} archivebox.cli.archivebox_snapshot
```
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`create_snapshots <archivebox.cli.archivebox_snapshot.create_snapshots>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.create_snapshots
:summary:
```
* - {py:obj}`build_snapshot_queryset <archivebox.cli.archivebox_snapshot.build_snapshot_queryset>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.build_snapshot_queryset
:summary:
```
* - {py:obj}`list_snapshots <archivebox.cli.archivebox_snapshot.list_snapshots>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.list_snapshots
:summary:
```
* - {py:obj}`update_snapshots <archivebox.cli.archivebox_snapshot.update_snapshots>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.update_snapshots
:summary:
```
* - {py:obj}`delete_snapshots <archivebox.cli.archivebox_snapshot.delete_snapshots>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.delete_snapshots
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_snapshot.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.main
:summary:
```
* - {py:obj}`create_cmd <archivebox.cli.archivebox_snapshot.create_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.create_cmd
:summary:
```
* - {py:obj}`list_cmd <archivebox.cli.archivebox_snapshot.list_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.list_cmd
:summary:
```
* - {py:obj}`update_cmd <archivebox.cli.archivebox_snapshot.update_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.update_cmd
:summary:
```
* - {py:obj}`delete_cmd <archivebox.cli.archivebox_snapshot.delete_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.delete_cmd
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_snapshot.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_snapshot.__command__
:value: >
'archivebox snapshot'
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.__command__
```
````
````{py:function} create_snapshots(urls: collections.abc.Iterable[str], tag: str = '', status: str = 'queued', depth: int = 0, created_by_id: int | None = None) -> int
:canonical: archivebox.cli.archivebox_snapshot.create_snapshots
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.create_snapshots
```
````
````{py:function} build_snapshot_queryset(*, status: str | None = None, url__icontains: str | None = None, url__istartswith: str | None = None, tag: str | None = None, crawl_id: str | None = None, sort: str | None = None, search: str | None = None, query: str | None = None, limit: int | None = None) -> django.db.models.QuerySet
:canonical: archivebox.cli.archivebox_snapshot.build_snapshot_queryset
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.build_snapshot_queryset
```
````
````{py:function} list_snapshots(status: str | None = None, url__icontains: str | None = None, url__istartswith: str | None = None, tag: str | None = None, crawl_id: str | None = None, limit: int | None = None, sort: str | None = None, csv: str | None = None, with_headers: bool = False, search: str | None = None, query: str | None = None) -> int
:canonical: archivebox.cli.archivebox_snapshot.list_snapshots
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.list_snapshots
```
````
````{py:function} update_snapshots(status: str | None = None, tag: str | None = None) -> int
:canonical: archivebox.cli.archivebox_snapshot.update_snapshots
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.update_snapshots
```
````
````{py:function} delete_snapshots(yes: bool = False, dry_run: bool = False) -> int
:canonical: archivebox.cli.archivebox_snapshot.delete_snapshots
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.delete_snapshots
```
````
````{py:function} main()
:canonical: archivebox.cli.archivebox_snapshot.main
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.main
```
````
````{py:function} create_cmd(urls: tuple, tag: str, status: str, depth: int)
:canonical: archivebox.cli.archivebox_snapshot.create_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.create_cmd
```
````
````{py:function} list_cmd(status: str | None, url__icontains: str | None, url__istartswith: str | None, tag: str | None, crawl_id: str | None, limit: int | None, sort: str | None, csv: str | None, with_headers: bool, search: str | None, query: tuple[str, ...])
:canonical: archivebox.cli.archivebox_snapshot.list_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.list_cmd
```
````
````{py:function} update_cmd(status: str | None, tag: str | None)
:canonical: archivebox.cli.archivebox_snapshot.update_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.update_cmd
```
````
````{py:function} delete_cmd(yes: bool, dry_run: bool)
:canonical: archivebox.cli.archivebox_snapshot.delete_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot.delete_cmd
```
````

53
docs/apidocs/archivebox/archivebox.cli.archivebox_snapshot_compat.md
View File

@ -1,53 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_snapshot_compat`
```{py:module} archivebox.cli.archivebox_snapshot_compat
```
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot_compat
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`main <archivebox.cli.archivebox_snapshot_compat.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot_compat.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_snapshot_compat.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_snapshot_compat.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_snapshot_compat.__command__
:value: >
'archivebox snapshot'
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot_compat.__command__
```
````
````{py:function} main(tag: str, status: str, depth: int, urls: tuple[str, ...])
:canonical: archivebox.cli.archivebox_snapshot_compat.main
```{autodoc2-docstring} archivebox.cli.archivebox_snapshot_compat.main
```
````

64
docs/apidocs/archivebox/archivebox.cli.archivebox_status.md
View File

@ -1,64 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_status`
```{py:module} archivebox.cli.archivebox_status
```
```{autodoc2-docstring} archivebox.cli.archivebox_status
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`status <archivebox.cli.archivebox_status.status>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_status.status
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_status.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_status.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`MAX_STATUS_FS_DIR_SCAN <archivebox.cli.archivebox_status.MAX_STATUS_FS_DIR_SCAN>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_status.MAX_STATUS_FS_DIR_SCAN
:summary:
```
````
### API
````{py:data} MAX_STATUS_FS_DIR_SCAN
:canonical: archivebox.cli.archivebox_status.MAX_STATUS_FS_DIR_SCAN
:value: >
5000
```{autodoc2-docstring} archivebox.cli.archivebox_status.MAX_STATUS_FS_DIR_SCAN
```
````
````{py:function} status(out_dir: pathlib.Path = DATA_DIR) -> None
:canonical: archivebox.cli.archivebox_status.status
```{autodoc2-docstring} archivebox.cli.archivebox_status.status
```
````
````{py:function} main(**kwargs)
:canonical: archivebox.cli.archivebox_status.main
```{autodoc2-docstring} archivebox.cli.archivebox_status.main
```
````

141
docs/apidocs/archivebox/archivebox.cli.archivebox_tag.md
View File

@ -1,141 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_tag`
```{py:module} archivebox.cli.archivebox_tag
```
```{autodoc2-docstring} archivebox.cli.archivebox_tag
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`create_tags <archivebox.cli.archivebox_tag.create_tags>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_tag.create_tags
:summary:
```
* - {py:obj}`list_tags <archivebox.cli.archivebox_tag.list_tags>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_tag.list_tags
:summary:
```
* - {py:obj}`update_tags <archivebox.cli.archivebox_tag.update_tags>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_tag.update_tags
:summary:
```
* - {py:obj}`delete_tags <archivebox.cli.archivebox_tag.delete_tags>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_tag.delete_tags
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_tag.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_tag.main
:summary:
```
* - {py:obj}`create_cmd <archivebox.cli.archivebox_tag.create_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_tag.create_cmd
:summary:
```
* - {py:obj}`list_cmd <archivebox.cli.archivebox_tag.list_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_tag.list_cmd
:summary:
```
* - {py:obj}`update_cmd <archivebox.cli.archivebox_tag.update_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_tag.update_cmd
:summary:
```
* - {py:obj}`delete_cmd <archivebox.cli.archivebox_tag.delete_cmd>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_tag.delete_cmd
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.archivebox_tag.__command__>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_tag.__command__
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.archivebox_tag.__command__
:value: >
'archivebox tag'
```{autodoc2-docstring} archivebox.cli.archivebox_tag.__command__
```
````
````{py:function} create_tags(names: collections.abc.Iterable[str]) -> int
:canonical: archivebox.cli.archivebox_tag.create_tags
```{autodoc2-docstring} archivebox.cli.archivebox_tag.create_tags
```
````
````{py:function} list_tags(name: str | None = None, name__icontains: str | None = None, limit: int | None = None) -> int
:canonical: archivebox.cli.archivebox_tag.list_tags
```{autodoc2-docstring} archivebox.cli.archivebox_tag.list_tags
```
````
````{py:function} update_tags(name: str | None = None) -> int
:canonical: archivebox.cli.archivebox_tag.update_tags
```{autodoc2-docstring} archivebox.cli.archivebox_tag.update_tags
```
````
````{py:function} delete_tags(yes: bool = False, dry_run: bool = False) -> int
:canonical: archivebox.cli.archivebox_tag.delete_tags
```{autodoc2-docstring} archivebox.cli.archivebox_tag.delete_tags
```
````
````{py:function} main()
:canonical: archivebox.cli.archivebox_tag.main
```{autodoc2-docstring} archivebox.cli.archivebox_tag.main
```
````
````{py:function} create_cmd(names: tuple)
:canonical: archivebox.cli.archivebox_tag.create_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_tag.create_cmd
```
````
````{py:function} list_cmd(name: str | None, name__icontains: str | None, limit: int | None)
:canonical: archivebox.cli.archivebox_tag.list_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_tag.list_cmd
```
````
````{py:function} update_cmd(name: str | None)
:canonical: archivebox.cli.archivebox_tag.update_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_tag.update_cmd
```
````
````{py:function} delete_cmd(yes: bool, dry_run: bool)
:canonical: archivebox.cli.archivebox_tag.delete_cmd
```{autodoc2-docstring} archivebox.cli.archivebox_tag.delete_cmd
```
````

152
docs/apidocs/archivebox/archivebox.cli.archivebox_update.md
View File

@ -1,152 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_update`
```{py:module} archivebox.cli.archivebox_update
```
```{autodoc2-docstring} archivebox.cli.archivebox_update
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_get_snapshot_crawl <archivebox.cli.archivebox_update._get_snapshot_crawl>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_update._get_snapshot_crawl
:summary:
```
* - {py:obj}`_get_search_indexing_plugins <archivebox.cli.archivebox_update._get_search_indexing_plugins>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_update._get_search_indexing_plugins
:summary:
```
* - {py:obj}`_build_filtered_snapshots_queryset <archivebox.cli.archivebox_update._build_filtered_snapshots_queryset>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_update._build_filtered_snapshots_queryset
:summary:
```
* - {py:obj}`reindex_snapshots <archivebox.cli.archivebox_update.reindex_snapshots>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_update.reindex_snapshots
:summary:
```
* - {py:obj}`update <archivebox.cli.archivebox_update.update>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_update.update
:summary:
```
* - {py:obj}`drain_old_archive_dirs <archivebox.cli.archivebox_update.drain_old_archive_dirs>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_update.drain_old_archive_dirs
:summary:
```
* - {py:obj}`process_all_db_snapshots <archivebox.cli.archivebox_update.process_all_db_snapshots>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_update.process_all_db_snapshots
:summary:
```
* - {py:obj}`process_filtered_snapshots <archivebox.cli.archivebox_update.process_filtered_snapshots>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_update.process_filtered_snapshots
:summary:
```
* - {py:obj}`print_stats <archivebox.cli.archivebox_update.print_stats>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_update.print_stats
:summary:
```
* - {py:obj}`print_combined_stats <archivebox.cli.archivebox_update.print_combined_stats>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_update.print_combined_stats
:summary:
```
* - {py:obj}`print_index_stats <archivebox.cli.archivebox_update.print_index_stats>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_update.print_index_stats
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_update.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_update.main
:summary:
```
````
### API
````{py:function} _get_snapshot_crawl(snapshot: archivebox.core.models.Snapshot) -> archivebox.crawls.models.Crawl | None
:canonical: archivebox.cli.archivebox_update._get_snapshot_crawl
```{autodoc2-docstring} archivebox.cli.archivebox_update._get_snapshot_crawl
```
````
````{py:function} _get_search_indexing_plugins() -> list[str]
:canonical: archivebox.cli.archivebox_update._get_search_indexing_plugins
```{autodoc2-docstring} archivebox.cli.archivebox_update._get_search_indexing_plugins
```
````
````{py:function} _build_filtered_snapshots_queryset(*, filter_patterns: collections.abc.Iterable[str], filter_type: str, status: str | None = None, url__icontains: str | None = None, url__istartswith: str | None = None, tag: str | None = None, crawl_id: str | None = None, limit: int | None = None, sort: str | None = None, search: str | None = None, before: float | None = None, after: float | None = None, resume: str | None = None)
:canonical: archivebox.cli.archivebox_update._build_filtered_snapshots_queryset
```{autodoc2-docstring} archivebox.cli.archivebox_update._build_filtered_snapshots_queryset
```
````
````{py:function} reindex_snapshots(snapshots: django.db.models.QuerySet[archivebox.core.models.Snapshot, archivebox.core.models.Snapshot], *, search_plugins: list[str], batch_size: int, collect_ids: bool = False, wait_for_turn=None) -> dict[str, typing.Any]
:canonical: archivebox.cli.archivebox_update.reindex_snapshots
```{autodoc2-docstring} archivebox.cli.archivebox_update.reindex_snapshots
```
````
````{py:function} update(filter_patterns: collections.abc.Iterable[str] = (), filter_type: str = 'exact', status: str | None = None, url__icontains: str | None = None, url__istartswith: str | None = None, tag: str | None = None, crawl_id: str | None = None, limit: int | None = None, sort: str | None = None, search: str | None = None, before: float | None = None, after: float | None = None, resume: str | None = None, batch_size: int = 500, continuous: bool = False, index_only: bool = False, migrate_only: bool = False, stop_daemon_stack: bool = True) -> None
:canonical: archivebox.cli.archivebox_update.update
```{autodoc2-docstring} archivebox.cli.archivebox_update.update
```
````
````{py:function} drain_old_archive_dirs(resume_from: str | None = None, batch_size: int = 500) -> dict[str, int]
:canonical: archivebox.cli.archivebox_update.drain_old_archive_dirs
```{autodoc2-docstring} archivebox.cli.archivebox_update.drain_old_archive_dirs
```
````
````{py:function} process_all_db_snapshots(batch_size: int = 500, resume: str | None = None, wait_for_turn=None) -> dict[str, int]
:canonical: archivebox.cli.archivebox_update.process_all_db_snapshots
```{autodoc2-docstring} archivebox.cli.archivebox_update.process_all_db_snapshots
```
````
````{py:function} process_filtered_snapshots(filter_patterns: collections.abc.Iterable[str], filter_type: str, status: str | None, url__icontains: str | None, url__istartswith: str | None, tag: str | None, crawl_id: str | None, limit: int | None, sort: str | None, search: str | None, before: float | None, after: float | None, resume: str | None, batch_size: int, queue_for_archiving: bool = True, wait_for_turn=None) -> dict[str, typing.Any]
:canonical: archivebox.cli.archivebox_update.process_filtered_snapshots
```{autodoc2-docstring} archivebox.cli.archivebox_update.process_filtered_snapshots
```
````
````{py:function} print_stats(stats: dict)
:canonical: archivebox.cli.archivebox_update.print_stats
```{autodoc2-docstring} archivebox.cli.archivebox_update.print_stats
```
````
````{py:function} print_combined_stats(stats_combined: dict)
:canonical: archivebox.cli.archivebox_update.print_combined_stats
```{autodoc2-docstring} archivebox.cli.archivebox_update.print_combined_stats
```
````
````{py:function} print_index_stats(stats: dict[str, typing.Any]) -> None
:canonical: archivebox.cli.archivebox_update.print_index_stats
```{autodoc2-docstring} archivebox.cli.archivebox_update.print_index_stats
```
````
````{py:function} main(**kwargs)
:canonical: archivebox.cli.archivebox_update.main
```{autodoc2-docstring} archivebox.cli.archivebox_update.main
```
````

64
docs/apidocs/archivebox/archivebox.cli.archivebox_version.md
View File

@ -1,64 +0,0 @@
# {py:mod}`archivebox.cli.archivebox_version`
```{py:module} archivebox.cli.archivebox_version
```
```{autodoc2-docstring} archivebox.cli.archivebox_version
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_format_binary_abspath <archivebox.cli.archivebox_version._format_binary_abspath>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_version._format_binary_abspath
:summary:
```
* - {py:obj}`_render_binary_abspath <archivebox.cli.archivebox_version._render_binary_abspath>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_version._render_binary_abspath
:summary:
```
* - {py:obj}`version <archivebox.cli.archivebox_version.version>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_version.version
:summary:
```
* - {py:obj}`main <archivebox.cli.archivebox_version.main>`
- ```{autodoc2-docstring} archivebox.cli.archivebox_version.main
:summary:
```
````
### API
````{py:function} _format_binary_abspath(abspath: str, *, pwd: pathlib.Path, lib_dir: pathlib.Path, personas_dir: pathlib.Path, home: pathlib.Path) -> str
:canonical: archivebox.cli.archivebox_version._format_binary_abspath
```{autodoc2-docstring} archivebox.cli.archivebox_version._format_binary_abspath
```
````
````{py:function} _render_binary_abspath(abspath: str)
:canonical: archivebox.cli.archivebox_version._render_binary_abspath
```{autodoc2-docstring} archivebox.cli.archivebox_version._render_binary_abspath
```
````
````{py:function} version(quiet: bool = False, binaries: collections.abc.Iterable[str] = ()) -> list[str]
:canonical: archivebox.cli.archivebox_version.version
```{autodoc2-docstring} archivebox.cli.archivebox_version.version
```
````
````{py:function} main(**kwargs)
:canonical: archivebox.cli.archivebox_version.main
```{autodoc2-docstring} archivebox.cli.archivebox_version.main
```
````

31
docs/apidocs/archivebox/archivebox.cli.cli_util.md
View File

@ -1,31 +0,0 @@
# {py:mod}`archivebox.cli.cli_util`
```{py:module} archivebox.cli.cli_util
```
```{autodoc2-docstring} archivebox.cli.cli_util
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`apply_filters <archivebox.cli.cli_util.apply_filters>`
- ```{autodoc2-docstring} archivebox.cli.cli_util.apply_filters
:summary:
```
````
### API
````{py:function} apply_filters(queryset, filter_kwargs: dict, limit: int | None = None)
:canonical: archivebox.cli.cli_util.apply_filters
```{autodoc2-docstring} archivebox.cli.cli_util.apply_filters
```
````

256
docs/apidocs/archivebox/archivebox.cli.md
View File

@ -1,256 +0,0 @@
# {py:mod}`archivebox.cli`
```{py:module} archivebox.cli
```
```{autodoc2-docstring} archivebox.cli
:allowtitles:
```
## Submodules
```{toctree}
:titlesonly:
:maxdepth: 1
archivebox.cli.archivebox_shell
archivebox.cli.archivebox_schedule
archivebox.cli.archivebox_list
archivebox.cli.archivebox_archiveresult
archivebox.cli.archivebox_process
archivebox.cli.archivebox_tag
archivebox.cli.archivebox_config
archivebox.cli.archivebox_server
archivebox.cli.archivebox_binary
archivebox.cli.archivebox_snapshot
archivebox.cli.archivebox_pluginmap
archivebox.cli.archivebox_crawl_compat
archivebox.cli.archivebox_machine
archivebox.cli.archivebox_update
archivebox.cli.archivebox_extract
archivebox.cli.archivebox_crawl
archivebox.cli.archivebox_remove
archivebox.cli.archivebox_install
archivebox.cli.archivebox_mcp
archivebox.cli.archivebox_search
archivebox.cli.archivebox_version
archivebox.cli.archivebox_persona
archivebox.cli.archivebox_snapshot_compat
archivebox.cli.archivebox_add
archivebox.cli.archivebox_status
archivebox.cli.cli_util
archivebox.cli.archivebox_run
archivebox.cli.archivebox_init
archivebox.cli.archivebox_help
archivebox.cli.archivebox_manage
```
## Package Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`ArchiveBoxGroup <archivebox.cli.ArchiveBoxGroup>`
- ```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup
:summary:
```
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`cli <archivebox.cli.cli>`
- ```{autodoc2-docstring} archivebox.cli.cli
:summary:
```
* - {py:obj}`main <archivebox.cli.main>`
- ```{autodoc2-docstring} archivebox.cli.main
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__command__ <archivebox.cli.__command__>`
- ```{autodoc2-docstring} archivebox.cli.__command__
:summary:
```
* - {py:obj}`STDERR <archivebox.cli.STDERR>`
- ```{autodoc2-docstring} archivebox.cli.STDERR
:summary:
```
````
### API
````{py:data} __command__
:canonical: archivebox.cli.__command__
:value: >
'archivebox'
```{autodoc2-docstring} archivebox.cli.__command__
```
````
````{py:data} STDERR
:canonical: archivebox.cli.STDERR
:value: >
'Console(...)'
```{autodoc2-docstring} archivebox.cli.STDERR
```
````
`````{py:class} ArchiveBoxGroup(name: str | None = None, commands: collections.abc.MutableMapping[str, click.core.Command] | collections.abc.Sequence[click.core.Command] | None = None, invoke_without_command: bool = False, no_args_is_help: bool | None = None, subcommand_metavar: str | None = None, chain: bool = False, result_callback: typing.Callable[..., typing.Any] | None = None, **kwargs: typing.Any)
:canonical: archivebox.cli.ArchiveBoxGroup
Bases: {py:obj}`rich_click.Group`
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup.__init__
```
````{py:attribute} meta_commands
:canonical: archivebox.cli.ArchiveBoxGroup.meta_commands
:value: >
None
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup.meta_commands
```
````
````{py:attribute} setup_commands
:canonical: archivebox.cli.ArchiveBoxGroup.setup_commands
:value: >
None
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup.setup_commands
```
````
````{py:attribute} model_commands
:canonical: archivebox.cli.ArchiveBoxGroup.model_commands
:value: >
None
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup.model_commands
```
````
````{py:attribute} archive_commands
:canonical: archivebox.cli.ArchiveBoxGroup.archive_commands
:value: >
None
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup.archive_commands
```
````
````{py:attribute} legacy_model_commands
:canonical: archivebox.cli.ArchiveBoxGroup.legacy_model_commands
:value: >
None
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup.legacy_model_commands
```
````
````{py:attribute} all_subcommands
:canonical: archivebox.cli.ArchiveBoxGroup.all_subcommands
:value: >
None
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup.all_subcommands
```
````
````{py:attribute} renamed_commands
:canonical: archivebox.cli.ArchiveBoxGroup.renamed_commands
:value: >
None
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup.renamed_commands
```
````
````{py:attribute} legacy_model_subcommands
:canonical: archivebox.cli.ArchiveBoxGroup.legacy_model_subcommands
:value: >
None
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup.legacy_model_subcommands
```
````
````{py:method} get_canonical_name(cmd_name)
:canonical: archivebox.cli.ArchiveBoxGroup.get_canonical_name
:classmethod:
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup.get_canonical_name
```
````
````{py:method} _should_use_legacy_model_command(cmd_name: str) -> bool
:canonical: archivebox.cli.ArchiveBoxGroup._should_use_legacy_model_command
:classmethod:
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup._should_use_legacy_model_command
```
````
````{py:method} get_command(ctx, cmd_name)
:canonical: archivebox.cli.ArchiveBoxGroup.get_command
````
````{py:method} _lazy_load(cmd_name_or_path)
:canonical: archivebox.cli.ArchiveBoxGroup._lazy_load
:classmethod:
```{autodoc2-docstring} archivebox.cli.ArchiveBoxGroup._lazy_load
```
````
`````
````{py:function} cli(ctx, help=False)
:canonical: archivebox.cli.cli
```{autodoc2-docstring} archivebox.cli.cli
```
````
````{py:function} main(args=None, prog_name=None, stdin=None)
:canonical: archivebox.cli.main
```{autodoc2-docstring} archivebox.cli.main
```
````

181
docs/apidocs/archivebox/archivebox.config.collection.md
View File

@ -1,181 +0,0 @@
# {py:mod}`archivebox.config.collection`
```{py:module} archivebox.config.collection
```
```{autodoc2-docstring} archivebox.config.collection
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_coerce_to_str_dict <archivebox.config.collection._coerce_to_str_dict>`
- ```{autodoc2-docstring} archivebox.config.collection._coerce_to_str_dict
:summary:
```
* - {py:obj}`_load_file_config_dict <archivebox.config.collection._load_file_config_dict>`
- ```{autodoc2-docstring} archivebox.config.collection._load_file_config_dict
:summary:
```
* - {py:obj}`_resolve_section_for_key <archivebox.config.collection._resolve_section_for_key>`
- ```{autodoc2-docstring} archivebox.config.collection._resolve_section_for_key
:summary:
```
* - {py:obj}`_render_config_file_content <archivebox.config.collection._render_config_file_content>`
- ```{autodoc2-docstring} archivebox.config.collection._render_config_file_content
:summary:
```
* - {py:obj}`_write_file_if_changed <archivebox.config.collection._write_file_if_changed>`
- ```{autodoc2-docstring} archivebox.config.collection._write_file_if_changed
:summary:
```
* - {py:obj}`mirror_machine_config_to_file <archivebox.config.collection.mirror_machine_config_to_file>`
- ```{autodoc2-docstring} archivebox.config.collection.mirror_machine_config_to_file
:summary:
```
* - {py:obj}`_coerce_from_str_dict <archivebox.config.collection._coerce_from_str_dict>`
- ```{autodoc2-docstring} archivebox.config.collection._coerce_from_str_dict
:summary:
```
* - {py:obj}`_mirror_file_to_machine_config <archivebox.config.collection._mirror_file_to_machine_config>`
- ```{autodoc2-docstring} archivebox.config.collection._mirror_file_to_machine_config
:summary:
```
* - {py:obj}`sync_machine_and_file <archivebox.config.collection.sync_machine_and_file>`
- ```{autodoc2-docstring} archivebox.config.collection.sync_machine_and_file
:summary:
```
* - {py:obj}`write_config_file <archivebox.config.collection.write_config_file>`
- ```{autodoc2-docstring} archivebox.config.collection.write_config_file
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`CONFIG_FILE_HEADER <archivebox.config.collection.CONFIG_FILE_HEADER>`
- ```{autodoc2-docstring} archivebox.config.collection.CONFIG_FILE_HEADER
:summary:
```
* - {py:obj}`_MIRROR_IN_PROGRESS <archivebox.config.collection._MIRROR_IN_PROGRESS>`
- ```{autodoc2-docstring} archivebox.config.collection._MIRROR_IN_PROGRESS
:summary:
```
* - {py:obj}`_INITIAL_SYNC_DONE <archivebox.config.collection._INITIAL_SYNC_DONE>`
- ```{autodoc2-docstring} archivebox.config.collection._INITIAL_SYNC_DONE
:summary:
```
````
### API
````{py:data} CONFIG_FILE_HEADER
:canonical: archivebox.config.collection.CONFIG_FILE_HEADER
:value: <Multiline-String>
```{autodoc2-docstring} archivebox.config.collection.CONFIG_FILE_HEADER
```
````
````{py:data} _MIRROR_IN_PROGRESS
:canonical: archivebox.config.collection._MIRROR_IN_PROGRESS
:type: bool
:value: >
False
```{autodoc2-docstring} archivebox.config.collection._MIRROR_IN_PROGRESS
```
````
````{py:data} _INITIAL_SYNC_DONE
:canonical: archivebox.config.collection._INITIAL_SYNC_DONE
:type: bool
:value: >
False
```{autodoc2-docstring} archivebox.config.collection._INITIAL_SYNC_DONE
```
````
````{py:function} _coerce_to_str_dict(config: typing.Any) -> dict[str, str]
:canonical: archivebox.config.collection._coerce_to_str_dict
```{autodoc2-docstring} archivebox.config.collection._coerce_to_str_dict
```
````
````{py:function} _load_file_config_dict() -> tuple[dict[str, str], float | None]
:canonical: archivebox.config.collection._load_file_config_dict
```{autodoc2-docstring} archivebox.config.collection._load_file_config_dict
```
````
````{py:function} _resolve_section_for_key(key: str, config_sections, plugin_configs) -> str
:canonical: archivebox.config.collection._resolve_section_for_key
```{autodoc2-docstring} archivebox.config.collection._resolve_section_for_key
```
````
````{py:function} _render_config_file_content(config: dict[str, str]) -> str
:canonical: archivebox.config.collection._render_config_file_content
```{autodoc2-docstring} archivebox.config.collection._render_config_file_content
```
````
````{py:function} _write_file_if_changed(content: str) -> bool
:canonical: archivebox.config.collection._write_file_if_changed
```{autodoc2-docstring} archivebox.config.collection._write_file_if_changed
```
````
````{py:function} mirror_machine_config_to_file(config: typing.Any) -> None
:canonical: archivebox.config.collection.mirror_machine_config_to_file
```{autodoc2-docstring} archivebox.config.collection.mirror_machine_config_to_file
```
````
````{py:function} _coerce_from_str_dict(file_config: dict[str, str]) -> dict[str, typing.Any]
:canonical: archivebox.config.collection._coerce_from_str_dict
```{autodoc2-docstring} archivebox.config.collection._coerce_from_str_dict
```
````
````{py:function} _mirror_file_to_machine_config(file_config: dict[str, str]) -> None
:canonical: archivebox.config.collection._mirror_file_to_machine_config
```{autodoc2-docstring} archivebox.config.collection._mirror_file_to_machine_config
```
````
````{py:function} sync_machine_and_file(machine: typing.Any = None) -> None
:canonical: archivebox.config.collection.sync_machine_and_file
```{autodoc2-docstring} archivebox.config.collection.sync_machine_and_file
```
````
````{py:function} write_config_file(config: dict[str, str]) -> archivebox.misc.logging.AttrDict
:canonical: archivebox.config.collection.write_config_file
```{autodoc2-docstring} archivebox.config.collection.write_config_file
```
````

1394
docs/apidocs/archivebox/archivebox.config.common.md
View File

File diff suppressed because it is too large Load Diff

265
docs/apidocs/archivebox/archivebox.config.configset.md
View File

@ -1,265 +0,0 @@
# {py:mod}`archivebox.config.configset`
```{py:module} archivebox.config.configset
```
```{autodoc2-docstring} archivebox.config.configset
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`CaseConfigParser <archivebox.config.configset.CaseConfigParser>`
-
* - {py:obj}`IniConfigSettingsSource <archivebox.config.configset.IniConfigSettingsSource>`
- ```{autodoc2-docstring} archivebox.config.configset.IniConfigSettingsSource
:summary:
```
* - {py:obj}`BaseConfigSet <archivebox.config.configset.BaseConfigSet>`
- ```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet
:summary:
```
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_read_ini_config_cached <archivebox.config.configset._read_ini_config_cached>`
- ```{autodoc2-docstring} archivebox.config.configset._read_ini_config_cached
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`COMPUTED_CONFIG_KEYS <archivebox.config.configset.COMPUTED_CONFIG_KEYS>`
- ```{autodoc2-docstring} archivebox.config.configset.COMPUTED_CONFIG_KEYS
:summary:
```
* - {py:obj}`_INI_CACHE <archivebox.config.configset._INI_CACHE>`
- ```{autodoc2-docstring} archivebox.config.configset._INI_CACHE
:summary:
```
````
### API
````{py:data} COMPUTED_CONFIG_KEYS
:canonical: archivebox.config.configset.COMPUTED_CONFIG_KEYS
:value: >
('TERM_WIDTH', 'COMMIT_HASH', 'BUILD_TIME', 'USES_SUBDOMAIN_ROUTING', 'ENABLES_FULL_JS_REPLAY', 'CON...
```{autodoc2-docstring} archivebox.config.configset.COMPUTED_CONFIG_KEYS
```
````
`````{py:class} CaseConfigParser(defaults=None, dict_type=_default_dict, allow_no_value=False, *, delimiters=('=', ':'), comment_prefixes=('#', ';'), inline_comment_prefixes=None, strict=True, empty_lines_in_values=True, default_section=DEFAULTSECT, interpolation=_UNSET, converters=_UNSET, allow_unnamed_section=False)
:canonical: archivebox.config.configset.CaseConfigParser
Bases: {py:obj}`configparser.ConfigParser`
````{py:method} optionxform(optionstr: str) -> str
:canonical: archivebox.config.configset.CaseConfigParser.optionxform
```{autodoc2-docstring} archivebox.config.configset.CaseConfigParser.optionxform
```
````
`````
````{py:data} _INI_CACHE
:canonical: archivebox.config.configset._INI_CACHE
:type: dict[tuple[str, float], dict[str, typing.Any]]
:value: >
None
```{autodoc2-docstring} archivebox.config.configset._INI_CACHE
```
````
````{py:function} _read_ini_config_cached(config_path_str: str) -> dict[str, typing.Any]
:canonical: archivebox.config.configset._read_ini_config_cached
```{autodoc2-docstring} archivebox.config.configset._read_ini_config_cached
```
````
`````{py:class} IniConfigSettingsSource(settings_cls: type[pydantic_settings.main.BaseSettings])
:canonical: archivebox.config.configset.IniConfigSettingsSource
Bases: {py:obj}`pydantic_settings.PydanticBaseSettingsSource`
```{autodoc2-docstring} archivebox.config.configset.IniConfigSettingsSource
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.config.configset.IniConfigSettingsSource.__init__
```
````{py:method} get_field_value(field: typing.Any, field_name: str) -> tuple[typing.Any, str, bool]
:canonical: archivebox.config.configset.IniConfigSettingsSource.get_field_value
````
````{py:method} __call__() -> dict[str, typing.Any]
:canonical: archivebox.config.configset.IniConfigSettingsSource.__call__
```{autodoc2-docstring} archivebox.config.configset.IniConfigSettingsSource.__call__
```
````
````{py:method} _load_config_file() -> dict[str, typing.Any]
:canonical: archivebox.config.configset.IniConfigSettingsSource._load_config_file
```{autodoc2-docstring} archivebox.config.configset.IniConfigSettingsSource._load_config_file
```
````
`````
`````{py:class} BaseConfigSet(_case_sensitive: bool | None = None, _nested_model_default_partial_update: bool | None = None, _env_prefix: str | None = None, _env_prefix_target: pydantic_settings.sources.EnvPrefixTarget | None = None, _env_file: pydantic_settings.sources.DotenvType | None = ENV_FILE_SENTINEL, _env_file_encoding: str | None = None, _env_ignore_empty: bool | None = None, _env_nested_delimiter: str | None = None, _env_nested_max_split: int | None = None, _env_parse_none_str: str | None = None, _env_parse_enums: bool | None = None, _cli_prog_name: str | None = None, _cli_parse_args: bool | list[str] | tuple[str, ...] | None = None, _cli_settings_source: pydantic_settings.sources.CliSettingsSource[typing.Any] | None = None, _cli_parse_none_str: str | None = None, _cli_hide_none_type: bool | None = None, _cli_avoid_json: bool | None = None, _cli_enforce_required: bool | None = None, _cli_use_class_docs_for_groups: bool | None = None, _cli_exit_on_error: bool | None = None, _cli_prefix: str | None = None, _cli_flag_prefix_char: str | None = None, _cli_implicit_flags: bool | typing.Literal[dual, toggle] | None = None, _cli_ignore_unknown_args: bool | None = None, _cli_kebab_case: bool | typing.Literal[all, no_enums] | None = None, _cli_shortcuts: collections.abc.Mapping[str, str | list[str]] | None = None, _secrets_dir: pydantic_settings.sources.PathType | None = None, _build_sources: tuple[tuple[pydantic_settings.sources.PydanticBaseSettingsSource, ...], dict[str, typing.Any]] | None = None, **values: typing.Any)
:canonical: archivebox.config.configset.BaseConfigSet
Bases: {py:obj}`pydantic_settings.BaseSettings`
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.__init__
```
````{py:attribute} model_config
:canonical: archivebox.config.configset.BaseConfigSet.model_config
:value: >
'SettingsConfigDict(...)'
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.model_config
```
````
````{py:attribute} computed_config_keys
:canonical: archivebox.config.configset.BaseConfigSet.computed_config_keys
:type: typing.ClassVar[tuple[str, ...]]
:value: >
()
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.computed_config_keys
```
````
````{py:method} settings_customise_sources(settings_cls: type[pydantic_settings.BaseSettings], init_settings: pydantic_settings.PydanticBaseSettingsSource, env_settings: pydantic_settings.PydanticBaseSettingsSource, dotenv_settings: pydantic_settings.PydanticBaseSettingsSource, file_secret_settings: pydantic_settings.PydanticBaseSettingsSource) -> tuple[pydantic_settings.PydanticBaseSettingsSource, ...]
:canonical: archivebox.config.configset.BaseConfigSet.settings_customise_sources
:classmethod:
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.settings_customise_sources
```
````
````{py:method} load_from_file(config_path: pathlib.Path) -> dict[str, str]
:canonical: archivebox.config.configset.BaseConfigSet.load_from_file
:classmethod:
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.load_from_file
```
````
````{py:method} __getitem__(key: str) -> typing.Any
:canonical: archivebox.config.configset.BaseConfigSet.__getitem__
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.__getitem__
```
````
````{py:method} __setitem__(key: str, value: typing.Any) -> None
:canonical: archivebox.config.configset.BaseConfigSet.__setitem__
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.__setitem__
```
````
````{py:method} update(*args, **kwargs) -> None
:canonical: archivebox.config.configset.BaseConfigSet.update
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.update
```
````
````{py:method} __contains__(key: str) -> bool
:canonical: archivebox.config.configset.BaseConfigSet.__contains__
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.__contains__
```
````
````{py:method} get(key: str, default: typing.Any = None) -> typing.Any
:canonical: archivebox.config.configset.BaseConfigSet.get
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.get
```
````
````{py:method} as_dict() -> dict[str, typing.Any]
:canonical: archivebox.config.configset.BaseConfigSet.as_dict
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.as_dict
```
````
````{py:method} items()
:canonical: archivebox.config.configset.BaseConfigSet.items
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.items
```
````
````{py:method} keys()
:canonical: archivebox.config.configset.BaseConfigSet.keys
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.keys
```
````
````{py:method} values()
:canonical: archivebox.config.configset.BaseConfigSet.values
```{autodoc2-docstring} archivebox.config.configset.BaseConfigSet.values
```
````
`````

770
docs/apidocs/archivebox/archivebox.config.constants.md
View File

@ -1,770 +0,0 @@
# {py:mod}`archivebox.config.constants`
```{py:module} archivebox.config.constants
```
```{autodoc2-docstring} archivebox.config.constants
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`ConstantsDict <archivebox.config.constants.ConstantsDict>`
- ```{autodoc2-docstring} archivebox.config.constants.ConstantsDict
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`CONSTANTS <archivebox.config.constants.CONSTANTS>`
- ```{autodoc2-docstring} archivebox.config.constants.CONSTANTS
:summary:
```
* - {py:obj}`CONSTANTS_CONFIG <archivebox.config.constants.CONSTANTS_CONFIG>`
- ```{autodoc2-docstring} archivebox.config.constants.CONSTANTS_CONFIG
:summary:
```
````
### API
`````{py:class} ConstantsDict
:canonical: archivebox.config.constants.ConstantsDict
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict
```
````{py:attribute} PACKAGE_DIR
:canonical: archivebox.config.constants.ConstantsDict.PACKAGE_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.PACKAGE_DIR
```
````
````{py:attribute} DATA_DIR
:canonical: archivebox.config.constants.ConstantsDict.DATA_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.DATA_DIR
```
````
````{py:attribute} ARCHIVE_DIR
:canonical: archivebox.config.constants.ConstantsDict.ARCHIVE_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.ARCHIVE_DIR
```
````
````{py:attribute} USERS_DIR
:canonical: archivebox.config.constants.ConstantsDict.USERS_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.USERS_DIR
```
````
````{py:attribute} MACHINE_TYPE
:canonical: archivebox.config.constants.ConstantsDict.MACHINE_TYPE
:type: str
:value: >
'get_machine_type(...)'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.MACHINE_TYPE
```
````
````{py:attribute} MACHINE_ID
:canonical: archivebox.config.constants.ConstantsDict.MACHINE_ID
:type: str
:value: >
'get_machine_id(...)'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.MACHINE_ID
```
````
````{py:attribute} COLLECTION_ID
:canonical: archivebox.config.constants.ConstantsDict.COLLECTION_ID
:type: str
:value: >
'get_collection_id(...)'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.COLLECTION_ID
```
````
````{py:attribute} VERSION
:canonical: archivebox.config.constants.ConstantsDict.VERSION
:type: str
:value: >
'detect_installed_version(...)'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.VERSION
```
````
````{py:attribute} IN_DOCKER
:canonical: archivebox.config.constants.ConstantsDict.IN_DOCKER
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.IN_DOCKER
```
````
````{py:attribute} IS_ROOT
:canonical: archivebox.config.constants.ConstantsDict.IS_ROOT
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.IS_ROOT
```
````
````{py:attribute} ARCHIVEBOX_USER
:canonical: archivebox.config.constants.ConstantsDict.ARCHIVEBOX_USER
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.ARCHIVEBOX_USER
```
````
````{py:attribute} ARCHIVEBOX_GROUP
:canonical: archivebox.config.constants.ConstantsDict.ARCHIVEBOX_GROUP
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.ARCHIVEBOX_GROUP
```
````
````{py:attribute} RUNNING_AS_UID
:canonical: archivebox.config.constants.ConstantsDict.RUNNING_AS_UID
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.RUNNING_AS_UID
```
````
````{py:attribute} RUNNING_AS_GID
:canonical: archivebox.config.constants.ConstantsDict.RUNNING_AS_GID
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.RUNNING_AS_GID
```
````
````{py:attribute} DEFAULT_PUID
:canonical: archivebox.config.constants.ConstantsDict.DEFAULT_PUID
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.DEFAULT_PUID
```
````
````{py:attribute} DEFAULT_PGID
:canonical: archivebox.config.constants.ConstantsDict.DEFAULT_PGID
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.DEFAULT_PGID
```
````
````{py:attribute} IS_INSIDE_VENV
:canonical: archivebox.config.constants.ConstantsDict.IS_INSIDE_VENV
:type: bool
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.IS_INSIDE_VENV
```
````
````{py:attribute} PACKAGE_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.PACKAGE_DIR_NAME
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.PACKAGE_DIR_NAME
```
````
````{py:attribute} TEMPLATES_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.TEMPLATES_DIR_NAME
:type: str
:value: >
'templates'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.TEMPLATES_DIR_NAME
```
````
````{py:attribute} TEMPLATES_DIR
:canonical: archivebox.config.constants.ConstantsDict.TEMPLATES_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.TEMPLATES_DIR
```
````
````{py:attribute} STATIC_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.STATIC_DIR_NAME
:type: str
:value: >
'static'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.STATIC_DIR_NAME
```
````
````{py:attribute} STATIC_DIR
:canonical: archivebox.config.constants.ConstantsDict.STATIC_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.STATIC_DIR
```
````
````{py:attribute} ARCHIVE_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.ARCHIVE_DIR_NAME
:type: str
:value: >
'archive'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.ARCHIVE_DIR_NAME
```
````
````{py:attribute} USERS_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.USERS_DIR_NAME
:type: str
:value: >
'users'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.USERS_DIR_NAME
```
````
````{py:attribute} SNAPSHOTS_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.SNAPSHOTS_DIR_NAME
:type: str
:value: >
'snapshots'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.SNAPSHOTS_DIR_NAME
```
````
````{py:attribute} CRAWLS_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.CRAWLS_DIR_NAME
:type: str
:value: >
'crawls'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.CRAWLS_DIR_NAME
```
````
````{py:attribute} SOURCES_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.SOURCES_DIR_NAME
:type: str
:value: >
'sources'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.SOURCES_DIR_NAME
```
````
````{py:attribute} PERSONAS_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.PERSONAS_DIR_NAME
:type: str
:value: >
'personas'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.PERSONAS_DIR_NAME
```
````
````{py:attribute} CACHE_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.CACHE_DIR_NAME
:type: str
:value: >
'cache'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.CACHE_DIR_NAME
```
````
````{py:attribute} LOGS_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.LOGS_DIR_NAME
:type: str
:value: >
'logs'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.LOGS_DIR_NAME
```
````
````{py:attribute} CUSTOM_PLUGINS_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.CUSTOM_PLUGINS_DIR_NAME
:type: str
:value: >
'custom_plugins'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.CUSTOM_PLUGINS_DIR_NAME
```
````
````{py:attribute} CUSTOM_TEMPLATES_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.CUSTOM_TEMPLATES_DIR_NAME
:type: str
:value: >
'custom_templates'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.CUSTOM_TEMPLATES_DIR_NAME
```
````
````{py:attribute} SOURCES_DIR
:canonical: archivebox.config.constants.ConstantsDict.SOURCES_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.SOURCES_DIR
```
````
````{py:attribute} PERSONAS_DIR
:canonical: archivebox.config.constants.ConstantsDict.PERSONAS_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.PERSONAS_DIR
```
````
````{py:attribute} LOGS_DIR
:canonical: archivebox.config.constants.ConstantsDict.LOGS_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.LOGS_DIR
```
````
````{py:attribute} CACHE_DIR
:canonical: archivebox.config.constants.ConstantsDict.CACHE_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.CACHE_DIR
```
````
````{py:attribute} CUSTOM_TEMPLATES_DIR
:canonical: archivebox.config.constants.ConstantsDict.CUSTOM_TEMPLATES_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.CUSTOM_TEMPLATES_DIR
```
````
````{py:attribute} USER_PLUGINS_DIR
:canonical: archivebox.config.constants.ConstantsDict.USER_PLUGINS_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.USER_PLUGINS_DIR
```
````
````{py:attribute} CONFIG_FILENAME
:canonical: archivebox.config.constants.ConstantsDict.CONFIG_FILENAME
:type: str
:value: >
'ArchiveBox.conf'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.CONFIG_FILENAME
```
````
````{py:attribute} SQL_INDEX_FILENAME
:canonical: archivebox.config.constants.ConstantsDict.SQL_INDEX_FILENAME
:type: str
:value: >
'index.sqlite3'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.SQL_INDEX_FILENAME
```
````
````{py:attribute} CONFIG_FILE
:canonical: archivebox.config.constants.ConstantsDict.CONFIG_FILE
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.CONFIG_FILE
```
````
````{py:attribute} DATABASE_FILE
:canonical: archivebox.config.constants.ConstantsDict.DATABASE_FILE
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.DATABASE_FILE
```
````
````{py:attribute} JSON_INDEX_FILENAME
:canonical: archivebox.config.constants.ConstantsDict.JSON_INDEX_FILENAME
:type: str
:value: >
'index.json'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.JSON_INDEX_FILENAME
```
````
````{py:attribute} JSONL_INDEX_FILENAME
:canonical: archivebox.config.constants.ConstantsDict.JSONL_INDEX_FILENAME
:type: str
:value: >
'index.jsonl'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.JSONL_INDEX_FILENAME
```
````
````{py:attribute} HTML_INDEX_FILENAME
:canonical: archivebox.config.constants.ConstantsDict.HTML_INDEX_FILENAME
:type: str
:value: >
'index.html'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.HTML_INDEX_FILENAME
```
````
````{py:attribute} ROBOTS_TXT_FILENAME
:canonical: archivebox.config.constants.ConstantsDict.ROBOTS_TXT_FILENAME
:type: str
:value: >
'robots.txt'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.ROBOTS_TXT_FILENAME
```
````
````{py:attribute} FAVICON_FILENAME
:canonical: archivebox.config.constants.ConstantsDict.FAVICON_FILENAME
:type: str
:value: >
'favicon.ico'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.FAVICON_FILENAME
```
````
````{py:attribute} TMP_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.TMP_DIR_NAME
:type: str
:value: >
'tmp'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.TMP_DIR_NAME
```
````
````{py:attribute} DEFAULT_TMP_DIR
:canonical: archivebox.config.constants.ConstantsDict.DEFAULT_TMP_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.DEFAULT_TMP_DIR
```
````
````{py:attribute} LIB_DIR_NAME
:canonical: archivebox.config.constants.ConstantsDict.LIB_DIR_NAME
:type: str
:value: >
'lib'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.LIB_DIR_NAME
```
````
````{py:attribute} DEFAULT_LIB_DIR
:canonical: archivebox.config.constants.ConstantsDict.DEFAULT_LIB_DIR
:type: pathlib.Path
:value: >
'_env_path(...)'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.DEFAULT_LIB_DIR
```
````
````{py:attribute} DEFAULT_LIB_BIN_DIR
:canonical: archivebox.config.constants.ConstantsDict.DEFAULT_LIB_BIN_DIR
:type: pathlib.Path
:value: >
'_env_path(...)'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.DEFAULT_LIB_BIN_DIR
```
````
````{py:attribute} RESERVED_ARCHIVE_DIR_NAMES
:canonical: archivebox.config.constants.ConstantsDict.RESERVED_ARCHIVE_DIR_NAMES
:type: frozenset[str]
:value: >
'frozenset(...)'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.RESERVED_ARCHIVE_DIR_NAMES
```
````
````{py:attribute} TIMEZONE
:canonical: archivebox.config.constants.ConstantsDict.TIMEZONE
:type: str
:value: >
'UTC'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.TIMEZONE
```
````
````{py:attribute} DEFAULT_CLI_COLORS
:canonical: archivebox.config.constants.ConstantsDict.DEFAULT_CLI_COLORS
:type: dict[str, str]
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.DEFAULT_CLI_COLORS
```
````
````{py:attribute} DISABLED_CLI_COLORS
:canonical: archivebox.config.constants.ConstantsDict.DISABLED_CLI_COLORS
:type: dict[str, str]
:value: >
'AttrDict(...)'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.DISABLED_CLI_COLORS
```
````
````{py:attribute} MAX_HOOK_RUNTIME_SECONDS
:canonical: archivebox.config.constants.ConstantsDict.MAX_HOOK_RUNTIME_SECONDS
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.MAX_HOOK_RUNTIME_SECONDS
```
````
````{py:attribute} MAX_SNAPSHOT_RUNTIME_SECONDS
:canonical: archivebox.config.constants.ConstantsDict.MAX_SNAPSHOT_RUNTIME_SECONDS
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.MAX_SNAPSHOT_RUNTIME_SECONDS
```
````
````{py:attribute} ALLOWDENYLIST_REGEX_FLAGS
:canonical: archivebox.config.constants.ConstantsDict.ALLOWDENYLIST_REGEX_FLAGS
:type: int
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.ALLOWDENYLIST_REGEX_FLAGS
```
````
````{py:attribute} STATICFILE_EXTENSIONS
:canonical: archivebox.config.constants.ConstantsDict.STATICFILE_EXTENSIONS
:type: frozenset[str]
:value: >
'frozenset(...)'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.STATICFILE_EXTENSIONS
```
````
````{py:attribute} PIP_RELATED_NAMES
:canonical: archivebox.config.constants.ConstantsDict.PIP_RELATED_NAMES
:type: frozenset[str]
:value: >
'frozenset(...)'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.PIP_RELATED_NAMES
```
````
````{py:attribute} NPM_RELATED_NAMES
:canonical: archivebox.config.constants.ConstantsDict.NPM_RELATED_NAMES
:type: frozenset[str]
:value: >
'frozenset(...)'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.NPM_RELATED_NAMES
```
````
````{py:attribute} ALLOWED_IN_DATA_DIR
:canonical: archivebox.config.constants.ConstantsDict.ALLOWED_IN_DATA_DIR
:type: frozenset[str]
:value: >
'frozenset(...)'
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.ALLOWED_IN_DATA_DIR
```
````
````{py:method} __getitem__(key: str)
:canonical: archivebox.config.constants.ConstantsDict.__getitem__
:classmethod:
```{autodoc2-docstring} archivebox.config.constants.ConstantsDict.__getitem__
```
````
`````
````{py:data} CONSTANTS
:canonical: archivebox.config.constants.CONSTANTS
:value: >
None
```{autodoc2-docstring} archivebox.config.constants.CONSTANTS
```
````
````{py:data} CONSTANTS_CONFIG
:canonical: archivebox.config.constants.CONSTANTS_CONFIG
:value: >
'AttrDict(...)'
```{autodoc2-docstring} archivebox.config.constants.CONSTANTS_CONFIG
```
````

81
docs/apidocs/archivebox/archivebox.config.django.md
View File

@ -1,81 +0,0 @@
# {py:mod}`archivebox.config.django`
```{py:module} archivebox.config.django
```
```{autodoc2-docstring} archivebox.config.django
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`setup_django <archivebox.config.django.setup_django>`
- ```{autodoc2-docstring} archivebox.config.django.setup_django
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`CONFIG <archivebox.config.django.CONFIG>`
- ```{autodoc2-docstring} archivebox.config.django.CONFIG
:summary:
```
* - {py:obj}`STDERR <archivebox.config.django.STDERR>`
- ```{autodoc2-docstring} archivebox.config.django.STDERR
:summary:
```
* - {py:obj}`DJANGO_SET_UP <archivebox.config.django.DJANGO_SET_UP>`
- ```{autodoc2-docstring} archivebox.config.django.DJANGO_SET_UP
:summary:
```
````
### API
````{py:data} CONFIG
:canonical: archivebox.config.django.CONFIG
:value: >
'get_config(...)'
```{autodoc2-docstring} archivebox.config.django.CONFIG
```
````
````{py:data} STDERR
:canonical: archivebox.config.django.STDERR
:value: >
'Console(...)'
```{autodoc2-docstring} archivebox.config.django.STDERR
```
````
````{py:data} DJANGO_SET_UP
:canonical: archivebox.config.django.DJANGO_SET_UP
:value: >
False
```{autodoc2-docstring} archivebox.config.django.DJANGO_SET_UP
```
````
````{py:function} setup_django(check_db=False, in_memory_db=False) -> None
:canonical: archivebox.config.django.setup_django
```{autodoc2-docstring} archivebox.config.django.setup_django
```
````

180
docs/apidocs/archivebox/archivebox.config.ldap.md
View File

@ -1,180 +0,0 @@
# {py:mod}`archivebox.config.ldap`
```{py:module} archivebox.config.ldap
```
```{autodoc2-docstring} archivebox.config.ldap
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`LDAPConfig <archivebox.config.ldap.LDAPConfig>`
- ```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig
:summary:
```
````
### API
`````{py:class} LDAPConfig(_case_sensitive: bool | None = None, _nested_model_default_partial_update: bool | None = None, _env_prefix: str | None = None, _env_prefix_target: pydantic_settings.sources.EnvPrefixTarget | None = None, _env_file: pydantic_settings.sources.DotenvType | None = ENV_FILE_SENTINEL, _env_file_encoding: str | None = None, _env_ignore_empty: bool | None = None, _env_nested_delimiter: str | None = None, _env_nested_max_split: int | None = None, _env_parse_none_str: str | None = None, _env_parse_enums: bool | None = None, _cli_prog_name: str | None = None, _cli_parse_args: bool | list[str] | tuple[str, ...] | None = None, _cli_settings_source: pydantic_settings.sources.CliSettingsSource[typing.Any] | None = None, _cli_parse_none_str: str | None = None, _cli_hide_none_type: bool | None = None, _cli_avoid_json: bool | None = None, _cli_enforce_required: bool | None = None, _cli_use_class_docs_for_groups: bool | None = None, _cli_exit_on_error: bool | None = None, _cli_prefix: str | None = None, _cli_flag_prefix_char: str | None = None, _cli_implicit_flags: bool | typing.Literal[dual, toggle] | None = None, _cli_ignore_unknown_args: bool | None = None, _cli_kebab_case: bool | typing.Literal[all, no_enums] | None = None, _cli_shortcuts: collections.abc.Mapping[str, str | list[str]] | None = None, _secrets_dir: pydantic_settings.sources.PathType | None = None, _build_sources: tuple[tuple[pydantic_settings.sources.PydanticBaseSettingsSource, ...], dict[str, typing.Any]] | None = None, **values: typing.Any)
:canonical: archivebox.config.ldap.LDAPConfig
Bases: {py:obj}`archivebox.config.configset.BaseConfigSet`
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig
```
```{rubric} Initialization
```
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.__init__
```
````{py:attribute} toml_section_header
:canonical: archivebox.config.ldap.LDAPConfig.toml_section_header
:type: str
:value: >
'LDAP_CONFIG'
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.toml_section_header
```
````
````{py:attribute} LDAP_ENABLED
:canonical: archivebox.config.ldap.LDAPConfig.LDAP_ENABLED
:type: bool
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.LDAP_ENABLED
```
````
````{py:attribute} LDAP_SERVER_URI
:canonical: archivebox.config.ldap.LDAPConfig.LDAP_SERVER_URI
:type: str | None
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.LDAP_SERVER_URI
```
````
````{py:attribute} LDAP_BIND_DN
:canonical: archivebox.config.ldap.LDAPConfig.LDAP_BIND_DN
:type: str | None
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.LDAP_BIND_DN
```
````
````{py:attribute} LDAP_BIND_PASSWORD
:canonical: archivebox.config.ldap.LDAPConfig.LDAP_BIND_PASSWORD
:type: str | None
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.LDAP_BIND_PASSWORD
```
````
````{py:attribute} LDAP_USER_BASE
:canonical: archivebox.config.ldap.LDAPConfig.LDAP_USER_BASE
:type: str | None
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.LDAP_USER_BASE
```
````
````{py:attribute} LDAP_USER_FILTER
:canonical: archivebox.config.ldap.LDAPConfig.LDAP_USER_FILTER
:type: str
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.LDAP_USER_FILTER
```
````
````{py:attribute} LDAP_USERNAME_ATTR
:canonical: archivebox.config.ldap.LDAPConfig.LDAP_USERNAME_ATTR
:type: str
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.LDAP_USERNAME_ATTR
```
````
````{py:attribute} LDAP_FIRSTNAME_ATTR
:canonical: archivebox.config.ldap.LDAPConfig.LDAP_FIRSTNAME_ATTR
:type: str
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.LDAP_FIRSTNAME_ATTR
```
````
````{py:attribute} LDAP_LASTNAME_ATTR
:canonical: archivebox.config.ldap.LDAPConfig.LDAP_LASTNAME_ATTR
:type: str
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.LDAP_LASTNAME_ATTR
```
````
````{py:attribute} LDAP_EMAIL_ATTR
:canonical: archivebox.config.ldap.LDAPConfig.LDAP_EMAIL_ATTR
:type: str
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.LDAP_EMAIL_ATTR
```
````
````{py:attribute} LDAP_CREATE_SUPERUSER
:canonical: archivebox.config.ldap.LDAPConfig.LDAP_CREATE_SUPERUSER
:type: bool
:value: >
'Field(...)'
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.LDAP_CREATE_SUPERUSER
```
````
````{py:method} validate_ldap_config() -> tuple[bool, str]
:canonical: archivebox.config.ldap.LDAPConfig.validate_ldap_config
```{autodoc2-docstring} archivebox.config.ldap.LDAPConfig.validate_ldap_config
```
````
`````

85
docs/apidocs/archivebox/archivebox.config.md
View File

@ -1,85 +0,0 @@
# {py:mod}`archivebox.config`
```{py:module} archivebox.config
```
```{autodoc2-docstring} archivebox.config
:allowtitles:
```
## Submodules
```{toctree}
:titlesonly:
:maxdepth: 1
archivebox.config.django
archivebox.config.ldap
archivebox.config.version
archivebox.config.paths
archivebox.config.constants
archivebox.config.common
archivebox.config.collection
archivebox.config.permissions
archivebox.config.configset
archivebox.config.views
```
## Package Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__getattr__ <archivebox.config.__getattr__>`
- ```{autodoc2-docstring} archivebox.config.__getattr__
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`__order__ <archivebox.config.__order__>`
- ```{autodoc2-docstring} archivebox.config.__order__
:summary:
```
* - {py:obj}`__all__ <archivebox.config.__all__>`
- ```{autodoc2-docstring} archivebox.config.__all__
:summary:
```
````
### API
````{py:data} __order__
:canonical: archivebox.config.__order__
:value: >
200
```{autodoc2-docstring} archivebox.config.__order__
```
````
````{py:function} __getattr__(name: str)
:canonical: archivebox.config.__getattr__
```{autodoc2-docstring} archivebox.config.__getattr__
```
````
````{py:data} __all__
:canonical: archivebox.config.__all__
:value: >
('CONSTANTS', 'CONSTANTS_CONFIG', 'PACKAGE_DIR', 'DATA_DIR', 'VERSION')
```{autodoc2-docstring} archivebox.config.__all__
```
````

259
docs/apidocs/archivebox/archivebox.config.paths.md
View File

@ -1,259 +0,0 @@
# {py:mod}`archivebox.config.paths`
```{py:module} archivebox.config.paths
```
```{autodoc2-docstring} archivebox.config.paths
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_env_path <archivebox.config.paths._env_path>`
- ```{autodoc2-docstring} archivebox.config.paths._env_path
:summary:
```
* - {py:obj}`_get_collection_id <archivebox.config.paths._get_collection_id>`
- ```{autodoc2-docstring} archivebox.config.paths._get_collection_id
:summary:
```
* - {py:obj}`get_collection_id <archivebox.config.paths.get_collection_id>`
- ```{autodoc2-docstring} archivebox.config.paths.get_collection_id
:summary:
```
* - {py:obj}`get_machine_id <archivebox.config.paths.get_machine_id>`
- ```{autodoc2-docstring} archivebox.config.paths.get_machine_id
:summary:
```
* - {py:obj}`get_machine_type <archivebox.config.paths.get_machine_type>`
- ```{autodoc2-docstring} archivebox.config.paths.get_machine_type
:summary:
```
* - {py:obj}`dir_is_writable <archivebox.config.paths.dir_is_writable>`
- ```{autodoc2-docstring} archivebox.config.paths.dir_is_writable
:summary:
```
* - {py:obj}`assert_dir_can_contain_unix_sockets <archivebox.config.paths.assert_dir_can_contain_unix_sockets>`
- ```{autodoc2-docstring} archivebox.config.paths.assert_dir_can_contain_unix_sockets
:summary:
```
* - {py:obj}`create_and_chown_dir <archivebox.config.paths.create_and_chown_dir>`
- ```{autodoc2-docstring} archivebox.config.paths.create_and_chown_dir
:summary:
```
* - {py:obj}`tmp_dir_socket_path_is_short_enough <archivebox.config.paths.tmp_dir_socket_path_is_short_enough>`
- ```{autodoc2-docstring} archivebox.config.paths.tmp_dir_socket_path_is_short_enough
:summary:
```
* - {py:obj}`get_or_create_working_tmp_dir <archivebox.config.paths.get_or_create_working_tmp_dir>`
- ```{autodoc2-docstring} archivebox.config.paths.get_or_create_working_tmp_dir
:summary:
```
* - {py:obj}`get_or_create_working_lib_dir <archivebox.config.paths.get_or_create_working_lib_dir>`
- ```{autodoc2-docstring} archivebox.config.paths.get_or_create_working_lib_dir
:summary:
```
* - {py:obj}`get_data_locations <archivebox.config.paths.get_data_locations>`
- ```{autodoc2-docstring} archivebox.config.paths.get_data_locations
:summary:
```
* - {py:obj}`get_code_locations <archivebox.config.paths.get_code_locations>`
- ```{autodoc2-docstring} archivebox.config.paths.get_code_locations
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`PACKAGE_DIR <archivebox.config.paths.PACKAGE_DIR>`
- ```{autodoc2-docstring} archivebox.config.paths.PACKAGE_DIR
:summary:
```
* - {py:obj}`DATA_DIR <archivebox.config.paths.DATA_DIR>`
- ```{autodoc2-docstring} archivebox.config.paths.DATA_DIR
:summary:
```
* - {py:obj}`ARCHIVE_DIR <archivebox.config.paths.ARCHIVE_DIR>`
- ```{autodoc2-docstring} archivebox.config.paths.ARCHIVE_DIR
:summary:
```
* - {py:obj}`USERS_DIR <archivebox.config.paths.USERS_DIR>`
- ```{autodoc2-docstring} archivebox.config.paths.USERS_DIR
:summary:
```
* - {py:obj}`IN_DOCKER <archivebox.config.paths.IN_DOCKER>`
- ```{autodoc2-docstring} archivebox.config.paths.IN_DOCKER
:summary:
```
* - {py:obj}`DATABASE_FILE <archivebox.config.paths.DATABASE_FILE>`
- ```{autodoc2-docstring} archivebox.config.paths.DATABASE_FILE
:summary:
```
````
### API
````{py:data} PACKAGE_DIR
:canonical: archivebox.config.paths.PACKAGE_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.paths.PACKAGE_DIR
```
````
````{py:data} DATA_DIR
:canonical: archivebox.config.paths.DATA_DIR
:type: pathlib.Path
:value: >
'resolve(...)'
```{autodoc2-docstring} archivebox.config.paths.DATA_DIR
```
````
````{py:function} _env_path(key: str, default: pathlib.Path) -> pathlib.Path
:canonical: archivebox.config.paths._env_path
```{autodoc2-docstring} archivebox.config.paths._env_path
```
````
````{py:data} ARCHIVE_DIR
:canonical: archivebox.config.paths.ARCHIVE_DIR
:type: pathlib.Path
:value: >
'_env_path(...)'
```{autodoc2-docstring} archivebox.config.paths.ARCHIVE_DIR
```
````
````{py:data} USERS_DIR
:canonical: archivebox.config.paths.USERS_DIR
:type: pathlib.Path
:value: >
'_env_path(...)'
```{autodoc2-docstring} archivebox.config.paths.USERS_DIR
```
````
````{py:data} IN_DOCKER
:canonical: archivebox.config.paths.IN_DOCKER
:value: >
None
```{autodoc2-docstring} archivebox.config.paths.IN_DOCKER
```
````
````{py:data} DATABASE_FILE
:canonical: archivebox.config.paths.DATABASE_FILE
:value: >
None
```{autodoc2-docstring} archivebox.config.paths.DATABASE_FILE
```
````
````{py:function} _get_collection_id(DATA_DIR=DATA_DIR, force_create=False) -> str
:canonical: archivebox.config.paths._get_collection_id
```{autodoc2-docstring} archivebox.config.paths._get_collection_id
```
````
````{py:function} get_collection_id(DATA_DIR=DATA_DIR) -> str
:canonical: archivebox.config.paths.get_collection_id
```{autodoc2-docstring} archivebox.config.paths.get_collection_id
```
````
````{py:function} get_machine_id() -> str
:canonical: archivebox.config.paths.get_machine_id
```{autodoc2-docstring} archivebox.config.paths.get_machine_id
```
````
````{py:function} get_machine_type() -> str
:canonical: archivebox.config.paths.get_machine_type
```{autodoc2-docstring} archivebox.config.paths.get_machine_type
```
````
````{py:function} dir_is_writable(dir_path: pathlib.Path, uid: int | None = None, gid: int | None = None, fallback=True, chown=True) -> bool
:canonical: archivebox.config.paths.dir_is_writable
```{autodoc2-docstring} archivebox.config.paths.dir_is_writable
```
````
````{py:function} assert_dir_can_contain_unix_sockets(dir_path: pathlib.Path) -> bool
:canonical: archivebox.config.paths.assert_dir_can_contain_unix_sockets
```{autodoc2-docstring} archivebox.config.paths.assert_dir_can_contain_unix_sockets
```
````
````{py:function} create_and_chown_dir(dir_path: pathlib.Path) -> None
:canonical: archivebox.config.paths.create_and_chown_dir
```{autodoc2-docstring} archivebox.config.paths.create_and_chown_dir
```
````
````{py:function} tmp_dir_socket_path_is_short_enough(dir_path: pathlib.Path) -> bool
:canonical: archivebox.config.paths.tmp_dir_socket_path_is_short_enough
```{autodoc2-docstring} archivebox.config.paths.tmp_dir_socket_path_is_short_enough
```
````
````{py:function} get_or_create_working_tmp_dir(autofix=True, quiet=True, config: ArchiveBoxConfig | None = None, **config_kwargs)
:canonical: archivebox.config.paths.get_or_create_working_tmp_dir
```{autodoc2-docstring} archivebox.config.paths.get_or_create_working_tmp_dir
```
````
````{py:function} get_or_create_working_lib_dir(autofix=True, quiet=False, config: ArchiveBoxConfig | None = None, **config_kwargs)
:canonical: archivebox.config.paths.get_or_create_working_lib_dir
```{autodoc2-docstring} archivebox.config.paths.get_or_create_working_lib_dir
```
````
````{py:function} get_data_locations(config: ArchiveBoxConfig | None = None, **config_kwargs)
:canonical: archivebox.config.paths.get_data_locations
```{autodoc2-docstring} archivebox.config.paths.get_data_locations
```
````
````{py:function} get_code_locations(config: ArchiveBoxConfig | None = None, **config_kwargs)
:canonical: archivebox.config.paths.get_code_locations
```{autodoc2-docstring} archivebox.config.paths.get_code_locations
```
````

304
docs/apidocs/archivebox/archivebox.config.permissions.md
View File

@ -1,304 +0,0 @@
# {py:mod}`archivebox.config.permissions`
```{py:module} archivebox.config.permissions
```
```{autodoc2-docstring} archivebox.config.permissions
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`drop_privileges <archivebox.config.permissions.drop_privileges>`
- ```{autodoc2-docstring} archivebox.config.permissions.drop_privileges
:summary:
```
* - {py:obj}`SudoPermission <archivebox.config.permissions.SudoPermission>`
- ```{autodoc2-docstring} archivebox.config.permissions.SudoPermission
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`DATA_DIR <archivebox.config.permissions.DATA_DIR>`
- ```{autodoc2-docstring} archivebox.config.permissions.DATA_DIR
:summary:
```
* - {py:obj}`DEFAULT_PUID <archivebox.config.permissions.DEFAULT_PUID>`
- ```{autodoc2-docstring} archivebox.config.permissions.DEFAULT_PUID
:summary:
```
* - {py:obj}`DEFAULT_PGID <archivebox.config.permissions.DEFAULT_PGID>`
- ```{autodoc2-docstring} archivebox.config.permissions.DEFAULT_PGID
:summary:
```
* - {py:obj}`RUNNING_AS_UID <archivebox.config.permissions.RUNNING_AS_UID>`
- ```{autodoc2-docstring} archivebox.config.permissions.RUNNING_AS_UID
:summary:
```
* - {py:obj}`RUNNING_AS_GID <archivebox.config.permissions.RUNNING_AS_GID>`
- ```{autodoc2-docstring} archivebox.config.permissions.RUNNING_AS_GID
:summary:
```
* - {py:obj}`EUID <archivebox.config.permissions.EUID>`
- ```{autodoc2-docstring} archivebox.config.permissions.EUID
:summary:
```
* - {py:obj}`EGID <archivebox.config.permissions.EGID>`
- ```{autodoc2-docstring} archivebox.config.permissions.EGID
:summary:
```
* - {py:obj}`SUDO_UID <archivebox.config.permissions.SUDO_UID>`
- ```{autodoc2-docstring} archivebox.config.permissions.SUDO_UID
:summary:
```
* - {py:obj}`SUDO_GID <archivebox.config.permissions.SUDO_GID>`
- ```{autodoc2-docstring} archivebox.config.permissions.SUDO_GID
:summary:
```
* - {py:obj}`USER <archivebox.config.permissions.USER>`
- ```{autodoc2-docstring} archivebox.config.permissions.USER
:summary:
```
* - {py:obj}`HOSTNAME <archivebox.config.permissions.HOSTNAME>`
- ```{autodoc2-docstring} archivebox.config.permissions.HOSTNAME
:summary:
```
* - {py:obj}`IS_ROOT <archivebox.config.permissions.IS_ROOT>`
- ```{autodoc2-docstring} archivebox.config.permissions.IS_ROOT
:summary:
```
* - {py:obj}`IN_DOCKER <archivebox.config.permissions.IN_DOCKER>`
- ```{autodoc2-docstring} archivebox.config.permissions.IN_DOCKER
:summary:
```
* - {py:obj}`FALLBACK_UID <archivebox.config.permissions.FALLBACK_UID>`
- ```{autodoc2-docstring} archivebox.config.permissions.FALLBACK_UID
:summary:
```
* - {py:obj}`FALLBACK_GID <archivebox.config.permissions.FALLBACK_GID>`
- ```{autodoc2-docstring} archivebox.config.permissions.FALLBACK_GID
:summary:
```
* - {py:obj}`ARCHIVEBOX_USER <archivebox.config.permissions.ARCHIVEBOX_USER>`
- ```{autodoc2-docstring} archivebox.config.permissions.ARCHIVEBOX_USER
:summary:
```
* - {py:obj}`ARCHIVEBOX_GROUP <archivebox.config.permissions.ARCHIVEBOX_GROUP>`
- ```{autodoc2-docstring} archivebox.config.permissions.ARCHIVEBOX_GROUP
:summary:
```
* - {py:obj}`ARCHIVEBOX_USER_EXISTS <archivebox.config.permissions.ARCHIVEBOX_USER_EXISTS>`
- ```{autodoc2-docstring} archivebox.config.permissions.ARCHIVEBOX_USER_EXISTS
:summary:
```
````
### API
````{py:data} DATA_DIR
:canonical: archivebox.config.permissions.DATA_DIR
:value: >
'Path(...)'
```{autodoc2-docstring} archivebox.config.permissions.DATA_DIR
```
````
````{py:data} DEFAULT_PUID
:canonical: archivebox.config.permissions.DEFAULT_PUID
:value: >
911
```{autodoc2-docstring} archivebox.config.permissions.DEFAULT_PUID
```
````
````{py:data} DEFAULT_PGID
:canonical: archivebox.config.permissions.DEFAULT_PGID
:value: >
911
```{autodoc2-docstring} archivebox.config.permissions.DEFAULT_PGID
```
````
````{py:data} RUNNING_AS_UID
:canonical: archivebox.config.permissions.RUNNING_AS_UID
:value: >
'getuid(...)'
```{autodoc2-docstring} archivebox.config.permissions.RUNNING_AS_UID
```
````
````{py:data} RUNNING_AS_GID
:canonical: archivebox.config.permissions.RUNNING_AS_GID
:value: >
'getgid(...)'
```{autodoc2-docstring} archivebox.config.permissions.RUNNING_AS_GID
```
````
````{py:data} EUID
:canonical: archivebox.config.permissions.EUID
:value: >
'geteuid(...)'
```{autodoc2-docstring} archivebox.config.permissions.EUID
```
````
````{py:data} EGID
:canonical: archivebox.config.permissions.EGID
:value: >
'getegid(...)'
```{autodoc2-docstring} archivebox.config.permissions.EGID
```
````
````{py:data} SUDO_UID
:canonical: archivebox.config.permissions.SUDO_UID
:value: >
'int(...)'
```{autodoc2-docstring} archivebox.config.permissions.SUDO_UID
```
````
````{py:data} SUDO_GID
:canonical: archivebox.config.permissions.SUDO_GID
:value: >
'int(...)'
```{autodoc2-docstring} archivebox.config.permissions.SUDO_GID
```
````
````{py:data} USER
:canonical: archivebox.config.permissions.USER
:type: str
:value: >
None
```{autodoc2-docstring} archivebox.config.permissions.USER
```
````
````{py:data} HOSTNAME
:canonical: archivebox.config.permissions.HOSTNAME
:type: str
:value: >
'cast(...)'
```{autodoc2-docstring} archivebox.config.permissions.HOSTNAME
```
````
````{py:data} IS_ROOT
:canonical: archivebox.config.permissions.IS_ROOT
:value: >
None
```{autodoc2-docstring} archivebox.config.permissions.IS_ROOT
```
````
````{py:data} IN_DOCKER
:canonical: archivebox.config.permissions.IN_DOCKER
:value: >
None
```{autodoc2-docstring} archivebox.config.permissions.IN_DOCKER
```
````
````{py:data} FALLBACK_UID
:canonical: archivebox.config.permissions.FALLBACK_UID
:value: >
None
```{autodoc2-docstring} archivebox.config.permissions.FALLBACK_UID
```
````
````{py:data} FALLBACK_GID
:canonical: archivebox.config.permissions.FALLBACK_GID
:value: >
None
```{autodoc2-docstring} archivebox.config.permissions.FALLBACK_GID
```
````
````{py:data} ARCHIVEBOX_USER
:canonical: archivebox.config.permissions.ARCHIVEBOX_USER
:value: >
'int(...)'
```{autodoc2-docstring} archivebox.config.permissions.ARCHIVEBOX_USER
```
````
````{py:data} ARCHIVEBOX_GROUP
:canonical: archivebox.config.permissions.ARCHIVEBOX_GROUP
:value: >
'int(...)'
```{autodoc2-docstring} archivebox.config.permissions.ARCHIVEBOX_GROUP
```
````
````{py:data} ARCHIVEBOX_USER_EXISTS
:canonical: archivebox.config.permissions.ARCHIVEBOX_USER_EXISTS
:value: >
False
```{autodoc2-docstring} archivebox.config.permissions.ARCHIVEBOX_USER_EXISTS
```
````
````{py:function} drop_privileges()
:canonical: archivebox.config.permissions.drop_privileges
```{autodoc2-docstring} archivebox.config.permissions.drop_privileges
```
````
````{py:function} SudoPermission(uid=0, fallback=False)
:canonical: archivebox.config.permissions.SudoPermission
```{autodoc2-docstring} archivebox.config.permissions.SudoPermission
```
````

105
docs/apidocs/archivebox/archivebox.config.version.md
View File

@ -1,105 +0,0 @@
# {py:mod}`archivebox.config.version`
```{py:module} archivebox.config.version
```
```{autodoc2-docstring} archivebox.config.version
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`detect_installed_version <archivebox.config.version.detect_installed_version>`
- ```{autodoc2-docstring} archivebox.config.version.detect_installed_version
:summary:
```
* - {py:obj}`get_COMMIT_HASH <archivebox.config.version.get_COMMIT_HASH>`
- ```{autodoc2-docstring} archivebox.config.version.get_COMMIT_HASH
:summary:
```
* - {py:obj}`get_BUILD_TIME <archivebox.config.version.get_BUILD_TIME>`
- ```{autodoc2-docstring} archivebox.config.version.get_BUILD_TIME
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`IN_DOCKER <archivebox.config.version.IN_DOCKER>`
- ```{autodoc2-docstring} archivebox.config.version.IN_DOCKER
:summary:
```
* - {py:obj}`PACKAGE_DIR <archivebox.config.version.PACKAGE_DIR>`
- ```{autodoc2-docstring} archivebox.config.version.PACKAGE_DIR
:summary:
```
* - {py:obj}`VERSION <archivebox.config.version.VERSION>`
- ```{autodoc2-docstring} archivebox.config.version.VERSION
:summary:
```
````
### API
````{py:data} IN_DOCKER
:canonical: archivebox.config.version.IN_DOCKER
:value: >
None
```{autodoc2-docstring} archivebox.config.version.IN_DOCKER
```
````
````{py:data} PACKAGE_DIR
:canonical: archivebox.config.version.PACKAGE_DIR
:type: pathlib.Path
:value: >
None
```{autodoc2-docstring} archivebox.config.version.PACKAGE_DIR
```
````
````{py:function} detect_installed_version(PACKAGE_DIR: pathlib.Path = PACKAGE_DIR)
:canonical: archivebox.config.version.detect_installed_version
```{autodoc2-docstring} archivebox.config.version.detect_installed_version
```
````
````{py:function} get_COMMIT_HASH() -> str | None
:canonical: archivebox.config.version.get_COMMIT_HASH
```{autodoc2-docstring} archivebox.config.version.get_COMMIT_HASH
```
````
````{py:function} get_BUILD_TIME() -> str
:canonical: archivebox.config.version.get_BUILD_TIME
```{autodoc2-docstring} archivebox.config.version.get_BUILD_TIME
```
````
````{py:data} VERSION
:canonical: archivebox.config.version.VERSION
:type: str
:value: >
'detect_installed_version(...)'
```{autodoc2-docstring} archivebox.config.version.VERSION
```
````

431
docs/apidocs/archivebox/archivebox.config.views.md
View File

@ -1,431 +0,0 @@
# {py:mod}`archivebox.config.views`
```{py:module} archivebox.config.views
```
```{autodoc2-docstring} archivebox.config.views
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`is_superuser <archivebox.config.views.is_superuser>`
- ```{autodoc2-docstring} archivebox.config.views.is_superuser
:summary:
```
* - {py:obj}`format_parsed_datetime <archivebox.config.views.format_parsed_datetime>`
- ```{autodoc2-docstring} archivebox.config.views.format_parsed_datetime
:summary:
```
* - {py:obj}`render_code_block <archivebox.config.views.render_code_block>`
- ```{autodoc2-docstring} archivebox.config.views.render_code_block
:summary:
```
* - {py:obj}`render_highlighted_json_block <archivebox.config.views.render_highlighted_json_block>`
- ```{autodoc2-docstring} archivebox.config.views.render_highlighted_json_block
:summary:
```
* - {py:obj}`get_plugin_docs_url <archivebox.config.views.get_plugin_docs_url>`
- ```{autodoc2-docstring} archivebox.config.views.get_plugin_docs_url
:summary:
```
* - {py:obj}`get_plugin_hook_source_url <archivebox.config.views.get_plugin_hook_source_url>`
- ```{autodoc2-docstring} archivebox.config.views.get_plugin_hook_source_url
:summary:
```
* - {py:obj}`get_live_config_url <archivebox.config.views.get_live_config_url>`
- ```{autodoc2-docstring} archivebox.config.views.get_live_config_url
:summary:
```
* - {py:obj}`get_environment_binary_url <archivebox.config.views.get_environment_binary_url>`
- ```{autodoc2-docstring} archivebox.config.views.get_environment_binary_url
:summary:
```
* - {py:obj}`get_installed_binary_change_url <archivebox.config.views.get_installed_binary_change_url>`
- ```{autodoc2-docstring} archivebox.config.views.get_installed_binary_change_url
:summary:
```
* - {py:obj}`get_machine_admin_url <archivebox.config.views.get_machine_admin_url>`
- ```{autodoc2-docstring} archivebox.config.views.get_machine_admin_url
:summary:
```
* - {py:obj}`render_code_tag_list <archivebox.config.views.render_code_tag_list>`
- ```{autodoc2-docstring} archivebox.config.views.render_code_tag_list
:summary:
```
* - {py:obj}`render_plugin_metadata_html <archivebox.config.views.render_plugin_metadata_html>`
- ```{autodoc2-docstring} archivebox.config.views.render_plugin_metadata_html
:summary:
```
* - {py:obj}`render_link_tag_list <archivebox.config.views.render_link_tag_list>`
- ```{autodoc2-docstring} archivebox.config.views.render_link_tag_list
:summary:
```
* - {py:obj}`render_property_links <archivebox.config.views.render_property_links>`
- ```{autodoc2-docstring} archivebox.config.views.render_property_links
:summary:
```
* - {py:obj}`render_config_properties_html <archivebox.config.views.render_config_properties_html>`
- ```{autodoc2-docstring} archivebox.config.views.render_config_properties_html
:summary:
```
* - {py:obj}`render_hook_links_html <archivebox.config.views.render_hook_links_html>`
- ```{autodoc2-docstring} archivebox.config.views.render_hook_links_html
:summary:
```
* - {py:obj}`render_binary_detail_description <archivebox.config.views.render_binary_detail_description>`
- ```{autodoc2-docstring} archivebox.config.views.render_binary_detail_description
:summary:
```
* - {py:obj}`obj_to_yaml <archivebox.config.views.obj_to_yaml>`
- ```{autodoc2-docstring} archivebox.config.views.obj_to_yaml
:summary:
```
* - {py:obj}`_binary_sort_key <archivebox.config.views._binary_sort_key>`
- ```{autodoc2-docstring} archivebox.config.views._binary_sort_key
:summary:
```
* - {py:obj}`get_db_binaries_by_name <archivebox.config.views.get_db_binaries_by_name>`
- ```{autodoc2-docstring} archivebox.config.views.get_db_binaries_by_name
:summary:
```
* - {py:obj}`get_filesystem_plugins <archivebox.config.views.get_filesystem_plugins>`
- ```{autodoc2-docstring} archivebox.config.views.get_filesystem_plugins
:summary:
```
* - {py:obj}`binaries_list_view <archivebox.config.views.binaries_list_view>`
- ```{autodoc2-docstring} archivebox.config.views.binaries_list_view
:summary:
```
* - {py:obj}`binary_detail_view <archivebox.config.views.binary_detail_view>`
- ```{autodoc2-docstring} archivebox.config.views.binary_detail_view
:summary:
```
* - {py:obj}`plugins_list_view <archivebox.config.views.plugins_list_view>`
- ```{autodoc2-docstring} archivebox.config.views.plugins_list_view
:summary:
```
* - {py:obj}`plugin_detail_view <archivebox.config.views.plugin_detail_view>`
- ```{autodoc2-docstring} archivebox.config.views.plugin_detail_view
:summary:
```
* - {py:obj}`worker_list_view <archivebox.config.views.worker_list_view>`
- ```{autodoc2-docstring} archivebox.config.views.worker_list_view
:summary:
```
* - {py:obj}`worker_detail_view <archivebox.config.views.worker_detail_view>`
- ```{autodoc2-docstring} archivebox.config.views.worker_detail_view
:summary:
```
* - {py:obj}`log_list_view <archivebox.config.views.log_list_view>`
- ```{autodoc2-docstring} archivebox.config.views.log_list_view
:summary:
```
* - {py:obj}`log_detail_view <archivebox.config.views.log_detail_view>`
- ```{autodoc2-docstring} archivebox.config.views.log_detail_view
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`ABX_PLUGINS_DOCS_BASE_URL <archivebox.config.views.ABX_PLUGINS_DOCS_BASE_URL>`
- ```{autodoc2-docstring} archivebox.config.views.ABX_PLUGINS_DOCS_BASE_URL
:summary:
```
* - {py:obj}`ABX_PLUGINS_GITHUB_BASE_URL <archivebox.config.views.ABX_PLUGINS_GITHUB_BASE_URL>`
- ```{autodoc2-docstring} archivebox.config.views.ABX_PLUGINS_GITHUB_BASE_URL
:summary:
```
* - {py:obj}`LIVE_CONFIG_BASE_URL <archivebox.config.views.LIVE_CONFIG_BASE_URL>`
- ```{autodoc2-docstring} archivebox.config.views.LIVE_CONFIG_BASE_URL
:summary:
```
* - {py:obj}`ENVIRONMENT_BINARIES_BASE_URL <archivebox.config.views.ENVIRONMENT_BINARIES_BASE_URL>`
- ```{autodoc2-docstring} archivebox.config.views.ENVIRONMENT_BINARIES_BASE_URL
:summary:
```
* - {py:obj}`INSTALLED_BINARIES_BASE_URL <archivebox.config.views.INSTALLED_BINARIES_BASE_URL>`
- ```{autodoc2-docstring} archivebox.config.views.INSTALLED_BINARIES_BASE_URL
:summary:
```
* - {py:obj}`JSON_TOKEN_RE <archivebox.config.views.JSON_TOKEN_RE>`
- ```{autodoc2-docstring} archivebox.config.views.JSON_TOKEN_RE
:summary:
```
````
### API
````{py:data} ABX_PLUGINS_DOCS_BASE_URL
:canonical: archivebox.config.views.ABX_PLUGINS_DOCS_BASE_URL
:value: >
'https://archivebox.github.io/abx-plugins/'
```{autodoc2-docstring} archivebox.config.views.ABX_PLUGINS_DOCS_BASE_URL
```
````
````{py:data} ABX_PLUGINS_GITHUB_BASE_URL
:canonical: archivebox.config.views.ABX_PLUGINS_GITHUB_BASE_URL
:value: >
'https://github.com/ArchiveBox/abx-plugins/tree/main/abx_plugins/plugins/'
```{autodoc2-docstring} archivebox.config.views.ABX_PLUGINS_GITHUB_BASE_URL
```
````
````{py:data} LIVE_CONFIG_BASE_URL
:canonical: archivebox.config.views.LIVE_CONFIG_BASE_URL
:value: >
'/admin/environment/config/'
```{autodoc2-docstring} archivebox.config.views.LIVE_CONFIG_BASE_URL
```
````
````{py:data} ENVIRONMENT_BINARIES_BASE_URL
:canonical: archivebox.config.views.ENVIRONMENT_BINARIES_BASE_URL
:value: >
'/admin/environment/binaries/'
```{autodoc2-docstring} archivebox.config.views.ENVIRONMENT_BINARIES_BASE_URL
```
````
````{py:data} INSTALLED_BINARIES_BASE_URL
:canonical: archivebox.config.views.INSTALLED_BINARIES_BASE_URL
:value: >
'/admin/machine/binary/'
```{autodoc2-docstring} archivebox.config.views.INSTALLED_BINARIES_BASE_URL
```
````
````{py:function} is_superuser(request: django.http.HttpRequest) -> bool
:canonical: archivebox.config.views.is_superuser
```{autodoc2-docstring} archivebox.config.views.is_superuser
```
````
````{py:function} format_parsed_datetime(value: object) -> str
:canonical: archivebox.config.views.format_parsed_datetime
```{autodoc2-docstring} archivebox.config.views.format_parsed_datetime
```
````
````{py:data} JSON_TOKEN_RE
:canonical: archivebox.config.views.JSON_TOKEN_RE
:value: >
'compile(...)'
```{autodoc2-docstring} archivebox.config.views.JSON_TOKEN_RE
```
````
````{py:function} render_code_block(text: str, *, highlighted: bool = False) -> str
:canonical: archivebox.config.views.render_code_block
```{autodoc2-docstring} archivebox.config.views.render_code_block
```
````
````{py:function} render_highlighted_json_block(value: typing.Any) -> str
:canonical: archivebox.config.views.render_highlighted_json_block
```{autodoc2-docstring} archivebox.config.views.render_highlighted_json_block
```
````
````{py:function} get_plugin_docs_url(plugin_name: str) -> str
:canonical: archivebox.config.views.get_plugin_docs_url
```{autodoc2-docstring} archivebox.config.views.get_plugin_docs_url
```
````
````{py:function} get_plugin_hook_source_url(plugin_name: str, hook_name: str) -> str
:canonical: archivebox.config.views.get_plugin_hook_source_url
```{autodoc2-docstring} archivebox.config.views.get_plugin_hook_source_url
```
````
````{py:function} get_live_config_url(key: str) -> str
:canonical: archivebox.config.views.get_live_config_url
```{autodoc2-docstring} archivebox.config.views.get_live_config_url
```
````
````{py:function} get_environment_binary_url(name: str) -> str
:canonical: archivebox.config.views.get_environment_binary_url
```{autodoc2-docstring} archivebox.config.views.get_environment_binary_url
```
````
````{py:function} get_installed_binary_change_url(name: str, binary: archivebox.machine.models.Binary | None) -> str | None
:canonical: archivebox.config.views.get_installed_binary_change_url
```{autodoc2-docstring} archivebox.config.views.get_installed_binary_change_url
```
````
````{py:function} get_machine_admin_url() -> str | None
:canonical: archivebox.config.views.get_machine_admin_url
```{autodoc2-docstring} archivebox.config.views.get_machine_admin_url
```
````
````{py:function} render_code_tag_list(values: list[str]) -> str
:canonical: archivebox.config.views.render_code_tag_list
```{autodoc2-docstring} archivebox.config.views.render_code_tag_list
```
````
````{py:function} render_plugin_metadata_html(config: dict[str, typing.Any]) -> str
:canonical: archivebox.config.views.render_plugin_metadata_html
```{autodoc2-docstring} archivebox.config.views.render_plugin_metadata_html
```
````
````{py:function} render_link_tag_list(values: list[str], url_resolver: collections.abc.Callable[[str], str] | None = None) -> str
:canonical: archivebox.config.views.render_link_tag_list
```{autodoc2-docstring} archivebox.config.views.render_link_tag_list
```
````
````{py:function} render_property_links(prop_name: str, prop_info: dict[str, typing.Any], machine_admin_url: str | None) -> str
:canonical: archivebox.config.views.render_property_links
```{autodoc2-docstring} archivebox.config.views.render_property_links
```
````
````{py:function} render_config_properties_html(properties: dict[str, typing.Any], machine_admin_url: str | None) -> str
:canonical: archivebox.config.views.render_config_properties_html
```{autodoc2-docstring} archivebox.config.views.render_config_properties_html
```
````
````{py:function} render_hook_links_html(plugin_name: str, hooks: list[str], source: str) -> str
:canonical: archivebox.config.views.render_hook_links_html
```{autodoc2-docstring} archivebox.config.views.render_hook_links_html
```
````
````{py:function} render_binary_detail_description(name: str, merged: dict[str, typing.Any], db_binary: typing.Any) -> str
:canonical: archivebox.config.views.render_binary_detail_description
```{autodoc2-docstring} archivebox.config.views.render_binary_detail_description
```
````
````{py:function} obj_to_yaml(obj: typing.Any, indent: int = 0) -> str
:canonical: archivebox.config.views.obj_to_yaml
```{autodoc2-docstring} archivebox.config.views.obj_to_yaml
```
````
````{py:function} _binary_sort_key(binary: archivebox.machine.models.Binary) -> tuple[int, int, int, typing.Any]
:canonical: archivebox.config.views._binary_sort_key
```{autodoc2-docstring} archivebox.config.views._binary_sort_key
```
````
````{py:function} get_db_binaries_by_name() -> dict[str, archivebox.machine.models.Binary]
:canonical: archivebox.config.views.get_db_binaries_by_name
```{autodoc2-docstring} archivebox.config.views.get_db_binaries_by_name
```
````
````{py:function} get_filesystem_plugins() -> dict[str, dict[str, typing.Any]]
:canonical: archivebox.config.views.get_filesystem_plugins
```{autodoc2-docstring} archivebox.config.views.get_filesystem_plugins
```
````
````{py:function} binaries_list_view(request: django.http.HttpRequest, **kwargs) -> admin_data_views.typing.TableContext
:canonical: archivebox.config.views.binaries_list_view
```{autodoc2-docstring} archivebox.config.views.binaries_list_view
```
````
````{py:function} binary_detail_view(request: django.http.HttpRequest, key: str, **kwargs) -> admin_data_views.typing.ItemContext
:canonical: archivebox.config.views.binary_detail_view
```{autodoc2-docstring} archivebox.config.views.binary_detail_view
```
````
````{py:function} plugins_list_view(request: django.http.HttpRequest, **kwargs) -> admin_data_views.typing.TableContext
:canonical: archivebox.config.views.plugins_list_view
```{autodoc2-docstring} archivebox.config.views.plugins_list_view
```
````
````{py:function} plugin_detail_view(request: django.http.HttpRequest, key: str, **kwargs) -> admin_data_views.typing.ItemContext
:canonical: archivebox.config.views.plugin_detail_view
```{autodoc2-docstring} archivebox.config.views.plugin_detail_view
```
````
````{py:function} worker_list_view(request: django.http.HttpRequest, **kwargs) -> admin_data_views.typing.TableContext
:canonical: archivebox.config.views.worker_list_view
```{autodoc2-docstring} archivebox.config.views.worker_list_view
```
````
````{py:function} worker_detail_view(request: django.http.HttpRequest, key: str, **kwargs) -> admin_data_views.typing.ItemContext
:canonical: archivebox.config.views.worker_detail_view
```{autodoc2-docstring} archivebox.config.views.worker_detail_view
```
````
````{py:function} log_list_view(request: django.http.HttpRequest, **kwargs) -> admin_data_views.typing.TableContext
:canonical: archivebox.config.views.log_list_view
```{autodoc2-docstring} archivebox.config.views.log_list_view
```
````
````{py:function} log_detail_view(request: django.http.HttpRequest, key: str, **kwargs) -> admin_data_views.typing.ItemContext
:canonical: archivebox.config.views.log_detail_view
```{autodoc2-docstring} archivebox.config.views.log_detail_view
```
````

31
docs/apidocs/archivebox/archivebox.core.admin.md
View File

@ -1,31 +0,0 @@
# {py:mod}`archivebox.core.admin`
```{py:module} archivebox.core.admin
```
```{autodoc2-docstring} archivebox.core.admin
:allowtitles:
```
## Module Contents
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`register_admin <archivebox.core.admin.register_admin>`
- ```{autodoc2-docstring} archivebox.core.admin.register_admin
:summary:
```
````
### API
````{py:function} register_admin(admin_site)
:canonical: archivebox.core.admin.register_admin
```{autodoc2-docstring} archivebox.core.admin.register_admin
```
````

597
docs/apidocs/archivebox/archivebox.core.admin_archiveresults.md
View File

@ -1,597 +0,0 @@
# {py:mod}`archivebox.core.admin_archiveresults`
```{py:module} archivebox.core.admin_archiveresults
```
```{autodoc2-docstring} archivebox.core.admin_archiveresults
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`ArchiveResultInline <archivebox.core.admin_archiveresults.ArchiveResultInline>`
-
* - {py:obj}`ArchiveResultAdmin <archivebox.core.admin_archiveresults.ArchiveResultAdmin>`
-
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`_get_replay_source_url <archivebox.core.admin_archiveresults._get_replay_source_url>`
- ```{autodoc2-docstring} archivebox.core.admin_archiveresults._get_replay_source_url
:summary:
```
* - {py:obj}`build_abx_dl_display_command <archivebox.core.admin_archiveresults.build_abx_dl_display_command>`
- ```{autodoc2-docstring} archivebox.core.admin_archiveresults.build_abx_dl_display_command
:summary:
```
* - {py:obj}`build_abx_dl_replay_command <archivebox.core.admin_archiveresults.build_abx_dl_replay_command>`
- ```{autodoc2-docstring} archivebox.core.admin_archiveresults.build_abx_dl_replay_command
:summary:
```
* - {py:obj}`get_plugin_admin_url <archivebox.core.admin_archiveresults.get_plugin_admin_url>`
- ```{autodoc2-docstring} archivebox.core.admin_archiveresults.get_plugin_admin_url
:summary:
```
* - {py:obj}`render_archiveresults_list <archivebox.core.admin_archiveresults.render_archiveresults_list>`
- ```{autodoc2-docstring} archivebox.core.admin_archiveresults.render_archiveresults_list
:summary:
```
* - {py:obj}`register_admin <archivebox.core.admin_archiveresults.register_admin>`
- ```{autodoc2-docstring} archivebox.core.admin_archiveresults.register_admin
:summary:
```
````
### API
````{py:function} _get_replay_source_url(result: archivebox.core.models.ArchiveResult) -> str
:canonical: archivebox.core.admin_archiveresults._get_replay_source_url
```{autodoc2-docstring} archivebox.core.admin_archiveresults._get_replay_source_url
```
````
````{py:function} build_abx_dl_display_command(result: archivebox.core.models.ArchiveResult) -> str
:canonical: archivebox.core.admin_archiveresults.build_abx_dl_display_command
```{autodoc2-docstring} archivebox.core.admin_archiveresults.build_abx_dl_display_command
```
````
````{py:function} build_abx_dl_replay_command(result: archivebox.core.models.ArchiveResult, config=None) -> str
:canonical: archivebox.core.admin_archiveresults.build_abx_dl_replay_command
```{autodoc2-docstring} archivebox.core.admin_archiveresults.build_abx_dl_replay_command
```
````
````{py:function} get_plugin_admin_url(plugin_name: str) -> str
:canonical: archivebox.core.admin_archiveresults.get_plugin_admin_url
```{autodoc2-docstring} archivebox.core.admin_archiveresults.get_plugin_admin_url
```
````
````{py:function} render_archiveresults_list(archiveresults_qs, limit=50, config=None)
:canonical: archivebox.core.admin_archiveresults.render_archiveresults_list
```{autodoc2-docstring} archivebox.core.admin_archiveresults.render_archiveresults_list
```
````
`````{py:class} ArchiveResultInline(parent_model, admin_site)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline
Bases: {py:obj}`django.contrib.admin.TabularInline`
````{py:attribute} name
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.name
:value: >
'Archive Results Log'
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.name
```
````
````{py:attribute} model
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.model
:value: >
None
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.model
```
````
````{py:attribute} parent_model
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.parent_model
:value: >
None
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.parent_model
```
````
````{py:attribute} extra
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.extra
:value: >
0
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.extra
```
````
````{py:attribute} sort_fields
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.sort_fields
:value: >
('end_ts', 'plugin', 'output_str', 'status', 'cmd_version')
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.sort_fields
```
````
````{py:attribute} readonly_fields
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.readonly_fields
:value: >
('id', 'result_id', 'completed', 'command', 'version')
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.readonly_fields
```
````
````{py:attribute} fields
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.fields
:value: >
('start_ts', 'end_ts')
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.fields
```
````
````{py:attribute} ordering
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.ordering
:value: >
('end_ts',)
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.ordering
```
````
````{py:attribute} show_change_link
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.show_change_link
:value: >
True
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.show_change_link
```
````
````{py:method} get_parent_object_from_request(request)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.get_parent_object_from_request
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.get_parent_object_from_request
```
````
````{py:method} completed(obj)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.completed
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.completed
```
````
````{py:method} result_id(obj)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.result_id
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.result_id
```
````
````{py:method} command(obj)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.command
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.command
```
````
````{py:method} version(obj)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.version
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultInline.version
```
````
````{py:method} get_formset(request, obj=None, **kwargs)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.get_formset
````
````{py:method} get_readonly_fields(request, obj=None)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultInline.get_readonly_fields
````
`````
``````{py:class} ArchiveResultAdmin(model, admin_site)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin
Bases: {py:obj}`archivebox.base_models.admin.BaseModelAdmin`
````{py:attribute} list_select_related
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.list_select_related
:value: >
()
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.list_select_related
```
````
````{py:attribute} list_display
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.list_display
:value: >
('details_link', 'zip_link', 'created_at', 'snapshot_info', 'tags_inline', 'status_badge', 'plugin_w...
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.list_display
```
````
````{py:attribute} list_display_links
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.list_display_links
:value: >
None
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.list_display_links
```
````
````{py:attribute} sort_fields
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.sort_fields
:value: >
('id', 'created_at', 'plugin', 'status')
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.sort_fields
```
````
````{py:attribute} readonly_fields
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.readonly_fields
:value: >
('admin_actions', 'cmd', 'cmd_version', 'pwd', 'cmd_str', 'snapshot_info', 'tags_str', 'created_at',...
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.readonly_fields
```
````
````{py:attribute} search_fields
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.search_fields
:value: >
('snapshot__id', 'snapshot__url', 'snapshot__tags__name', 'snapshot__crawl_id', 'plugin', 'hook_name...
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.search_fields
```
````
````{py:attribute} autocomplete_fields
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.autocomplete_fields
:value: >
['snapshot']
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.autocomplete_fields
```
````
````{py:attribute} fieldsets
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.fieldsets
:value: >
(('Actions',), ('Snapshot',), ('Plugin',), ('Timing',), ('Command',), ('Output',))
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.fieldsets
```
````
````{py:attribute} list_filter
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.list_filter
:value: >
('status', 'plugin', 'start_ts')
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.list_filter
```
````
````{py:attribute} ordering
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.ordering
:value: >
['-start_ts']
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.ordering
```
````
````{py:attribute} list_per_page
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.list_per_page
:value: >
50
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.list_per_page
```
````
````{py:attribute} paginator
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.paginator
:value: >
None
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.paginator
```
````
````{py:attribute} save_on_top
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.save_on_top
:value: >
True
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.save_on_top
```
````
````{py:attribute} show_full_result_count
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.show_full_result_count
:value: >
False
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.show_full_result_count
```
````
````{py:attribute} actions
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.actions
:value: >
['delete_selected']
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.actions
```
````
`````{py:class} Meta
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.Meta
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.Meta
```
````{py:attribute} verbose_name
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.Meta.verbose_name
:value: >
'Archive Result'
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.Meta.verbose_name
```
````
````{py:attribute} verbose_name_plural
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.Meta.verbose_name_plural
:value: >
'Archive Results'
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.Meta.verbose_name_plural
```
````
`````
````{py:method} change_view(request, object_id, form_url='', extra_context=None)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.change_view
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.change_view
```
````
````{py:method} changelist_view(request, extra_context=None)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.changelist_view
````
````{py:method} get_queryset(request)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.get_queryset
````
````{py:method} get_search_results(request, queryset, search_term)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.get_search_results
````
````{py:method} get_snapshot_view_url(result: archivebox.core.models.ArchiveResult) -> str
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.get_snapshot_view_url
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.get_snapshot_view_url
```
````
````{py:method} get_output_view_url(result: archivebox.core.models.ArchiveResult) -> str
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.get_output_view_url
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.get_output_view_url
```
````
````{py:method} get_output_files_url(result: archivebox.core.models.ArchiveResult) -> str
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.get_output_files_url
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.get_output_files_url
```
````
````{py:method} get_output_zip_url(result: archivebox.core.models.ArchiveResult) -> str
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.get_output_zip_url
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.get_output_zip_url
```
````
````{py:method} details_link(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.details_link
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.details_link
```
````
````{py:method} zip_link(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.zip_link
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.zip_link
```
````
````{py:method} snapshot_info(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.snapshot_info
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.snapshot_info
```
````
````{py:method} tags_str(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.tags_str
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.tags_str
```
````
````{py:method} tags_inline(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.tags_inline
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.tags_inline
```
````
````{py:method} status_badge(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.status_badge
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.status_badge
```
````
````{py:method} plugin_with_icon(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.plugin_with_icon
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.plugin_with_icon
```
````
````{py:method} process_link(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.process_link
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.process_link
```
````
````{py:method} machine_link(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.machine_link
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.machine_link
```
````
````{py:method} cmd_str(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.cmd_str
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.cmd_str
```
````
````{py:method} output_display(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.output_display
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.output_display
```
````
````{py:method} output_str_display(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.output_str_display
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.output_str_display
```
````
````{py:method} admin_actions(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.admin_actions
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.admin_actions
```
````
````{py:method} output_summary(result)
:canonical: archivebox.core.admin_archiveresults.ArchiveResultAdmin.output_summary
```{autodoc2-docstring} archivebox.core.admin_archiveresults.ArchiveResultAdmin.output_summary
```
````
``````
````{py:function} register_admin(admin_site)
:canonical: archivebox.core.admin_archiveresults.register_admin
```{autodoc2-docstring} archivebox.core.admin_archiveresults.register_admin
```
````

166
docs/apidocs/archivebox/archivebox.core.admin_site.md
View File

@ -1,166 +0,0 @@
# {py:mod}`archivebox.core.admin_site`
```{py:module} archivebox.core.admin_site
```
```{autodoc2-docstring} archivebox.core.admin_site
:allowtitles:
```
## Module Contents
### Classes
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`ArchiveBoxAdmin <archivebox.core.admin_site.ArchiveBoxAdmin>`
-
````
### Functions
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`register_admin_site <archivebox.core.admin_site.register_admin_site>`
- ```{autodoc2-docstring} archivebox.core.admin_site.register_admin_site
:summary:
```
````
### Data
````{list-table}
:class: autosummary longtable
:align: left
* - {py:obj}`archivebox_admin <archivebox.core.admin_site.archivebox_admin>`
- ```{autodoc2-docstring} archivebox.core.admin_site.archivebox_admin
:summary:
```
````
### API
`````{py:class} ArchiveBoxAdmin(name='admin')
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin
Bases: {py:obj}`django.contrib.admin.AdminSite`
````{py:attribute} site_header
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin.site_header
:value: >
'ArchiveBox'
```{autodoc2-docstring} archivebox.core.admin_site.ArchiveBoxAdmin.site_header
```
````
````{py:attribute} index_title
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin.index_title
:value: >
'Admin Views'
```{autodoc2-docstring} archivebox.core.admin_site.ArchiveBoxAdmin.index_title
```
````
````{py:attribute} site_title
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin.site_title
:value: >
'Admin'
```{autodoc2-docstring} archivebox.core.admin_site.ArchiveBoxAdmin.site_title
```
````
````{py:attribute} namespace
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin.namespace
:value: >
'admin'
```{autodoc2-docstring} archivebox.core.admin_site.ArchiveBoxAdmin.namespace
```
````
````{py:method} each_context(request: django.http.HttpRequest) -> dict[str, typing.Any]
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin.each_context
````
````{py:method} _format_object_count(count: int) -> tuple[int, str, str]
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin._format_object_count
:staticmethod:
```{autodoc2-docstring} archivebox.core.admin_site.ArchiveBoxAdmin._format_object_count
```
````
````{py:method} _set_model_object_count(models_by_table: dict[str, list[dict[str, typing.Any]]], table: str, count: int, title: str | None = None) -> None
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin._set_model_object_count
```{autodoc2-docstring} archivebox.core.admin_site.ArchiveBoxAdmin._set_model_object_count
```
````
````{py:method} get_app_list(request: django.http.HttpRequest, app_label: str | None = None) -> list[admin_data_views.typing.AppDict]
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin.get_app_list
````
````{py:method} admin_data_index_view(request: django.http.HttpRequest, **kwargs: typing.Any) -> django.template.response.TemplateResponse
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin.admin_data_index_view
```{autodoc2-docstring} archivebox.core.admin_site.ArchiveBoxAdmin.admin_data_index_view
```
````
````{py:method} index(request: django.http.HttpRequest, extra_context: dict[str, typing.Any] | None = None) -> django.template.response.TemplateResponse
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin.index
````
````{py:method} get_admin_data_urls() -> list[URLResolver | URLPattern]
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin.get_admin_data_urls
```{autodoc2-docstring} archivebox.core.admin_site.ArchiveBoxAdmin.get_admin_data_urls
```
````
````{py:method} get_urls() -> list[URLResolver | URLPattern]
:canonical: archivebox.core.admin_site.ArchiveBoxAdmin.get_urls
```{autodoc2-docstring} archivebox.core.admin_site.ArchiveBoxAdmin.get_urls
```
````
`````
````{py:data} archivebox_admin
:canonical: archivebox.core.admin_site.archivebox_admin
:value: >
'ArchiveBoxAdmin(...)'
```{autodoc2-docstring} archivebox.core.admin_site.archivebox_admin
```
````
````{py:function} register_admin_site()
:canonical: archivebox.core.admin_site.register_admin_site
```{autodoc2-docstring} archivebox.core.admin_site.register_admin_site
```
````

1182
docs/apidocs/archivebox/archivebox.core.admin_snapshots.md
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More