Dockerfile for scoop

.github/dependabot.yml

@@ -1,40 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
-
-version: 2
-updates:
-  - package-ecosystem: "pip"
-    directory: "/"
-    groups:
-      python:
-        patterns:
-          - "*"
-    schedule:
-      interval: "monthly"
-  
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    groups:
-      actions:
-        patterns:
-          - "*"
-    schedule:
-      interval: "monthly"
-
-  - package-ecosystem: "npm"
-    directory: "/scripts/settings/"
-    groups:
-      actions:
-        patterns:
-          - "*"
-    schedule:
-      interval: "monthly"
-
-  - package-ecosystem: "docker"
-    # Look for a `Dockerfile` in the `root` directory
-    directory: "/"
-    # Check for updates once a week
-    schedule:
-      interval: "monthly"

.github/workflows/docker-publish.yaml

@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out the repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
@@ -33,14 +33,14 @@ jobs:
         uses: docker/setup-buildx-action@v3
 
       - name: Log in to Docker Hub
-        uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772
+        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804
+        uses: docker/metadata-action@369eb591f429131d6889c46b94e711f089e6ca96
         with:
           images: bellingcat/auto-archiver
       

.github/workflows/ruff.yaml

@@ -3,18 +3,8 @@ name: Ruff Formatting & Linting
 on:
   push:
     branches: [ main ]
-    paths-ignore:
-      - "README.md"
-      - ".github"
-      - "poetry.lock"
-      - "scripts/settings"
   pull_request:
     branches: [ main ]
-    paths-ignore:
-      - "README.md"
-      - ".github"
-      - "poetry.lock"
-      - "scripts/settings"
 
 jobs:
   build:

.github/workflows/tests-core.yaml

@@ -20,7 +20,8 @@ jobs:
       fail-fast: false
       matrix:
         python-version: ["3.10", "3.11", "3.12"]
-        os: [ubuntu-22.04, ubuntu-latest]
+        os: [ubuntu-22.04]
+        #TODO: re-enable ubuntu-latest, this is disabled as oscrypto cannot be pinned to github commit and pushed to pypi
     defaults:
       run:
         working-directory: ./
@@ -28,26 +29,16 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Install ffmpeg
-        run: sudo apt-get update && sudo apt-get install -y ffmpeg
+      - name: Install Poetry
+        run: pipx install poetry
 
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
+          cache: 'poetry'
 
-      - name: Install latest Poetry
-        run: pipx install poetry
-      
-      - name: Cache Poetry and pip artifacts
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cache/pypoetry
-            ~/.cache/pip
-          key: poetry-${{ matrix.os }}-${{ matrix.python-version }}-${{ hashFiles('**/poetry.lock') }}
-
-      - name: Install dependencies from source only
+      - name: Install dependencies
         run: poetry install --no-interaction --with dev
 
       - name: Run Core Tests

.github/workflows/tests-download.yaml

@@ -22,26 +22,16 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Install ffmpeg
-        run: sudo apt-get update && sudo apt-get install -y ffmpeg
+      - name: Install poetry
+        run: pipx install poetry
 
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
+          cache: 'poetry'
 
-      - name: Install latest Poetry
-        run: pipx install poetry
-
-      - name: Cache Poetry and pip artifacts
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cache/pypoetry
-            ~/.cache/pip
-          key: poetry-${{ matrix.os }}-${{ matrix.python-version }}-${{ hashFiles('**/poetry.lock') }}
-
-      - name: Install dependencies from source only
+      - name: Install dependencies
         run: poetry install --no-interaction --with dev
 
       - name: Run Download Tests

.gitignore

@@ -1,7 +1,6 @@
 tmp*/
 temp/
 .env*
-!.env*.example
 .DS_Store
 expmt/
 service_account.json
@@ -38,7 +37,3 @@ docs/source/modules/autogen/
 scripts/settings_page.html
 scripts/settings/src/schema.json 
 .vite
-downloaded_files
-latest_logs
-# for launch.json
-.vscode

Dockerfile

@@ -1,4 +1,4 @@
-FROM webrecorder/browsertrix-crawler:1.6.3 AS base
+FROM ubuntu:noble AS base
 
 ENV RUNNING_IN_DOCKER=1 \
     LANG=C.UTF-8 \
@@ -11,12 +11,47 @@ ENV RUNNING_IN_DOCKER=1 \
 ARG TARGETARCH
 
 # Installing system dependencies
-RUN	apt-get update && \
-    apt-get install -y --no-install-recommends gcc ffmpeg fonts-noto exiftool python3-tk 
+RUN apt-get update && \ 
+    apt install -y --no-install-recommends software-properties-common && \ 
+    add-apt-repository ppa:mozillateam/ppa && \
+	apt-get update && \
+    apt-get install -y --no-install-recommends ca-certificates build-essential python3-pip python3-dev python3-venv gcc wget ffmpeg fonts-noto exiftool \
+    fonts-arphic-ukai fonts-arphic-uming fonts-freefont-ttf fonts-gfs-neohellenic fonts-indic fonts-ipafont-mincho fonts-ipafont-gothic fonts-kacst \
+    fonts-liberation fonts-noto-cjk fonts-noto-color-emoji fonts-roboto fonts-stix fonts-thai-tlwg fonts-sil-padauk fonts-ubuntu fonts-unfonts-core fonts-wqy-zenhei \
+     && \
+	apt-get install -y --no-install-recommends firefox-esr && \
+    ln -s /usr/bin/firefox-esr /usr/bin/firefox
+
+ARG GECKODRIVER_VERSION=0.36.0
+
+RUN if [ $(uname -m) = "aarch64" ]; then \
+        GECKODRIVER_ARCH=linux-aarch64; \
+    else \
+        GECKODRIVER_ARCH=linux64; \
+    fi && \
+    wget https://github.com/mozilla/geckodriver/releases/download/v${GECKODRIVER_VERSION}/geckodriver-v${GECKODRIVER_VERSION}-${GECKODRIVER_ARCH}.tar.gz && \
+    tar -xvzf geckodriver* -C /usr/local/bin && \
+    chmod +x /usr/local/bin/geckodriver && \
+    rm geckodriver-v* && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
 
 # Poetry and runtime
 FROM base AS runtime
 
+# Download and install node + Scoop
+RUN wget -q -O - https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash \
+&& . "$HOME/.nvm/nvm.sh" \
+&& nvm install 23 && nvm use 23
+
+# Install Scoop - global install so `scoop` is available in the PATH
+RUN . "$HOME/.nvm/nvm.sh" && npm install -g @harvard-lil/scoop && \
+npx playwright install-deps chromium && \ 
+corepack enable yarn
+
+   
+
 ENV POETRY_NO_INTERACTION=1 \
     POETRY_VIRTUALENVS_IN_PROJECT=1 \
     POETRY_VIRTUALENVS_CREATE=1

README.md

@@ -1,13 +1,12 @@
 <h1 align="center">Auto Archiver</h1>
 
-[![Documentation Status](https://readthedocs.org/projects/auto-archiver/badge/?version=latest)](https://auto-archiver.readthedocs.io/en/latest/?badge=latest)
 [![PyPI version](https://badge.fury.io/py/auto-archiver.svg)](https://badge.fury.io/py/auto-archiver)
-[![Docker Image Version (latest by date)](https://img.shields.io/docker/v/bellingcat/auto-archiver?sort=semver&logo=docker&color=#69F0AE)](https://hub.docker.com/r/bellingcat/auto-archiver)
+[![Docker Image Version (latest by date)](https://img.shields.io/docker/v/bellingcat/auto-archiver?label=version&logo=docker)](https://hub.docker.com/r/bellingcat/auto-archiver)
 [![Core Test Status](https://github.com/bellingcat/auto-archiver/workflows/Core%20Tests/badge.svg)](https://github.com/bellingcat/auto-archiver/actions/workflows/tests-core.yaml)
-<!-- [![Download Test Status](https://github.com/bellingcat/auto-archiver/workflows/Download%20Tests/badge.svg)](https://github.com/bellingcat/auto-archiver/actions/workflows/tests-download.yaml) -->
-
+[![Download Test Status](https://github.com/bellingcat/auto-archiver/workflows/Download%20Tests/badge.svg)](https://github.com/bellingcat/auto-archiver/actions/workflows/tests-download.yaml)
 <!-- ![Docker Pulls](https://img.shields.io/docker/pulls/bellingcat/auto-archiver) -->
 <!-- [![PyPI download month](https://img.shields.io/pypi/dm/auto-archiver.svg)](https://pypi.python.org/pypi/auto-archiver/) -->
+<!-- [![Documentation Status](https://readthedocs.org/projects/vk-url-scraper/badge/?version=latest)](https://vk-url-scraper.readthedocs.io/en/latest/?badge=latest) -->
 
 
 

docs/scripts/scripts.py

@@ -47,6 +47,7 @@ def generate_module_docs():
 
     for module in sorted(ModuleFactory().available_modules(), key=lambda x: (x.requires_setup, x.name)):
         # generate the markdown file from the __manifest__.py file.
+
         manifest = module.manifest
         for type in manifest["type"]:
             modules_by_type.setdefault(type, []).append(module)
@@ -63,27 +64,6 @@ def generate_module_docs():
 """
         steps_str = "\n".join(f"  {t}s:\n  - {module.name}" for t in manifest["type"])
 
-        if manifest.get("autodoc_dropins"):
-            loaded_module = module.load({})
-            dropins = loaded_module.load_dropins()
-            dropin_str = "\n##### Available Dropins\n"
-            for dropin in dropins:
-                if not (ddoc := dropin.documentation()):
-                    continue
-                dropin_str += f"\n###### {ddoc.get('name', dropin.__name__)}\n\n"
-                dropin_str += f"{ddoc.get('description')}\n\n"
-                if ddoc.get("site"):
-                    dropin_str += f"**Site**: {ddoc['site']}\n\n"
-                if dauth := ddoc.get("authentication"):
-                    dropin_str += "**YAML configuration**:\n"
-                    dropin_auth_yaml = "authentication:\n...\n"
-                    for site, creds in dauth.items():
-                        dropin_auth_yaml += f"  {site}:\n"
-                        for k, v in creds.items():
-                            dropin_auth_yaml += f'    {k}: "{v}"\n'
-                    dropin_str += f"```{{code}} yaml\n{dropin_auth_yaml}...\n```\n"
-            readme_str += dropin_str
-
         if not manifest["configs"]:
             config_string = f"# No configuration options for {module.name}.*\n"
         else:

docs/source/development/testing.md

@@ -3,14 +3,14 @@
 `pytest` is used for testing. There are two main types of tests:
 
 1. 'core' tests which should be run on every change
-2. 'download' tests which hit the network. These tests will do things like make API calls (e.g. Twitter, Bluesky etc.) and should be run regularly to make sure that APIs have not changed, they take longer.
+2. 'download' tests which hit the network. These tests will do things like make API calls (e.g. Twitter, Bluesky etc.) and should be run regularly to make sure that APIs have not changed.
 
 
 ## Running Tests 
 
 1. Make sure you've installed the dev dependencies with `pytest install --with dev`
 2. Tests can be run as follows:
-```{code} bash
+```
 #### Command prefix of 'poetry run' removed here for simplicity
 # run core tests
 pytest -ra -v -m "not download"
@@ -18,15 +18,4 @@ pytest -ra -v -m "not download"
 pytest -ra -v -m "download"
 # run all tests
 pytest -ra -v
-
-
-# run a specific test file
-pytest -ra -v tests/test_file.py
-# run a specific test function
-pytest -ra -v tests/test_file.py::test_function_name
-```
-
-3. Some tests require environment variables to be set. You can use the example `.env.test.example` file as a template. Copy it to `.env.test` and fill in the required values. This file will be loaded automatically by `pytest`.
-```{code} bash
-cp .env.test.example .env.test
 ```

docs/source/flow_overview.md

@@ -8,7 +8,7 @@ The archiver archives web pages using the following workflow
 4. **Formatter** creates a report from all the archived content (HTML, PDF, ...)
 5. **Database** knows what's been archived and also stores the archive result (spreadsheet, CSV, or just the console)
 
-Each step in the workflow is handled by 'modules' that interact with the data in different ways. For example, the Twitter Extractor Module would extract information from the Twitter website. The AntiBot Module will download HTML and take screenshots of the given page. See the [core modules page](core_modules.md) for an overview of all the modules that are available.
+Each step in the workflow is handled by 'modules' that interact with the data in different ways. For example, the Twitter Extractor Module would extract information from the Twitter website. The Screenshot Enricher Module will take screenshots of the given page. See the [core modules page](core_modules.md) for an overview of all the modules that are available.
 
 Auto-archiver must have at least one module defined for each step of the workflow. This is done by setting the [configuration](installation/configurations.md) for your auto-archiver instance.
 

docs/source/how_to/04_run_instagrapi_server.md

@@ -1,169 +0,0 @@
-# InstagrAPI Server
-
-The instagram API Extractor requires access to a running instance of the InstagrAPI server. 
-We have a lightweight script with the endpoints required for our Instagram API Extractor module which you can run locally, or via Docker.
-
-
-
-⚠️ Warning: Remember that it's best not to use your own personal account for archiving. [Here's why](../installation/authentication.md#recommendations-for-authentication).
-## Quick Start: Using Docker
-
-We've provided a convenient shell script (`run_instagrapi_server.sh`) that simplifies the process of setting up and running the Instagrapi server in Docker. This script handles building the Docker image, setting up credentials, and starting the container.
-
-### 🔧 Running the script:
-
-Run this script either from the repository root or from within the `scripts/instagrapi_server` directory:
-
-```bash
-./scripts/instagrapi_server/run_instagrapi_server.sh
-```
-
-This script will:
-- Prompt for your Instagram username and password.
-- Create the necessary `.env` file.
-- Build the Docker image.
-- Start the Docker container and authenticate with Instagram, creating a session automatically.
-
-### ⏱ To run the server again later:
-```bash
-docker start ig-instasrv
-```
-
-### 🐛 Debugging:
-View logs:
-```bash
-docker logs ig-instasrv
-```
-
-
-### Overview: How the Setup Works
-
-1. You enter your Instagram credentials in a local `.env` file
-2. You run the server **once locally** to generate a session file
-3. After that, you can choose to run the server again locally or inside Docker without needing to log in again
-
----
-
-## Optional: Manual / Local Setup
-
-If you'd prefer to run the server manually (without Docker), you can follow these steps:
-
-
-1. **Navigate to the server folder (and stay there for the rest of this guide)**:
-   ```bash
-   cd scripts/instagrapi_server
-   ```
-
-2. **Create a `secrets/` folder** (if it doesn't already exist in `scripts/instagrapi_server`):
-   ```bash
-   mkdir -p secrets
-   ```
-
-3. **Create a `.env` file** inside `secrets/` with your Instagram credentials:
-   ```dotenv
-   INSTAGRAM_USERNAME="your_username"
-   INSTAGRAM_PASSWORD="your_password"
-   ```
-
-4. **Install dependencies** using the pyproject.toml file:
-  
-   ```bash
-   poetry install --no-root
-   ```
-
-5. **Run the server locally**:
-   ```bash
-   poetry run uvicorn src.instaserver:app --port 8000
-   ```
-
-6. **Watch for the message**:
-   ```
-   Login successful, session saved.
-   ```
-
-✅ Your session is now saved to `secrets/instagrapi_session.json`.
-
-### To run it again locally:
-```bash
-poetry run uvicorn src.instaserver:app --port 8000
-```
-
----
-
-## Adding the API Endpoint to Auto Archiver
-
-The server should now be running within that session, and accessible at  http://127.0.0.1:8000 
-
-You can set this in the Auto Archiver orchestration.yaml file like this:
-```yaml
-instagram_api_extractor:
-  api_endpoint: http://127.0.0.1:8000
-```
-
-
----
-
-## 2. Running the Server Again
-
-Once the session file is created, you should be able to run the server without logging in again.
-
-### To run it locally (from scripts/instagrapi_server):
-```bash
-poetry run uvicorn src.instgrapinstance.instaserver:app --port 8000
-```
-
----
-
-## 3. Running via Docker (After Setup is Complete, either locally or via the script)
-
-Once the `instagrapi_session.json` and `.env` files are set up, you can pass them Docker and it should authenticate successfully.
-
-### 🔨 Build the Docker image manually:
-```bash
-docker build -t instagrapi-server .
-```
-
-### ▶️ Run the container:
-```bash
-docker run -d \
-  --env-file secrets/.env \
-  -v "$(pwd)/secrets:/app/secrets" \
-  -p 8000:8000 \
-  --name ig-instasrv \
-  instagrapi-server
-```
-
-This passes the /secrets/ directory to docker as well as the environment variables from the `.env` file.
-
-
-
----
-
-## 4. Optional Cleanup
-
-- **Stop the Docker container**:
-  ```bash
-  docker stop ig-instasrv
-  ```
-
-- **Remove the container**:
-  ```bash
-  docker rm ig-instasrv
-  ```
-
-- **Remove the Docker image**:
-  ```bash
-  docker rmi instagrapi-server
-  ```
-
-### ⏱ To run again later:
-```bash
-docker start ig-instasrv
-```
-
----
-
-##  Notes
-
-- Never share your `.env` or `instagrapi_session.json` — these contain sensitive login data. 
-- If you want to reset your session, simply delete the `secrets/instagrapi_session.json` file and re-run the local server.

docs/source/how_to/05_upgrading_to_1_1_0.md

@@ -1,54 +0,0 @@
-# Upgrading from v1.0.1
-
-```{note} This how-to is only relevant for people who used Auto Archiver before June 2025 (versions prior to 1.1.0).
-
-If you are new to Auto Archiver, then you are already using the latest configuration format and this how-to is not relevant for you.
-```
-
-Versions 1.1.0+ of Auto Archiver has breaking changes in the configuration format, which means earlier configuration formats will not work without slight modifications.
-
-
-## Dropping `vk_extractor` module
-We have dropped the `vk_extractor` because of problems in a project we relied on. You will need to remove it from your configuration file, otherwise you will see an error like:
-
-```{code} console
-Module 'vk_extractor' not found. Are you sure it's installed/exists?
-```
-
-## Dropping `screenshot_enricher` module
-We have dropped the `screenshot_enricher` module because a new `antibot_extractor_enricher` (see below) module replaces its functionality more robustly and with less dependency hassle on geckodriver/firefox. You will need to remove it from your configuration file, otherwise you will see an error like:
-
-```{code} console
-Module 'screenshot_enricher' not found. Are you sure it's installed/exists?
-```
-
-
-## New `antibot_extractor_enricher` module and VkDropin
-We have added a new [`antibot_extractor_enricher`](../modules/autogen/extractor/antibot_extractor_enricher.md) module that uses a computer-controlled browser to extract content from websites that use anti-bot measures. You can add it to your configuration file like this:
-
-```{code} yaml
-steps:
-  extractors:
-    - antibot_extractor_enricher
-
-  # or alternatively, if you want to use it as an enricher:
-  enrichers:
-    - antibot_extractor_enricher
-```
-
-It will take a full page screenshot, a PDF capture, extract HTML source code, and any other relevant media. 
-
-It comes with Dropins that we will be adding and maintaining. 
-
-> Dropin: A module with site-specific behaviours that is loaded automatically. You don't need to add them to your configuration steps for them to run. Sometimes they need `authentication` configurations though.
-
-One such Dropin is the VkDropin which uses this automated browser to access VKontakte (VK) pages. You should add a username/password to the configuration file if you get authentication blocks from VK, to do so use the [authentication settings](authentication_how_to.md):
-
-```{code} yaml
-authentication:
-  vk.com:
-    username: your_username
-    password: your_password
-```
-
-See all available Dropins in [the source code](https://github.com/bellingcat/auto-archiver/tree/main/src/auto_archiver/modules/antibot_extractor_enricher/dropins). Usually each Dropin needs its own authentication settings, similarly to the VkDropin.

docs/source/how_to/authentication_how_to.md

@@ -106,117 +106,5 @@ Finally,Some important things to remember:
 
 ## Authenticating on XXXX site with username/password
 
-```{note} 
-This section is still under construction 🚧
+```{note} This section is still under construction 🚧
 ```
-
-
-# Proof of Origin Tokens
-
-YouTube uses **Proof of Origin Tokens (POT)** as part of its bot detection system to verify that requests originate from valid clients. If a token is missing or invalid, some videos may return errors like "Sign in to confirm you're not a bot."
-
-yt-dlp provides [a detailed guide to POTs](https://github.com/yt-dlp/yt-dlp/wiki/PO-Token-Guide).
-
-### How Auto Archiver Uses POT
-This feature is enabled for the Generic Archiver via two yt-dlp plugins:
-
-- **Client-side plugin**: [yt-dlp-get-pot](https://github.com/coletdjnz/yt-dlp-get-pot)  
-  Detects when a token is required and requests one from a provider.
-
-- **Provider plugin**: [bgutil-ytdlp-pot-provider](https://github.com/Brainicism/bgutil-ytdlp-pot-provider)  
-  Includes both a Python plugin and a **Node.js server or script** to generate the token.
-
-These are installed in our Poetry environment.
-
-### Integration Methods
-
-**Docker (Recommended)**:
-
-When running the Auto Archiver using the Docker image, we use the [Node.js token generation script](https://github.com/Brainicism/bgutil-ytdlp-pot-provider/tree/master/server).
-This is to avoid managing a separate server process, and is handled automatically inside the Docker container when needed.
-
-This is already included in the Docker image, however if you need to disable this you can set the config option `bguils_po_token_method` under the `generic_extractor` section of your `orchestration.yaml` config file to "disabled".
-```yaml
-generic_extractor:
-  bguils_po_token_method: "disabled"
-```
-
-**PyPi/ Local**:
-
-When using the Auto Archiver PyPI package, or running locally, you will need additional system requirements to run the token generation script, namely either Docker, or Node.js and Yarn.
-
-See the [bgutil-ytdlp-pot-provider](https://github.com/Brainicism/bgutil-ytdlp-pot-provider?tab=readme-ov-file#a-http-server-option) documentation for more details.
-
-⚠️WARNING⚠️: This will add the server scripts to the home directory of wherever this is running.
-
-- You can set the config option `bguils_po_token_method` under the `generic_extractor` section of your `orchestration.yaml` config file to "script" to enable the token generation script process locally.
-- Alternatively you can run the bgutil-ytdlp-pot-provider server separately using their Docker image or Node.js server.
-
-### Notes
-
-- The token generation script is only triggered when needed by yt-dlp, so it should have no effect unless YouTube requests a POT.
-- If you're running the Auto Archiver in Docker, this is set up automatically.
-- If you're running locally, you'll need to run the setup script manually or enable the feature in your config.
-- You can set up both the server and the script, and the plugin will fallback on each other if needed. This is recommended for robustness!
-
-### Configurations: 
-
-## Configurations Summary
-
-| Option     | Behavior                                                                                                                                   | Docker Default? |
-|------------| ------------------------------------------------------------------------------------------------------------------------------------------ | --------------- |
-| `auto`     | Docker: Automatically downloads and uses the token generation script. Local: Does nothing; assumes a separate server is running externally. | ✅ Yes           |
-| `script`   | Explicitly downloads and uses the token generation script, even locally.                                                                   | ❌ No            |
-| `disabled` | Disables token generation completely.                                                                                                      | ❌ No            |
-
-Example configuration:
-
- 
-```yaml
-generic_extractor:
-  # ...  
-  bguils_po_token_method: "script"
-  # For debugging add the verbose flag here:
-  ytdlp_args: "--no-abort-on-error --abort-on-error --verbose"
-
-```
-
-**Advanced Configuration:**
-
-If you change the default port of the bgutil-ytdlp-pot-provider server, you can pass the updated values using our `extractor_args` option for the gereric extractor.
-
-```yaml
-generic_extractor:
-  ytdlp_args: "--no-abort-on-error --abort-on-error --verbose"
-  ytdlp_update_interval: 5
-  bguils_po_token_method: "script"
-  extractor_args:
-    youtube:
-      getpot_bgutil_baseurl: "http://127.0.0.1:8080"
-      player_client: web,tv
-```
-For more details on this for bgutils see [here](https://github.com/Brainicism/bgutil-ytdlp-pot-provider?tab=readme-ov-file#usage)
-
-### Checking the logs
-
-To verify that the POT process working, look for the following lines in your log after adding the config option:
-
-```shell
-[GetPOT] BgUtilScript: Generating POT via script: /Users/you/bgutil-ytdlp-pot-provider/server/build/generate_once.js
-[debug] [GetPOT] BgUtilScript: Executing command to get POT via script: /Users/you/.nvm/versions/node/v20.18.0/bin/node /Users/you/bgutil-ytdlp-pot-provider/server/build/generate_once.js -v ymCMy8OflKM
-[debug] [GetPOT] BgUtilScript: stdout:
-{"poToken":"MlMxojNFhEJvUzGeHEkVRSK_luXtwcDnwSNIOgaUutqB7t99nmlNvtWgYayboopG6ZopZgmQ-6PJCWEMHv89MIiFGGlJRY25Fkwzxmia_8uYgf5AWf==","generatedAt":"2025-03-26T10:45:26.156Z","visitIdentifier":"ymCMy8OflKM"}
-[debug] [GetPOT] Fetching gvs PO Token for tv client
-```
-
-If it can't find the script or something, you'll see something like this:
-```shell
-[debug] [GetPOT] Fetching player PO Token for tv client
-WARNING: [GetPOT] BgUtilScript: Script path doesn't exist: /Users/you/bgutil-ytdlp-pot-provider/server/build/generate_once.js. Please make sure the script has been transpiled correctly.
-WARNING: [GetPOT] BgUtilHTTP: Error reaching GET http://127.0.0.1:4416/ping (caused by TransportError). Please make sure that the server is reachable at http://127.0.0.1:4416.
-[debug] [GetPOT] No player PO Token provider available for tv client
-```
-
-In this case check that the script has been transpiled correctly and is available at the path specified in the log, 
-or that the server is running and reachable.
-

docs/source/how_to/logging.md

@@ -1,6 +1,6 @@
 # Keeping Logs
 
-Auto Archiver's logs can be helpful for debugging problematic archiving processes. This guide shows you how to use the logs configuration.
+Auto Archiver's logs can be helpful for debugging problematic archiving processes. This guide shows you how to use the logs to 
 
 ## Setting up logging
 
@@ -8,10 +8,10 @@ Logging settings can be set on the command line or using the orchestration confi
 
 #### Enabling or Disabling Logging
 
-Logging to the console is enabled by default. If you want to globally disable Auto Archiver's logging, then you can set `enabled: false` in your `logging` config file:
+Logging to the console is enabled by default. If you want to globally disable Auto Archiver's logging, then you can set `enabled: false` in your `logging` config:
 
 ```{code} yaml
-:caption: orchestration.yaml
+
 ...
 logging:
    enabled: false
@@ -24,7 +24,7 @@ This will disable all logs from Auto Archiver, but it does not disable logs for
 
 #### Logging Level
 
-There are 7 logging levels in total, with 5 of them used in this tool. They are: `DEBUG`, `INFO`, `SUCCESS`, `WARNING` and `ERROR`.
+There are 7 logging levels in total, with 4 commonly used levels. They are: `DEBUG`, `INFO`, `WARNING` and `ERROR`.
 
 Change the warning level by setting the value in your orchestration config file:
 
@@ -44,7 +44,7 @@ For normal usage, it is recommended to use the `INFO` level, or if you prefer qu
 
 ### Logging to a file
 
-As default, auto-archiver will log to the console. But if you wish to store your logs for future reference, or you are running the auto-archiver from within code a implementation, then you may wish to enable file logging. This can be done by setting the `file:` config value in the logging settings.
+As default, auto-archiver will log to the console. But if you wish to store your logs for future reference, or you are running the auto-archiver from within code a implementation, then you may with to enable file logging. This can be done by setting the `file:` config value in the logging settings.
 
 **Rotation:** For file logging, you can choose to 'rotate' your log files (creating new log files) so they do not get too large. Change this by setting the 'rotation' option in your logging settings. For a full list of rotation options, see the [loguru docs](https://loguru.readthedocs.io/en/stable/overview.html#easier-file-logging-with-rotation-retention-compression).
 
@@ -57,33 +57,15 @@ logging:
     rotation: 1 day
 ```
 
-### Logging each level to a different file
-If you want to log each level to a different file, you can do this by setting the `each_level_in_separate_file:` option to `true` and also setting your `file:` name, a new file will be created for each of the 5 levels used, by appending the `0_level` name to the file like so `your_file.log.1_error`. In this case the `level:` option is ignored, and all levels will be logged. 
-
-
-```{code} yaml
-:caption: orchestration.yaml
-
-logging:
-    each_level_in_separate_file: true
-    file: /my/logs/file.log 
-```
-This will create the following files:
-- `/my/logs/file.log.1_debug`
-- `/my/logs/file.log.2_info`
-- `/my/logs/file.log.3_success`
-- `/my/logs/file.log.4_warning`
-- `/my/logs/file.log.5_error`
-
 ### Full logging example
 
-The below example logs only `DEBUG` logs to the console and to the file `/my/file.log`, rotating that file once per week:
+The below example logs only `WARNING` logs to the console and to the file `/my/file.log`, rotating that file once per week:
 
 ```{code} yaml
 :caption: orchestration.yaml
 
 logging:
-    level: DEBUG
+    level: WARNING
     file: /my/file.log
     rotation: 1 week
 ```

docs/source/how_to/new_config_format.md

@@ -71,6 +71,7 @@ The names of the actual modules have also changed, so for any extractor modules
 - `telethon_archiver` → `telethon_extractor`
 - `wacz_archiver_enricher` → `wacz_extractor_enricher`
 - `wayback_archiver_enricher` → `wayback_extractor_enricher`
+- `vk_archiver` → `vk_extractor`
 
 
 #### c) Module Renaming

docs/source/installation/authentication.md

@@ -6,15 +6,6 @@ There are two main use cases for authentication:
 * Some websites require some kind of authentication in order to view the content. Examples include Facebook, Telegram etc.
 * Some websites use anti-bot systems to block bot-like tools from accessing the website. Adding real login information to auto-archiver can sometimes bypass this.
 
-```{note}
-
-The Authentication framework currently only works with the following modules:
-* [Generic Extractor](../modules/autogen/extractor/generic_extractor.md) - the main module for extracting content from websites
-* [Antibot Extractor/Enricher](../modules/autogen/extractor/antibot_extractor_enricher.md)
-
-To authenticate for WACZ archiving, see the instructions on the [](../modules/autogen/enricher/wacz_extractor_enricher.md) page.
-```
-
 ## The Authentication Config
 
 You can save your authentication information directly inside your orchestration config file, or as a separate file (for security/multi-deploy purposes). Whether storing your settings inside the orchestration file, or as a separate file, the configuration format is the same. Currently, auto-archiver supports the following authentication types:
@@ -34,10 +25,9 @@ You can save your authentication information directly inside your orchestration
 
 ```{note} 
 
-Currently, the Username & Password, and API settings only work with the Generic and Antibot Extractors. Furthermore, many sites can still detect bots and block username/password logins. Twitter/X and YouTube are two prominent ones that block username/password logins.
+The Username & Password, and API settings only work with the Generic Extractor. Other modules (like the screenshot enricher) can only use the `cookies` options. Furthermore, many sites can still detect bots and block username/password logins. Twitter/X and YouTube are two prominent ones that block username/password logging.
 
-
-One of the 'Cookies' options is recommended for the most robust archiving, but it still isn't guaranteed to work.
+One of the 'Cookies' options is recommended for the most robust archiving.
 ```
 
 ```{code} yaml
@@ -53,12 +43,12 @@ authentication:
       username: myusername
       password: 123
     
-   facebook.com:
-      cookie: single_cookie
+    facebook.com:
+       cookie: single_cookie
 
-   othersite.com:
-      api_key: 123
-      api_secret: 1234
+    othersite.com:
+       api_key: 123
+       api_secret: 1234
   
 ```
 

docs/source/installation/example_scripts/ubuntu_24_server_install.md

@@ -1,160 +0,0 @@
-
-### Bash script for Ubuntu 24 Server install
-
-> NOTE: this script has not been tested by the maintainers and results from the personal experience of a user. It is meant as a guide and not an out of the box script, as you will see it's aimed at a custom branches, users, and features like the Geckodriver which are removed as of version 1.0.2. 
-
-This acts as a handy guide on all requirements. This is built and tested on the 29th of May 2025 on Ubuntu Server 24.04.2 LTS (which is the current latest LTS)
-
-```bash
-#!/bin/sh
-
-# I usually run steps manually as logged in with the user: dave
-# which the application runs under which makes debugging easier
-
-cd ~
-sudo apt update -y
-sudo apt upgrade -y
-
-# Clone only my latest branch
-git clone -b v1-test --single-branch https://github.com/djhmateer/auto-archiver
-
-mkdir ~/auto-archiver/secrets
-sudo chown -R dave ~/auto-archiver
-
-sudo apt update -y
-sudo apt upgrade -y
-
-## Python 3.12.3 comes with Ubuntu 24.04.2
-
-# Poetry install 2.1.3 on 2nd June 25
-curl -sSL https://install.python-poetry.org | python3 -
-
-# had to restart here.. 
-sudo reboot
-
-# C++ compiler so pdqhash will install next
-sudo apt install build-essential python3-dev -y
-
-cd auto-archiver
-
-poetry install
-
-# FFMpeg
-# 6.1.1-3ubuntu5 on 2nd June 25
-sudo apt install ffmpeg -y
-
-## Firefox
-# 139.0+build2-0ubuntu0.24.04.1~mt1 on 2nd Jun 25
-# 16th Jun - don't need anymore as using Chrome in antibot
-# cd ~
-# sudo add-apt-repository ppa:mozillateam/ppa -y
-
-# echo '
-# Package: *
-# Pin: release o=LP-PPA-mozillateam
-# Pin-Priority: 1001
-# ' | sudo tee /etc/apt/preferences.d/mozilla-firefox
-
-# echo 'Unattended-Upgrade::Allowed-Origins:: "LP-PPA-mozillateam:${distro_codename}";' | sudo tee /etc/apt/apt.conf.d/51unattended-upgrades-firefox
-
-# sudo apt install firefox -y
-
-wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
-
-# Chrome
-cd ~
-# got problems here - fixed below
-# 137.0.7151.103 on 16th Jun 2025
-sudo dpkg -i google-chrome-stable_current_amd64.deb
-
-# fix dependencies on install above
-sudo apt-get install -f
-
-# had to click a lot on UI to get going.
-# to test
-# google-chrome
-
-## Gecko driver
-# check version numbers for new ones
-# https://github.com/mozilla/geckodriver/releases/
-wget https://github.com/mozilla/geckodriver/releases/download/v0.36.0/geckodriver-v0.36.0-linux64.tar.gz
-tar -xvzf geckodriver*
-chmod +x geckodriver
-sudo mv geckodriver /usr/local/bin/
-rm geckodriver*
-
-# Fonts so selenium via firefox can render other languages eg Burmese
-sudo apt install fonts-noto -y
-
-# Docker
-# Add Docker's official GPG key:
-sudo apt-get update -y
-sudo apt-get install ca-certificates curl -y
-sudo install -m 0755 -d /etc/apt/keyrings
-sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
-sudo chmod a+r /etc/apt/keyrings/docker.asc
-
-# Add the repository to Apt sources:
-echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
-  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
-  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
-
-sudo apt-get update -y
-
-sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y
-
-# add dave user to docker group 
-sudo usermod -aG docker $USER
-
-# reboot otherwise can't pull images
-
-# https://github.com/webrecorder/browsertrix-crawler
-# https://hub.docker.com/r/webrecorder/browsertrix-crawler/tags
-# 1.6.2 on 4th Jun 2025
-docker pull webrecorder/browsertrix-crawler:latest
-
-# exif
-sudo apt install libimage-exiftool-perl -y
-
-
-## CRON run every minute
-# the cron job running as user dave will execute the shell script
-# I have many scripts running from cron_11 upwards.
-# patch in the correct number
-sudo chmod +x ~/auto-archiver/scripts/cron_15.sh
-
-# don't want service to run until a reboot otherwise problems with Gecko driver
-sudo service cron stop
-
-# runs the script every minute
-# notice put in a # to disable so will have to manually start it.
-cat <<EOT >> run-auto-archive
-#*/1 * * * * dave /home/dave/auto-archiver/scripts/cron_15.sh
-EOT
-
-sudo mv run-auto-archive /etc/cron.d
-sudo chown root /etc/cron.d/run-auto-archive
-sudo chmod 600 /etc/cron.d/run-auto-archive
-
-# Helper alias 'c' to open the above file
-echo "alias c='sudo vim /etc/cron.d/run-auto-archive'" >> ~/.bashrc
-
-# secrets folder copy
-# I run dev from:
-# \\wsl.localhost\Ubuntu-24.04\home\dave\code\auto-archiver\secrets\
-
-# orchestration.yaml - for aa config
-# service_account - for google spreadsheet
-# anon.session - for telethon so don't have to type in phone number
-# profile.tar.gz - for wacz to have a logged in profile for facebook, x.com and instagram to get data
-
-# Youtube - POT Tokens
-# https://github.com/Brainicism/bgutil-ytdlp-pot-provider
-docker run --name bgutil-provider --restart unless-stopped -d -p 4416:4416 brainicism/bgutil-ytdlp-pot-provider
-
-
-# test run
-cd ~/auto-archiver
-
-poetry run python src/auto_archiver --config secrets/orchestration-aa-demo-main.yaml
-```

docs/source/installation/faq.md

@@ -11,6 +11,7 @@ are available on the [extractors](../modules/extractor.md) page. Some sites supp
 * Twitter
 * Instagram
 * Telegram
+* VKontact
 * Tiktok
 * Bluesky
 

docs/source/installation/installation.md

@@ -51,14 +51,11 @@ After this, you're ready to set up your [your configuration file](configurations
 If using the local installation method, you will also need to install the following dependencies locally:
 
 1.[ffmpeg](https://www.ffmpeg.org/) - for handling of downloaded videos
-<!-- 2. [firefox](https://www.mozilla.org/en-US/firefox/new/) and [geckodriver](https://github.com/mozilla/geckodriver/releases) on a path folder like `/usr/local/bin` - for taking webpage screenshots with the screenshot enricher -->
-3. (optional) [fonts-noto](https://fonts.google.com/noto) to deal with multiple unicode characters during selenium screenshots: `sudo apt install fonts-noto -y`.
+2. [firefox](https://www.mozilla.org/en-US/firefox/new/) and [geckodriver](https://github.com/mozilla/geckodriver/releases) on a path folder like `/usr/local/bin` - for taking webpage screenshots with the screenshot enricher
+3. (optional) [fonts-noto](https://fonts.google.com/noto) to deal with multiple unicode characters during selenium/geckodriver's screenshots: `sudo apt install fonts-noto -y`.
 4. [Browsertrix Crawler docker image](https://hub.docker.com/r/webrecorder/browsertrix-crawler) for the WACZ enricher/archiver
 
 
-### Custom installation scripts
-- [Ubuntu 24 Server Install by @djhmateer](example_scripts/ubuntu_24_server_install.md) - a WYSIWYG example script from a user who set up the Auto Archiver on a fresh Ubuntu 24 server.
-
 
 ## Developer Install
 

docs/source/installation/setup.md

@@ -27,8 +27,8 @@ The way you run the Auto Archiver depends on how you installed it (docker instal
 If you installed Auto Archiver using docker, open up your terminal, and copy-paste / type the following command:
 
 ```bash
-docker run -it --rm -v $PWD/secrets:/app/secrets -v $PWD/local_archive:/app/local_archive bellingcat/auto-archiver -- "https://example.com/1/"
-```
+docker run -it --rm -v $PWD/secrets:/app/secrets -v $PWD/local_archive:/app/local_archive bellingcat/auto-archiver
+ ```
 
 breaking this command down:
    1. `docker run` tells docker to start a new container (an instance of the image)
@@ -42,7 +42,6 @@ breaking this command down:
        1.  `-v` same as above, this is a volume instruction
        2.  `$PWD/local_archive` is a folder `local_archive/` in case you want to archive locally and have the files accessible outside docker
        3.  `/app/local_archive` is a folder inside docker that you can reference in your orchestration.yml file 
-   6. ` -- "https://example.com/1/"` this will pass the URL to archive to the default [command line feeder](../modules/autogen/feeder/cli_feeder.md)
 
 ### Example invocations
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "auto-archiver"
-version = "1.1.0"
+version = "0.13.8"
 description = "Automatically archive links to videos, images, and social media content from Google Sheets (and more)."
 
 requires-python = ">=3.10,<3.13"
@@ -27,6 +27,7 @@ dependencies = [
     "bs4 (>=0.0.0)",
     "loguru (>=0.0.0)",
     "ffmpeg-python (>=0.0.0)",
+    "selenium (>=0.0.0)",
     "telethon (>=0.0.0)",
     "google-api-python-client (>=0.0.0)",
     "google-auth-httplib2 (>=0.0.0)",
@@ -40,24 +41,23 @@ dependencies = [
     "instaloader (>=0.0.0)",
     "tqdm (>=0.0.0)",
     "jinja2 (>=0.0.0)",
+    "pyOpenSSL (==24.2.1)",
+    "cryptography (>=41.0.0,<42.0.0)",
     "boto3 (>=1.28.0,<2.0.0)",
     "dataclasses-json (>=0.0.0)",
+    "yt-dlp (>=2025.1.26,<2026.0.0)",
     "numpy (==2.1.3)",
+    "vk-url-scraper (>=0.0.0)",
     "requests[socks] (>=0.0.0)",
     "warcio (>=0.0.0)",
     "jsonlines (>=0.0.0)",
     "pysubs2 (>=0.0.0)",
     "retrying (>=0.0.0)",
+    "tsp-client (>=0.0.0)",
+    "certvalidator (>=0.0.0)",
     "rich-argparse (>=1.6.0,<2.0.0)",
     "ruamel-yaml (>=0.18.10,<0.19.0)",
-    "rfc3161-client (>=1.0.1,<2.0.0)",
-    "cryptography (>44.0.1,<45.0.0)",
     "opentimestamps (>=0.4.5,<0.5.0)",
-    "bgutil-ytdlp-pot-provider (>=1.0.0)",
-    "yt-dlp[curl-cffi,default] (>=2025.5.22,<2026.0.0)",
-    "secretstorage (>=3.3.3,<4.0.0)",
-    "seleniumbase (>=4.36.4,<5.0.0)",
-    "pyautogui (>=0.9.54,<0.10.0)",
 ]
 
 [tool.poetry.group.dev.dependencies]

scripts/instagrapi_server/.gitignore

@@ -1,2 +0,0 @@
-secrets*
-*instagrapi_session.json

scripts/instagrapi_server/Dockerfile

@@ -1,19 +0,0 @@
-FROM python:3.12-slim
-WORKDIR /app
-
-# Install Poetry
-RUN pip install --upgrade pip
-RUN pip install poetry
-
-# Copy all source code
-COPY . .
-
-# Prevent Poetry from creating a virtual environment
-RUN poetry config virtualenvs.create false
-
-# Install dependencies
-RUN poetry install --no-root
-
-
-# Use uvicorn to run the FastAPI app
-CMD ["poetry", "run", "uvicorn", "src.instaserver:app", "--host", "0.0.0.0", "--port", "8000"]

scripts/instagrapi_server/pyproject.toml

@@ -1,18 +0,0 @@
-[project]
-name = "instaserver"
-version = "0.1.0"
-description = "A FastAPI InstagrAPI server"
-package-mode = false
-requires-python = ">=3.10"
-dependencies = [
-    "fastapi (>=0.115.12,<0.116.0)",
-    "instagrapi (>=2.1.3,<3.0.0)",
-    "uvicorn (>=0.34.0,<0.35.0)",
-    "pillow (>=11.1.0,<12.0.0)",
-    "python-dotenv (>=1.1.0,<2.0.0)"
-]
-
-
-[build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
-build-backend = "poetry.core.masonry.api"

scripts/instagrapi_server/run_instagrapi_server.sh

@@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-#
-# run_instagrapi_server.sh
-# Usage:
-#   From repo root:   ./scripts/instagrapi_server/run_instagrapi_server.sh
-#   Or from script dir: ./run_instagrapi_server.sh
-#
-
-set -e
-
-# Step 1: cd to the script's directory (contains Dockerfile and secrets/)
-cd "$(dirname "$0")" || exit 1
-
-# Create secrets/ if it doesn't exist
-if [[ ! -d "secrets" ]]; then
-  echo "Creating secrets/ directory..."
-  mkdir secrets
-fi
-
-echo "Enter your Instagram credentials to store in secrets/.env"
-read -rp "Instagram Username: " IGUSER
-read -rsp "Instagram Password: " IGPASS
-echo ""
-
-cat <<EOF > secrets/.env
-INSTAGRAM_USERNAME=$IGUSER
-INSTAGRAM_PASSWORD=$IGPASS
-EOF
-echo "Created secrets/.env with your credentials."
-
-# Build Docker image
-IMAGE_NAME="instagrapi-server"
-echo "Building Docker image '$IMAGE_NAME'..."
-docker build -t "$IMAGE_NAME" .
-
-# Run container
-CONTAINER_NAME="ig-instasrv"
-echo "Running container '$CONTAINER_NAME'..."
-docker run -d \
-  --env-file secrets/.env \
-  -v "$(pwd)/secrets:/app/secrets" \
-  -p 8000:8000 \
-  --name "$CONTAINER_NAME" \
-  "$IMAGE_NAME"
-
-echo "Done! Instagrapi server is running on port 8000."
-echo "Use 'docker logs $CONTAINER_NAME' to view logs."
-echo "Use 'docker stop $CONTAINER_NAME' and 'docker rm $CONTAINER_NAME' to stop/remove the container."

scripts/instagrapi_server/src/instaserver.py

@@ -1,157 +0,0 @@
-"""https://subzeroid.github.io/instagrapi/
-
-Run using the following command:
- uvicorn src.instgrapinstance.instaserver:app --host 0.0.0.0 --port 8000 --reload
-"""
-
-import logging
-import os
-import sys
-from dotenv import load_dotenv
-
-from fastapi import FastAPI, HTTPException
-from instagrapi import Client
-from instagrapi.exceptions import LoginRequired, BadCredentials
-
-load_dotenv(dotenv_path="secrets/.env")
-logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
-
-INSTAGRAM_USERNAME = os.getenv("INSTAGRAM_USERNAME")
-INSTAGRAM_PASSWORD = os.getenv("INSTAGRAM_PASSWORD")
-SESSION_FILE = "secrets/instagrapi_session.json"
-
-app = FastAPI()
-cl = Client()
-
-
-@app.on_event("startup")
-def startup_event():
-    """Login automatically when server starts"""
-    try:
-        login_instagram()
-    except RuntimeError as e:
-        logging.error(f"API failed to start: {e}")
-        sys.exit(1)
-
-
-def login_instagram():
-    """Ensures Instagrapi is logged in and session is persistent"""
-    if not INSTAGRAM_USERNAME or not INSTAGRAM_PASSWORD:
-        raise RuntimeError("Instagram credentials are missing.")
-
-    if os.path.exists(SESSION_FILE):
-        try:
-            cl.load_settings(SESSION_FILE)
-            cl.get_timeline_feed()
-            logging.info("Using saved session.")
-            return
-        except LoginRequired:
-            logging.info("Session expired. Logging in again...")
-
-    try:
-        cl.login(INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD)
-        cl.dump_settings(SESSION_FILE)
-        logging.info("Login successful, session saved.")
-    except BadCredentials as bc:
-        raise RuntimeError("Incorrect Instagram username or password.") from bc
-    except Exception as e:
-        raise RuntimeError(f"Login failed: {e}") from e
-
-
-@app.get("/v1/media/by/id")
-def get_media_by_id(id: str):
-    """Fetch post details by media ID"""
-    logging.info(f"Fetching media by ID: {id}")
-    try:
-        media = cl.media_info(id)
-        return media.model_dump()
-    except Exception as e:
-        logging.warning(f"Media not found for ID {id}: {e}")
-        raise HTTPException(status_code=404, detail="Post not found") from e
-
-
-@app.get("/v1/media/by/code")
-def get_media_by_code(code: str):
-    """Fetch post details by shortcode"""
-    logging.info(f"Fetching media by shortcode: {code}")
-    try:
-        media_id = cl.media_pk_from_code(code)
-        media = cl.media_info(media_id)
-        return media.model_dump()
-    except Exception as e:
-        logging.warning(f"Media not found for code {code}: {e}")
-        raise HTTPException(status_code=404, detail="Post not found") from e
-
-
-@app.get("/v2/user/tag/medias")
-def get_user_tagged_medias(user_id: str, page_id: str = None):
-    logging.info(f"Fetching tagged medias for user_id={user_id} page_id={page_id}")
-    try:
-        # Placeholder for now
-        items, next_page_id = [], None
-        return {"response": {"items": items}, "next_page_id": next_page_id}
-    except Exception as e:
-        logging.warning(f"Tagged media not found for {user_id}: {e}")
-        raise HTTPException(status_code=404, detail="Tagged media not found") from e
-
-
-@app.get("/v1/user/highlights")
-def get_user_highlights(user_id: str):
-    logging.info(f"Fetching highlights list for user_id={user_id}")
-    try:
-        highlights = cl.user_highlights(user_id)
-        return [h.model_dump() for h in highlights]
-    except Exception as e:
-        logging.warning(f"Highlights not found for {user_id}: {e}")
-        raise HTTPException(status_code=404, detail="No highlights found") from e
-
-
-@app.get("/v2/highlight/by/id")
-def get_highlight_by_id(id: str):
-    logging.info(f"Fetching highlight details for id={id}")
-    try:
-        highlight = cl.highlight_info(id)
-        return {"response": {"reels": {f"highlight:{id}": highlight.model_dump()}}}
-    except Exception as e:
-        logging.warning(f"Highlight not found for id {id}: {e}")
-        raise HTTPException(status_code=404, detail="Highlight not found") from e
-
-
-@app.get("/v1/user/stories/by/username")
-def get_stories(username: str):
-    logging.info(f"Fetching stories for username={username}")
-    try:
-        user_id = cl.user_id_from_username(username)
-        stories = cl.user_stories(user_id)
-        return [story.model_dump() for story in stories]
-    except Exception as e:
-        logging.warning(f"Stories not found for {username}: {e}")
-        raise HTTPException(status_code=404, detail="Stories not found") from e
-
-
-@app.get("/v2/user/by/username")
-def get_user_by_username(username: str):
-    logging.info(f"Fetching user profile for username={username}")
-    try:
-        user = cl.user_info_by_username(username)
-        return {"user": user.model_dump()}
-    except Exception as e:
-        logging.warning(f"User not found: {username}: {e}")
-        raise HTTPException(status_code=404, detail="User not found") from e
-
-
-@app.get("/v1/user/medias/chunk")
-def get_user_medias(user_id: str, end_cursor: str = None):
-    logging.info(f"Fetching paginated medias for user_id={user_id}, end_cursor={end_cursor}")
-    try:
-        posts, next_cursor = cl.user_medias_paginated(user_id, end_cursor=end_cursor)
-        return [[post.model_dump() for post in posts], next_cursor]
-    except Exception as e:
-        logging.warning(f"No posts found for user_id={user_id}: {e}")
-        raise HTTPException(status_code=404, detail="No posts found") from e
-
-
-if __name__ == "__main__":
-    import uvicorn
-
-    uvicorn.run(app, host="0.0.0.0", port=8000)

scripts/settings/package.json

@@ -13,10 +13,10 @@
     "@dnd-kit/sortable": "^10.0.0",
     "@emotion/react": "latest",
     "@emotion/styled": "latest",
-    "@mui/icons-material": "^7.1.1",
+    "@mui/icons-material": "^6.4.7",
     "@mui/material": "latest",
-    "react": "19.1.0",
-    "react-dom": "19.1.0",
+    "react": "19.0.0",
+    "react-dom": "19.0.0",
     "react-markdown": "^10.0.0",
     "yaml": "^2.7.0"
   },

src/auto_archiver/core/base_module.py

@@ -98,11 +98,12 @@ class BaseModule(ABC):
         """
         # TODO: think about if/how we can deal with sites that have multiple domains (main one is x.com/twitter.com)
         # for now the user must enter them both, like "x.com,twitter.com" in their config. Maybe we just hard-code?
-        domain = UrlUtil.domain_for_url(site).removeprefix("www.")
+
+        site = UrlUtil.domain_for_url(site).removeprefix("www.")
         # add the 'www' version of the site to the list of sites to check
         authdict = {}
 
-        for to_try in [site, domain, f"www.{domain}"]:
+        for to_try in [site, f"www.{site}"]:
             if to_try in self.authentication:
                 authdict.update(self.authentication[to_try])
                 break
@@ -110,9 +111,9 @@ class BaseModule(ABC):
         # do a fuzzy string match just to print a warning - don't use it since it's insecure
         if not authdict:
             for key in self.authentication.keys():
-                if key in domain or domain in key:
+                if key in site or site in key:
                     logger.debug(
-                        f"Could not find exact authentication information for '{domain}'. \
+                        f"Could not find exact authentication information for site '{site}'. \
 did find information for '{key}' which is close, is this what you meant? \
 If so, edit your authentication settings to make sure it exactly matches."
                     )

src/auto_archiver/core/extractor.py

@@ -8,7 +8,6 @@ Factory method to initialize an extractor instance based on its name.
 
 from __future__ import annotations
 from abc import abstractmethod
-from contextlib import suppress
 import mimetypes
 import os
 import requests
@@ -17,7 +16,6 @@ from retrying import retry
 import re
 
 from auto_archiver.core import Metadata, BaseModule
-from auto_archiver.utils.url import get_media_url_best_quality
 
 
 class Extractor(BaseModule):
@@ -72,22 +70,10 @@ class Extractor(BaseModule):
         return ""
 
     @retry(wait_random_min=500, wait_random_max=3500, stop_max_attempt_number=5)
-    def download_from_url(self, url: str, to_filename: str = None, verbose=True, try_best_quality=False) -> str:
+    def download_from_url(self, url: str, to_filename: str = None, verbose=True) -> str:
         """
         downloads a URL to provided filename, or inferred from URL, returns local filename
-        Warning: if try_best_quality is True, it will return a tuple of (filename, best_quality_url) if the download was successful.
         """
-        if any(url.startswith(x) for x in ["blob:", "data:"]):
-            return None, url if try_best_quality else None
-
-        if try_best_quality:
-            with suppress(Exception):
-                # Attempt to download the original URL
-                best_quality_url = get_media_url_best_quality(url)
-                orig_download = self.download_from_url(best_quality_url, to_filename, verbose)
-                if orig_download:
-                    return orig_download, best_quality_url
-
         if not to_filename:
             to_filename = url.split("/")[-1].split("?")[0]
             if len(to_filename) > 64:
@@ -112,14 +98,10 @@ class Extractor(BaseModule):
             with open(to_filename, "wb") as f:
                 for chunk in d.iter_content(chunk_size=8192):
                     f.write(chunk)
-            if try_best_quality:
-                return to_filename, url
             return to_filename
 
         except requests.RequestException as e:
-            logger.warning(f"Failed to fetch the Media URL: {str(e)[:250]}")
-        if try_best_quality:
-            return None, url
+            logger.warning(f"Failed to fetch the Media URL: {e}")
 
     @abstractmethod
     def download(self, item: Metadata) -> Metadata | False:

src/auto_archiver/core/media.py

@@ -116,7 +116,7 @@ class Media:
         # self.is_video() should be used together with this method
         try:
             streams = ffmpeg.probe(self.filename, select_streams="v")["streams"]
-            logger.debug(f"STREAMS FOR {self.filename} {streams}")
+            logger.warning(f"STREAMS FOR {self.filename} {streams}")
             return any(s.get("duration_ts", 0) > 0 for s in streams)
         except Error:
             return False  # ffmpeg errors when reading bad files

src/auto_archiver/core/metadata.py

@@ -96,7 +96,7 @@ class Metadata:
 
     def is_empty(self) -> bool:
         meaningfull_ids = set(self.metadata.keys()) - set(
-            ["_processed_at", "url", "original_url", "total_bytes", "total_size", "archive_duration_seconds"]
+            ["_processed_at", "url", "total_bytes", "total_size", "archive_duration_seconds"]
         )
         return not self.is_success() and len(self.media) == 0 and len(meaningfull_ids) == 0
 

src/auto_archiver/core/module.py

@@ -214,8 +214,11 @@ class LazyBaseModule:
 
         # check external dependencies are installed
         def check_deps(deps, check):
-            for dep in filter(lambda d: len(d.strip()) > 0, deps):
-                if not check(dep.strip()):
+            for dep in deps:
+                if not len(dep):
+                    # clear out any empty strings that a user may have erroneously added
+                    continue
+                if not check(dep):
                     logger.error(
                         f"Module '{self.name}' requires external dependency '{dep}' which is not available/setup. \
                                  Have you installed the required dependencies for the '{self.name}' module? See the documentation for more information."
@@ -274,9 +277,6 @@ class LazyBaseModule:
         # finally, get the class instance
         instance: BaseModule = getattr(sys.modules[sub_qualname], class_name)()
 
-        # save the instance for future easy loading
-        self._instance = instance
-
         # set the name, display name and module factory
         instance.name = self.name
         instance.display_name = self.display_name
@@ -289,6 +289,8 @@ class LazyBaseModule:
         instance.config_setup(config)
         instance.setup()
 
+        # save the instance for future easy loading
+        self._instance = instance
         return instance
 
     def __repr__(self):

src/auto_archiver/core/orchestrator.py

@@ -5,7 +5,6 @@ formatting, database operations and clean up.
 """
 
 from __future__ import annotations
-from packaging import version
 from typing import Generator, Union, List, Type, TYPE_CHECKING
 import argparse
 import os
@@ -34,7 +33,7 @@ from .config import (
 from .module import ModuleFactory, LazyBaseModule
 from . import validators, Feeder, Extractor, Database, Storage, Formatter, Enricher
 from .consts import MODULE_TYPES, SetupError
-from auto_archiver.utils.url import check_url_or_raise, clean
+from auto_archiver.utils.url import check_url_or_raise
 
 if TYPE_CHECKING:
     from .base_module import BaseModule
@@ -249,7 +248,7 @@ Here's how that would look: \n\nsteps:\n  extractors:\n  - [your_extractor_name_
             action="store",
             dest="logging.level",
             choices=["INFO", "DEBUG", "ERROR", "WARNING"],
-            help="the logging level to use for the standard output and file logging",
+            help="the logging level to use",
             default="INFO",
             type=str.upper,
         )
@@ -264,14 +263,6 @@ Here's how that would look: \n\nsteps:\n  extractors:\n  - [your_extractor_name_
             default=None,
         )
 
-        parser.add_argument(
-            "--logging.each_level_in_separate_file",
-            action="store",
-            dest="logging.each_level_in_separate_file",
-            help="if set, writes each logging level to a separate file (ignores --logging.level), you must also set --logging.file. Each level will have a dedicate logs file matching your <file>.debug, <file>.info, etc.",
-            default=False,
-        )
-
     def add_individual_module_args(
         self, modules: list[LazyBaseModule] = None, parser: argparse.ArgumentParser = None
     ) -> None:
@@ -341,24 +332,11 @@ Here's how that would look: \n\nsteps:\n  extractors:\n  - [your_extractor_name_
 
         # add other logging info
         if self.logger_id is None:  # note - need direct comparison to None since need to consider falsy value 0
-            use_level = logging_config["level"]
-            self.logger_id = logger.add(sys.stderr, level=use_level)
-
-            rotation = logging_config["rotation"]
-            log_file = logging_config["file"]
-
-            if logging_config.get("each_level_in_separate_file"):
-                assert logging_config["file"], (
-                    "You must set --logging.file if you want to use --logging.each_level_in_separate_file"
+            self.logger_id = logger.add(sys.stderr, level=logging_config["level"])
+            if log_file := logging_config["file"]:
+                logger.add(log_file) if not logging_config["rotation"] else logger.add(
+                    log_file, rotation=logging_config["rotation"]
                 )
-                for i, level in enumerate(["DEBUG", "INFO", "SUCCESS", "WARNING", "ERROR"], start=1):
-                    logger.add(
-                        f"{log_file}.{i}_{level.lower()}",
-                        filter=lambda rec, lvl=level: rec["level"].name == lvl,
-                        rotation=rotation,
-                    )
-            elif log_file:
-                logger.add(log_file, rotation=rotation, level=use_level)
 
     def install_modules(self, modules_by_type):
         """
@@ -409,10 +387,8 @@ Here's how that would look: \n\nsteps:\n  extractors:\n  - [your_extractor_name_
                 except (KeyboardInterrupt, Exception) as e:
                     if not isinstance(e, KeyboardInterrupt) and not isinstance(e, SetupError):
                         logger.error(f"Error during setup of modules: {e}\n{traceback.format_exc()}")
-
-                    # access the _instance here because loaded_module may not return if there's an error
-                    if lazy_module._instance and module_type == "extractor":
-                        lazy_module._instance.cleanup()
+                    if loaded_module and module_type == "extractor":
+                        loaded_module.cleanup()
                     raise e
 
                 if not loaded_module:
@@ -458,19 +434,16 @@ Here's how that would look: \n\nsteps:\n  extractors:\n  - [your_extractor_name_
 
     def check_for_updates(self):
         response = requests.get("https://pypi.org/pypi/auto-archiver/json").json()
-        latest_version = version.parse(response["info"]["version"])
-        current_version = version.parse(__version__)
+        latest_version = response["info"]["version"]
         # check version compared to current version
-        if latest_version > current_version:
+        if latest_version != __version__:
             if os.environ.get("RUNNING_IN_DOCKER"):
                 update_cmd = "`docker pull bellingcat/auto-archiver:latest`"
             else:
                 update_cmd = "`pip install --upgrade auto-archiver`"
             logger.warning("")
             logger.warning("********* IMPORTANT: UPDATE AVAILABLE ********")
-            logger.warning(
-                f"A new version of auto-archiver is available (v{latest_version}, you have v{current_version})"
-            )
+            logger.warning(f"A new version of auto-archiver is available (v{latest_version}, you have {__version__})")
             logger.warning(f"Make sure to update to the latest version using: {update_cmd}")
             logger.warning("")
 
@@ -537,7 +510,7 @@ Here's how that would look: \n\nsteps:\n  extractors:\n  - [your_extractor_name_
                 yield self.feed_item(item)
                 url_count += 1
 
-        logger.info(f"Processed {url_count} URL(s)")
+        logger.success(f"Processed {url_count} URL(s)")
         self.cleanup()
 
     def feed_item(self, item: Metadata) -> Metadata:
@@ -593,13 +566,12 @@ Here's how that would look: \n\nsteps:\n  extractors:\n  - [your_extractor_name_
             raise e
 
         # 1 - sanitize - each archiver is responsible for cleaning/expanding its own URLs
-        url = clean(original_url)
+        url = original_url
         for a in self.extractors:
             url = a.sanitize_url(url)
 
         result.set_url(url)
         if original_url != url:
-            logger.debug(f"Sanitized URL from {original_url} to {url}")
             result.set("original_url", original_url)
 
         # 2 - notify start to DBs, propagate already archived if feature enabled in DBs

src/auto_archiver/core/validators.py

@@ -4,6 +4,12 @@ import argparse
 import json
 
 
+def example_validator(value):
+    if "example" not in value:
+        raise argparse.ArgumentTypeError(f"{value} is not a valid value for this argument")
+    return value
+
+
 def positive_number(value):
     if value < 0:
         raise argparse.ArgumentTypeError(f"{value} is not a positive number")

src/auto_archiver/modules/antibot_extractor_enricher/__manifest__.py

@@ -1,53 +0,0 @@
-{
-    "name": "Antibot Extractor/Enricher",
-    "type": ["extractor", "enricher"],
-    "requires_setup": False,
-    "dependencies": {"python": ["loguru", "seleniumbase", "yt_dlp"], "bin": ["ffmpeg"]},
-    "configs": {
-        "save_to_pdf": {
-            "default": False,
-            "type": "bool",
-            "help": "save a PDF snapshot of the page.",
-        },
-        "max_download_images": {
-            "default": 50,
-            "help": "maximum number of images to download from the page (0 = no download, inf = no limit).",
-        },
-        "max_download_videos": {
-            "default": 50,
-            "help": "maximum number of videos to download from the page (0 = no download, inf = no limit).",
-        },
-        "user_data_dir": {
-            "default": "secrets/antibot_user_data",
-            "help": "Path to the user data directory for the webdriver. This is used to persist browser state, such as cookies and local storage. If you use the docker deployment, this path will be appended with `_docker` that is because the folder cannot be shared between the host and the container due to user permissions.",
-        },
-        "detect_auth_wall": {
-            "default": True,
-            "type": "bool",
-            "help": "detect if the page is behind an authentication wall (e.g. login required) and skip it. disable if you want to archive pages where logins are required.",
-        },
-        "proxy": {
-            "default": None,
-            "help": "proxy to use for the webdriver, Format: 'SERVER:PORT' or 'USER:PASS@SERVER:PORT'",
-        },
-    },
-    "autodoc_dropins": True,
-    "description": """
-    Uses a browser controlled by SeleniumBase to capture HTML, media, and screenshots/PDFs of a web page, by bypassing anti-bot measures like Cloudflare's Turnstile or Google Recaptcha.
-	
-	> ⚠️ Still in trial development, please report any issues or suggestions via [GitHub Issues](https://github.com/bellingcat/auto-archiver/issues).
-	
-    ### Features
-	- Extracts the HTML source code of the page.
-    - Takes full-page screenshots of web pages.
-	- Takes full-page PDF snapshots of web pages.
-	- Downloads images and videos from the page, excluding specified file extensions.
-
-    ### Notes
-	- Using a proxy affects Cloudflare Turnstile captcha handling, so it is recommended to use a proxy only if necessary.
-
-	### Dropins
-	This module uses sub-modules called Dropins for specific sites that allow it to handle anti-bot measures and custom Login flows. You don't need to include the dropins in your configuration, but you do need to add authentication credentials if you want to overcome login walls on those sites, see detailed instructions for each Dropin below.
-
-    """,
-}

src/auto_archiver/modules/antibot_extractor_enricher/antibot_extractor_enricher.py

@@ -1,293 +0,0 @@
-import base64
-import math
-import os
-import sys
-import traceback
-from urllib.parse import urljoin
-import glob
-import importlib.util
-
-from loguru import logger
-import selenium
-from seleniumbase import SB
-
-from auto_archiver.core import Extractor, Enricher, Metadata, Media
-from auto_archiver.modules.antibot_extractor_enricher.dropin import Dropin
-from auto_archiver.modules.antibot_extractor_enricher.dropins.default import DefaultDropin
-from auto_archiver.utils.misc import random_str
-from auto_archiver.utils.url import is_relevant_url
-
-
-class AntibotExtractorEnricher(Extractor, Enricher):
-    def setup(self) -> None:
-        self.agent = "cool"
-        if "linux" in sys.platform or "win32" in sys.platform:
-            self.agent = None  # Use the default UserAgent
-
-        # parse configuration options
-        if self.max_download_images == "inf":
-            self.max_download_images = math.inf
-        else:
-            self.max_download_images = int(self.max_download_images)
-
-        if self.max_download_videos == "inf":
-            self.max_download_videos = math.inf
-        else:
-            self.max_download_videos = int(self.max_download_videos)
-
-        self._prepare_user_data_dir()
-
-        self.dropins = self.load_dropins()
-
-    def load_dropins(self):
-        dropins = []
-
-        # TODO: add user-configurable drop-ins via config like generic_extractor
-        dropins_dir = os.path.join(os.path.dirname(__file__), "dropins")
-        for file_path in glob.glob(os.path.join(dropins_dir, "*.py")):
-            if os.path.basename(file_path).startswith("_"):
-                continue  # skip __init__.py or private modules
-            module_name = f"auto_archiver.modules.antibot_extractor_enricher.dropins.{os.path.splitext(os.path.basename(file_path))[0]}"
-            spec = importlib.util.spec_from_file_location(module_name, file_path)
-            module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(module)
-            for attr in dir(module):
-                obj = getattr(module, attr)
-                if getattr(obj, "__module__", None) != module.__name__:
-                    continue  # Skip imported modules/classes/functions
-                if isinstance(obj, type) and issubclass(obj, Dropin):
-                    dropins.append(obj)
-        logger.debug(f"ANTIBOT loaded drop-in classes: {', '.join([d.__name__ for d in dropins])}")
-        return dropins
-
-    def sanitize_url(self, url: str) -> str:
-        for dropin in self.dropins:
-            if dropin.suitable(url):
-                return dropin.sanitize_url(url)
-        return url
-
-    def download(self, item: Metadata) -> Metadata:
-        result = Metadata()
-        result.merge(item)
-        if self.enrich(result):
-            result.status = "antibot"
-            return result
-
-    def _prepare_user_data_dir(self):
-        if self.user_data_dir:
-            in_docker = os.environ.get("RUNNING_IN_DOCKER")
-            if in_docker:
-                self.user_data_dir = self.user_data_dir.rstrip(os.path.sep) + "_docker"
-            os.makedirs(self.user_data_dir, exist_ok=True)
-
-    def enrich(self, to_enrich: Metadata, custom_data_dir: bool = True) -> bool:
-        using_user_data_dir = self.user_data_dir if custom_data_dir else None
-        url = to_enrich.get_url()
-        url_sample = url[:75]
-
-        try:
-            with SB(uc=True, agent=self.agent, headed=None, user_data_dir=using_user_data_dir, proxy=self.proxy) as sb:
-                logger.info(f"ANTIBOT selenium browser is up with agent {self.agent}, opening {url_sample}...")
-                sb.uc_open_with_reconnect(url, 4)
-
-                logger.debug(f"ANTIBOT handling CAPTCHAs for {url_sample}...")
-                sb.uc_gui_handle_cf()
-                sb.uc_gui_click_rc()  # NB: using handle instead of click breaks some sites like reddit, for now we separate here but can have dropins deciding this in the future
-
-                dropin = self._get_suitable_dropin(url, sb)
-                dropin.open_page(url)
-
-                if self.detect_auth_wall and self._hit_auth_wall(sb):
-                    logger.warning(f"ANTIBOT SKIP since auth wall or CAPTCHA was detected for {url_sample}")
-                    return False
-
-                sb.wait_for_ready_state_complete()
-                sb.sleep(1)  # margin for the page to load completely
-
-                to_enrich.set_title(sb.get_title())
-                self._enrich_html_source_code(sb, to_enrich)
-
-                self._enrich_full_page_screenshot(sb, to_enrich)
-                if self.save_to_pdf:
-                    self._enrich_full_page_pdf(sb, to_enrich)
-
-                downloaded_images, downloaded_videos = dropin.add_extra_media(to_enrich)
-
-                self._enrich_download_media(
-                    sb,
-                    to_enrich,
-                    js_css_selector=dropin.js_for_image_css_selectors(),
-                    max_media=self.max_download_images - downloaded_images,
-                )
-                self._enrich_download_media(
-                    sb,
-                    to_enrich,
-                    js_css_selector=dropin.js_for_video_css_selectors(),
-                    max_media=self.max_download_videos - downloaded_videos,
-                )
-                logger.info(f"ANTIBOT completed for {url_sample}")
-
-            return to_enrich
-        except selenium.common.exceptions.SessionNotCreatedException as e:
-            if custom_data_dir:  # the retry logic only works once
-                logger.error(
-                    f"ANTIBOT session not created error: {e}. Please remove the user_data_dir {self.user_data_dir} and try again, will retry without user data dir though."
-                )
-                return self.enrich(to_enrich, custom_data_dir=False)
-            raise e  # re-raise
-        except Exception as e:
-            logger.error(f"ANTIBOT runtime error: {e}: {traceback.format_exc()}")
-            return False
-
-    def _get_suitable_dropin(self, url: str, sb: SB):
-        """
-        Returns a suitable drop-in for the given URL.
-        This method checks if the URL is suitable for any of the registered drop-ins.
-        """
-        for dropin in self.dropins:
-            if dropin.suitable(url):
-                logger.debug(f"ANTIBOT using drop-in {dropin.__name__} for {url}")
-                return dropin(sb, self)
-
-        return DefaultDropin(sb, self)
-
-    def _hit_auth_wall(self, sb: SB) -> bool:
-        """
-        Tries to detect if the currently loaded page is an auth/login wall.
-        Returns True if login is likely required.
-        """
-        # TODO: improve this detection logic, currently it is very basic and may not cover all cases
-
-        # Common URL patterns
-        current_url = sb.get_current_url().lower()
-        if any(kw in current_url for kw in ["login", "signin", "signup", "register", "captcha"]):
-            return True
-
-        # Common visible text markers
-        login_keywords = [
-            "sign up or log in",
-            "log in to continue",
-            "sign in to continue",
-            "login required",
-            "please log in",
-            "please sign up",
-            "please sign in",
-            "login to access",
-            "sign up to access",
-            "register to access",
-            "captcha verification",
-        ]
-        for word in login_keywords + [w.capitalize() for w in login_keywords]:
-            if sb.is_text_visible(word):
-                return True
-
-        # Common title markers
-        title = sb.get_title().lower()
-        if any(
-            kw in title
-            for kw in [
-                "just a moment...",
-                "tiktok - make your day",
-                "um momento...",
-                "log in",
-                "sign in",
-                "sign up",
-                "register",
-                "captcha",
-                "verification required",
-                "access denied",
-            ]
-        ):
-            return True
-
-        # Common form fields
-        elements = [
-            "input[type='password']",
-            "input[type='email']",
-            "input[type='username']",
-            "input[type='phone']",
-            "input[name='username']",
-            "input[name='email']",
-            "input[name='password']",
-            "input[name='login']",
-        ]
-        if any(sb.is_element_visible(el) for el in elements):
-            return True
-
-        return False
-
-    @logger.catch
-    def _enrich_html_source_code(self, sb: SB, to_enrich: Metadata):
-        """
-        Enriches the HTML source code of the Metadata object.
-        This method is called by the enrich method.
-        """
-        source = sb.get_page_source()
-
-        html_filename = os.path.join(self.tmp_dir, f"source{random_str(6)}.html")
-        with open(html_filename, "w", encoding="utf-8") as f:
-            f.write(source)
-
-        to_enrich.add_media(Media(filename=html_filename), id="html_source_code")
-
-    @logger.catch
-    def _enrich_full_page_screenshot(self, sb: SB, to_enrich: Metadata):
-        """
-        Enriches the full page screenshot of the Metadata object.
-        This method is called by the enrich method.
-        """
-        start_size = sb.get_window_size()
-        w, h = start_size["width"], start_size["height"]
-
-        x = max(sb.execute_script("return document.documentElement.scrollWidth"), w)
-        y = min(max(sb.execute_script("return document.documentElement.scrollHeight"), h), 25_000)
-        logger.debug(f"Setting window size to {x}x{y} for full page screenshot.")
-        sb.set_window_size(x, y)
-
-        screen_filename = os.path.join(self.tmp_dir, f"screenshot{random_str(6)}.png")
-        sb.save_screenshot(screen_filename)
-
-        to_enrich.add_media(Media(filename=screen_filename), id="screenshot")
-
-    @logger.catch
-    def _enrich_full_page_pdf(self, sb: SB, to_enrich: Metadata):
-        """
-        Enriches the full page PDF of the Metadata object.
-        This method is called by the enrich method.
-        """
-        result = sb.driver.execute_cdp_cmd("Page.printToPDF", {"printBackground": True, "landscape": False})
-
-        pdf_data = base64.b64decode(result["data"])
-
-        pdf_filename = os.path.join(self.tmp_dir, f"pdf{random_str(6)}.pdf")
-        with open(pdf_filename, "wb") as f:
-            f.write(pdf_data)
-
-        to_enrich.add_media(Media(filename=pdf_filename), id="pdf")
-
-    @logger.catch
-    def _enrich_download_media(self, sb: SB, to_enrich: Metadata, js_css_selector: str, max_media: int):
-        """
-        Downloads media from the page and adds them to the Metadata object.
-        This method is called by the enrich method.
-        """
-        if max_media == 0:
-            return
-        url = to_enrich.get_url()
-        all_urls = set()
-
-        sources = sb.execute_script(js_css_selector)
-        # js_for_css_selectors
-        for src in sources:
-            if len(all_urls) >= max_media:
-                logger.debug(f"Reached max download limit of {max_media} images/videos.")
-                break
-            if not is_relevant_url(src):
-                continue
-            full_src = urljoin(url, src)
-            if full_src not in all_urls:
-                filename, full_src = self.download_from_url(full_src, try_best_quality=True)
-                if not filename:
-                    continue
-                all_urls.add(full_src)
-                to_enrich.add_media(Media(filename=filename, properties={"url": full_src}))

src/auto_archiver/modules/antibot_extractor_enricher/dropin.py

@@ -1,159 +0,0 @@
-import os
-from typing import Mapping
-from loguru import logger
-from seleniumbase import SB
-import yt_dlp
-
-from auto_archiver.core import Extractor, Media, Metadata
-from auto_archiver.utils.misc import ydl_entry_to_filename
-
-
-class Dropin:
-    """
-    A class to handle drop-in functionality for the antibot extractor enricher module.
-    This class is designed to be a base class for drop-ins that can handle specific websites.
-    """
-
-    @staticmethod
-    def documentation() -> Mapping[str, str]:
-        """
-        Each Dropin should auto-document itself with this method.
-        Return dictionary can include:
-        - 'name': A string representing the name of the dropin.
-        - 'description': A string describing the functionality of the dropin.
-        - 'site': A string representing the site this dropin is for.
-        - 'authentication': A dictionary with authentication example for the site.
-
-        """
-        return {}
-
-    def __init__(self, sb: SB, extractor: Extractor):
-        """
-        Initialize the Dropin with the given SeleniumBase instance.
-
-        :param sb: An instance of the SeleniumBase class that this drop-in will use.
-        :param extractor: An instance of the Extractor class that this drop-in will use.
-        """
-        self.sb: SB = sb
-        self.extractor: Extractor = extractor
-
-    @staticmethod
-    def suitable(url: str) -> bool:
-        """
-        Check if the URL is suitable for processing with this dropin.
-        :param url: The URL to check.
-        :return: True if the URL is suitable for processing, False otherwise.
-        """
-        raise NotImplementedError("This method should be implemented in the subclass")
-
-    @staticmethod
-    def sanitize_url(url: str) -> str:
-        """
-        Used to clean URLs before processing them.
-        """
-        return url
-
-    @staticmethod
-    def images_selectors() -> str:
-        """
-        CSS selector to find images in the HTML page
-        """
-        return "img"
-
-    @staticmethod
-    def video_selectors() -> str:
-        """
-        CSS selector to find videos in the HTML page.
-        """
-        return "video, source"
-
-    def js_for_image_css_selectors(self) -> str:
-        """
-        A configurable JS script that receives a css selector from the dropin itself and returns an array of Image elements according to the selection.
-
-        You can overwrite this instead of `images_selector` for more control over scraped images.
-        """
-        return f"""
-            return Array.from(document.querySelectorAll("{self.images_selectors()}")).map(el => el.src || el.href).filter(Boolean);
-        """
-
-    def js_for_video_css_selectors(self) -> str:
-        """
-        A configurable JS script that receives a css selector from the dropin itself and returns an array of Video elements according to the selection.
-
-        You can overwrite this instead of `video_selector` for more control over scraped videos.
-        """
-        return f"""
-            return Array.from(document.querySelectorAll("{self.video_selectors()}")).map(el => el.src || el.href).filter(Boolean);
-        """
-
-    def open_page(self, url) -> bool:
-        """
-        Make sure the page is opened, even if it requires authentication, captcha solving, etc.
-        :param url: The URL to open.
-        :return: True if success, False otherwise.
-        """
-        raise NotImplementedError("This method should be implemented in the subclass")
-
-    def add_extra_media(self, to_enrich: Metadata) -> tuple[int, int]:
-        """
-        Extract image and/or video data from the currently open post with SeleniumBase. Media is added to the `to_enrich` Metadata object.
-        :return: A tuple (number of Images added, number of Videos added).
-        """
-        return 0, 0
-
-    def _get_username_password(self, site) -> tuple[str, str]:
-        """
-        Get the username and password for the site from the extractor's auth data.
-        :return: A tuple (username, password).
-        """
-        auth = self.extractor.auth_for_site(site)
-        username = auth.get("username", "")
-        password = auth.get("password", "")
-        if not username or not password:
-            raise ValueError(f"{site} authentication requires a username and password.")
-        return username, password
-
-    def _download_videos_with_ytdlp(self, video_urls: list[str], to_enrich: Metadata) -> int:
-        """
-        Download videos using yt-dlp.
-        :param video_urls: List of video URLs to download.
-        :return: The number of videos downloaded.
-        """
-        if type(self.extractor.max_download_videos) is int:
-            video_urls = video_urls[: self.extractor.max_download_videos]
-
-        if not video_urls:
-            return 0
-
-        ydl_options = [
-            "-o",
-            os.path.join(self.extractor.tmp_dir, "%(id)s.%(ext)s"),
-            "--quiet",
-            "--no-playlist",
-            "--no-write-subs",
-            "--no-write-auto-subs",
-            "--postprocessor-args",
-            "ffmpeg:-bitexact",
-            "--max-filesize",
-            "1000M",  # Limit to 1GB per video
-        ]
-        *_, validated_options = yt_dlp.parse_options(ydl_options)
-        downloaded = 0
-        with yt_dlp.YoutubeDL(validated_options) as ydl:
-            for url in video_urls:
-                try:
-                    logger.debug(f"Downloading video from URL: {url}")
-                    info = ydl.extract_info(url, download=True)
-                    filename = ydl_entry_to_filename(ydl, info)
-                    if not filename:  # Failed to download video.
-                        continue
-                    media = Media(filename)
-                    for x in ["duration", "original_url", "fulltitle", "description", "upload_date"]:
-                        if x in info:
-                            media.set(x, info[x])
-                    to_enrich.add_media(media)
-                    downloaded += 1
-                except Exception as e:
-                    logger.error(f"Error downloading {url}: {e}")
-        return downloaded

src/auto_archiver/modules/antibot_extractor_enricher/dropins/default.py

@@ -1,14 +0,0 @@
-from auto_archiver.modules.antibot_extractor_enricher.dropin import Dropin
-
-
-class DefaultDropin(Dropin):
-    """
-    A default fallback drop-in class for handling generic cases in the antibot extractor enricher module.
-    """
-
-    @staticmethod
-    def suitable(url: str) -> bool:
-        return False
-
-    def open_page(self, url) -> bool:
-        return True

src/auto_archiver/modules/antibot_extractor_enricher/dropins/linkedin.py

@@ -1,74 +0,0 @@
-from typing import Mapping
-from loguru import logger
-from auto_archiver.modules.antibot_extractor_enricher.dropin import Dropin
-
-
-class LinkedinDropin(Dropin):
-    """
-    A class to handle LinkedIn drop-in functionality for the antibot extractor enricher module.
-    """
-
-    @staticmethod
-    def documentation() -> Mapping[str, str]:
-        return {
-            "name": "Linkedin Dropin",
-            "description": "Handles LinkedIn pages/posts and requires authentication to access most content but will still be useful without it. The first time you login to a new IP, LinkedIn may require an email verification code, you can do a manual login first and then it won't ask for it again.",
-            "site": "linkedin.com",
-            "authentication": {
-                "linkedin.com": {
-                    "username": "email address or phone number",
-                    "password": "password",
-                }
-            },
-        }
-
-    notifications_css_selector = 'a[href*="linkedin.com/notifications"]'
-
-    @staticmethod
-    def suitable(url: str) -> bool:
-        return "linkedin.com" in url
-
-    def js_for_image_css_selectors(self) -> str:
-        get_all_css = "main img:not([src*='profile-displayphoto']):not([src*='profile-framedphoto'])"
-        get_first_css = (
-            "main img[src*='profile-framedphoto'], main img[src*='profile-displayphoto'], main img[src*='company-logo']"
-        )
-
-        return f"""
-            const all = Array.from(document.querySelectorAll("{get_all_css}")).map(el => el.src || el.href).filter(Boolean);
-            const profile = document.querySelector("{get_first_css}");
-            return all.concat(profile?.src || profile?.href || []).filter(Boolean);
-        """
-
-    @staticmethod
-    def video_selectors() -> str:
-        # usually videos are from blob: but running the generic extractor should handle that
-        return "main video"
-
-    def open_page(self, url) -> bool:
-        if not self.sb.is_element_present(self.notifications_css_selector):
-            self._login()
-            if url != self.sb.get_current_url():
-                self.sb.open(url)
-        return True
-
-    @logger.catch
-    def _login(self) -> bool:
-        if self.sb.is_text_visible("Sign in to view more content"):
-            self.sb.click_link_text("Sign in", timeout=2)
-            self.sb.wait_for_ready_state_complete()
-        else:
-            self.sb.open("https://www.linkedin.com/login")
-            self.sb.wait_for_ready_state_complete()
-
-        username, password = self._get_username_password("linkedin.com")
-        logger.debug("LinkedinDropin Logging in to Linkedin with username: {}", username)
-        self.sb.type("#username", username)
-        self.sb.type("#password", password)
-        self.sb.click_if_visible("#password-visibility-toggle", timeout=0.5)
-        self.sb.click("button[type='submit']")
-        self.sb.wait_for_ready_state_complete()
-        # TODO: on suspicious login, LinkedIn may require an email verification code
-
-        if not self.sb.is_element_present(self.notifications_css_selector):
-            self.sb.click_if_visible('button[aria-label="Dismiss"]', timeout=0.5)

src/auto_archiver/modules/antibot_extractor_enricher/dropins/reddit.py

@@ -1,92 +0,0 @@
-from contextlib import suppress
-from typing import Mapping
-from auto_archiver.core.metadata import Metadata
-from auto_archiver.modules.antibot_extractor_enricher.dropin import Dropin
-
-from loguru import logger
-
-
-class RedditDropin(Dropin):
-    """
-    A class to handle Reddit drop-in functionality for the antibot extractor enricher module.
-    """
-
-    def documentation() -> Mapping[str, str]:
-        return {
-            "name": "Reddit Dropin",
-            "description": "Handles Reddit posts and works without authentication until Reddit flags your IP, so authentication is advised.",
-            "site": "reddit.com",
-            "authentication": {
-                "reddit.com": {
-                    "username": "email address or username",
-                    "password": "password",
-                }
-            },
-        }
-
-    @staticmethod
-    def suitable(url: str) -> bool:
-        return "reddit.com" in url
-
-    @staticmethod
-    def images_selectors() -> str:
-        return "shreddit-post img"
-
-    @staticmethod
-    def video_selectors() -> str:
-        return "shreddit-post video, shreddit-post source"
-
-    def open_page(self, url) -> bool:
-        if self.sb.is_text_visible("You've been blocked by network security."):
-            self._login()
-            if url != self.sb.get_current_url():
-                self.sb.open(url)
-        return True
-
-    @logger.catch
-    def _login(self):
-        self.sb.click_link_text("Log in")
-        self.sb.wait_for_ready_state_complete()
-        self._close_cookies_banner()
-
-        username, password = self._get_username_password("reddit.com")
-        logger.debug("RedditDropin Logging in to Reddit with username: {}", username)
-
-        self.sb.type("#login-username", username)
-        self.sb.type("#login-password", password)
-
-        elem = self.sb.find_element("button.login")
-        self.sb.execute_script("arguments[0].scrollIntoView(true);", elem)
-        self.sb.slow_click("button.login")
-        self.sb.wait_for_ready_state_complete()
-
-        if "https://www.reddit.com/login/" in self.sb.get_current_url():
-            self.sb.sleep(5)
-            self.sb.wait_for_ready_state_complete()
-
-        if self.sb.is_text_visible("You've been blocked by network security."):
-            self.sb.click_link_text("Log in")
-            self.sb.wait_for_ready_state_complete()
-            if self.sb.is_text_visible("Welcome back"):
-                logger.debug("RedditDropin Login successful")
-                self.sb.click_if_visible("this link")
-
-    def _close_cookies_banner(self):
-        with suppress(Exception):  # selenium.common.exceptions.JavascriptException
-            self.sb.execute_script("""
-                document
-                    .querySelector("reddit-cookie-banner")
-                    .shadowRoot.querySelector("faceplate-dialog")
-                    .querySelector("#accept-all-cookies-button button")
-                    .click()
-            """)
-
-    @logger.catch
-    def add_extra_media(self, to_enrich: Metadata) -> tuple[int, int]:
-        filtered_urls = self.sb.execute_script(rf"""
-            return [...document.querySelectorAll("{self.video_selectors()}")]
-            .map(el => el.src || el.href)
-            .filter(url => url && /\.(m3u8|mpd|ism)$/.test(url));
-        """)
-        logger.debug("RedditDropin Found {} video URLs", len(filtered_urls))
-        return 0, self._download_videos_with_ytdlp(filtered_urls, to_enrich)

src/auto_archiver/modules/antibot_extractor_enricher/dropins/vk.py

@@ -1,92 +0,0 @@
-import re
-from typing import Mapping
-
-from auto_archiver.core.metadata import Metadata
-from auto_archiver.modules.antibot_extractor_enricher.dropin import Dropin
-
-from loguru import logger
-
-
-class VkDropin(Dropin):
-    """
-    A class to handle VK drop-in functionality for the antibot extractor enricher module.
-    """
-
-    WALL_PATTERN = re.compile(r"(wall.{0,1}\d+_\d+)")
-    VIDEO_PATTERN = re.compile(r"(video.{0,1}\d+_\d+(?:_\w+)?)")
-    CLIP_PATTERN = re.compile(r"(clip.{0,1}\d+_\d+)")
-    PHOTO_PATTERN = re.compile(r"(photo.{0,1}\d+_\d+)")
-
-    def documentation() -> Mapping[str, str]:
-        return {
-            "name": "VKontakte Dropin",
-            "description": "Handles VKontakte posts and works without authentication for some content.",
-            "site": "vk.com",
-            "authentication": {
-                "vk.com": {
-                    "username": "phone number with country code",
-                    "password": "password",
-                }
-            },
-        }
-
-    @staticmethod
-    def suitable(url: str) -> bool:
-        return "vk.com" in url
-
-    @staticmethod
-    def sanitize_url(url: str) -> str:
-        """
-        Transforms modal URLs like 'https://vk.com/page_name?w=wall-123456_7890' to 'https://vk.com/wall-123456_7890'
-        """
-        for pattern in [VkDropin.WALL_PATTERN, VkDropin.VIDEO_PATTERN, VkDropin.CLIP_PATTERN, VkDropin.PHOTO_PATTERN]:
-            match = pattern.search(url)
-            if match:
-                return f"https://vk.com/{match.group(1)}"
-        return url
-
-    def open_page(self, url) -> bool:
-        if self.sb.is_text_visible("Sign in to VK"):
-            if self._login():
-                self.sb.open(url)
-        return True
-
-    @logger.catch
-    def _login(self) -> bool:
-        # TODO: test method, because current tests work without a login
-        self.sb.open("https://vk.com")
-        self.sb.wait_for_ready_state_complete()
-        if "/feed" in self.sb.get_current_url():
-            logger.debug("Already logged in to VK.")
-            return True
-
-        # need to login
-        username, password = self._get_username_password("vk.com")
-        logger.debug("Logging in to VK with username: {}", username)
-
-        self.sb.click('[data-testid="enter-another-way"]', timeout=10)
-        self.sb.clear('input[name="login"][type="tel"]', by="css selector", timeout=10)
-        self.sb.type('input[name="login"][type="tel"]', username, by="css selector", timeout=10)
-        self.sb.click('button[type="submit"]')
-
-        # TODO: handle captcha if it appears
-        # if sb.is_element_visible("img.vkc__CaptchaPopup__image"):
-        #     captcha_url = sb.get_attribute("img.vkc__CaptchaPopup__image", "src")
-        #     print("CAPTCHA detected:", captcha_url)
-        #     image_url = sb.get_attribute("img[alt*='captcha']", "src")
-        #     solution = solve_captcha(image_url)
-        #     sb.type("input#captcha-text, input[name='captcha']", solution)
-        #     sb.click("button[type='submit']")
-
-        self.sb.type('input[name="password"]', password, timeout=15)
-        self.sb.click('button[type="submit"]')
-        self.sb.wait_for_ready_state_complete(timeout=10)
-        self.sb.wait_for_element("body", timeout=10)
-        # self.sb.sleep(2)
-        return "/feed" in self.sb.get_current_url()
-
-    @logger.catch
-    def add_extra_media(self, to_enrich: Metadata) -> tuple[int, int]:
-        video_urls = [v.get_attribute("href") for v in self.sb.find_elements('a[href*="/video-"]')]
-
-        return 0, self._download_videos_with_ytdlp(video_urls, to_enrich)

src/auto_archiver/modules/gdrive_storage/gdrive_storage.py

@@ -93,18 +93,13 @@ class GDriveStorage(Storage):
         # upload file to gd
         logger.debug(f"uploading {filename=} to folder id {upload_to}")
         file_metadata = {"name": [filename], "parents": [upload_to]}
-        try:
-            media = MediaFileUpload(media.filename, resumable=True)
-            gd_file = (
-                self.service.files()
-                .create(supportsAllDrives=True, body=file_metadata, media_body=media, fields="id")
-                .execute()
-            )
-            logger.debug(f"uploadf: uploaded file {gd_file['id']} successfully in folder={upload_to}")
-        except FileNotFoundError as e:
-            logger.error(f"gd uploadf: file not found {media.filename=} - {e}")
-        except Exception as e:
-            logger.error(f"gd uploadf: error uploading {media.filename=} to {upload_to} - {e}")
+        media = MediaFileUpload(media.filename, resumable=True)
+        gd_file = (
+            self.service.files()
+            .create(supportsAllDrives=True, body=file_metadata, media_body=media, fields="id")
+            .execute()
+        )
+        logger.debug(f"uploadf: uploaded file {gd_file['id']} successfully in folder={upload_to}")
 
     # must be implemented even if unused
     def uploadf(self, file: IO[bytes], key: str, **kwargs: dict) -> bool:

src/auto_archiver/modules/generic_extractor/__manifest__.py

@@ -4,7 +4,9 @@
     "author": "Bellingcat",
     "type": ["extractor"],
     "requires_setup": False,
-    "dependencies": {"python": ["yt_dlp", "requests", "loguru", "slugify"], "bin": ["ffmpeg"]},
+    "dependencies": {
+        "python": ["yt_dlp", "requests", "loguru", "slugify"],
+    },
     "description": """
 This is the generic extractor used by auto-archiver, which uses `yt-dlp` under the hood.
 
@@ -30,8 +32,6 @@ For a full list of video platforms supported by `yt-dlp`, see the
 custom dropins can be created to handle additional websites and passed to the archiver
 via the command line using the `--dropins` option (TODO!).
 
-You can see all currently implemented dropins in [the source code](https://github.com/bellingcat/auto-archiver/tree/main/src/auto_archiver/modules/generic_extractor).
-
 ### Auto-Updates
 
 The Generic Extractor will also automatically check for updates to `yt-dlp` (every 5 days by default).
@@ -62,7 +62,7 @@ If you are having issues with the extractor, you can review the version of `yt-d
         },
         "end_means_success": {
             "default": True,
-            "help": "if True, any archived content will mean a 'success', if False this extractor will not return a 'success' stage; this is useful for cases when the yt-dlp will archive a video but ignore other types of content like images or text only pages that the subsequent extractors can retrieve.",
+            "help": "if True, any archived content will mean a 'success', if False this archiver will not return a 'success' stage; this is useful for cases when the yt-dlp will archive a video but ignore other types of content like images or text only pages that the subsequent archivers can retrieve.",
             "type": "bool",
         },
         "allow_playlist": {
@@ -74,11 +74,6 @@ If you are having issues with the extractor, you can review the version of `yt-d
             "default": "inf",
             "help": "Use to limit the number of videos to download when a channel or long page is being extracted. 'inf' means no limit.",
         },
-        "bguils_po_token_method": {
-            "default": "auto",
-            "help": "Set up a Proof of origin token provider. This process has additional requirements. See [authentication](https://auto-archiver.readthedocs.io/en/latest/how_to/authentication_how_to.html) for more information.",
-            "choices": ["auto", "script", "disabled"],
-        },
         "extractor_args": {
             "default": {},
             "help": "Additional arguments to pass to the yt-dlp extractor. See https://github.com/yt-dlp/yt-dlp/blob/master/README.md#extractor-arguments.",

src/auto_archiver/modules/generic_extractor/generic_extractor.py

@@ -1,17 +1,12 @@
-import shutil
-import sys
 import datetime
 import os
 import importlib
 import subprocess
-import zipfile
 
 from typing import Generator, Type
-from urllib.request import urlretrieve
 
 import yt_dlp
 from yt_dlp.extractor.common import InfoExtractor
-from yt_dlp.utils import MaxDownloadsReached
 import pysubs2
 
 from loguru import logger
@@ -19,7 +14,6 @@ from loguru import logger
 from auto_archiver.core.extractor import Extractor
 from auto_archiver.core import Metadata, Media
 from auto_archiver.utils import get_datetime_from_str
-from auto_archiver.utils.misc import ydl_entry_to_filename
 from .dropin import GenericDropin
 
 
@@ -31,141 +25,45 @@ class GenericExtractor(Extractor):
     _dropins = {}
 
     def setup(self):
-        self.check_for_extractor_updates()
-        self.setup_po_tokens()
-        # TODO: figure out why the following is not properly recognised by yt-dlp:
-        # if "generic" not in self.extractor_args:
-        #     self.extractor_args["generic"] = "impersonate"
-
-    def check_for_extractor_updates(self):
-        """Checks whether yt-dlp or its plugins need updating and triggers a restart if so."""
+        # check for file .ytdlp-update in the secrets folder
         if self.ytdlp_update_interval < 0:
             return
 
-        update_file = os.path.join("secrets" if os.path.exists("secrets") else "", ".ytdlp-update")
-        next_check = None
-        if os.path.exists(update_file):
-            with open(update_file, "r") as f:
-                next_check = datetime.datetime.fromisoformat(f.read())
+        use_secrets = os.path.exists("secrets")
+        path = os.path.join("secrets" if use_secrets else "", ".ytdlp-update")
+        next_update_check = None
+        if os.path.exists(path):
+            with open(path, "r") as f:
+                next_update_check = datetime.datetime.fromisoformat(f.read())
 
-        if next_check and next_check > datetime.datetime.now():
-            return
+        if not next_update_check or next_update_check < datetime.datetime.now():
+            self.update_ytdlp()
 
-        yt_dlp_updated = self.update_package("yt-dlp")
-        bgutil_updated = self.update_package("bgutil-ytdlp-pot-provider")
+            next_update_check = datetime.datetime.now() + datetime.timedelta(days=self.ytdlp_update_interval)
+            with open(path, "w") as f:
+                f.write(next_update_check.isoformat())
 
-        # Write the new timestamp
-        with open(update_file, "w") as f:
-            next_check = datetime.datetime.now() + datetime.timedelta(days=self.ytdlp_update_interval)
-            f.write(next_check.isoformat())
-
-        if yt_dlp_updated or bgutil_updated:
-            if os.environ.get("AUTO_ARCHIVER_ALLOW_RESTART", "1") != "1":
-                logger.warning("yt-dlp or plugin was updated — please restart auto-archiver manually")
-            else:
-                logger.warning("yt-dlp or plugin was updated — restarting auto-archiver")
-                logger.warning(" ======= RESTARTING ======= ")
-                os.execv(sys.executable, [sys.executable] + sys.argv)
-
-    def update_package(self, package_name: str) -> bool:
-        logger.info(f"Checking and updating {package_name}...")
+    def update_ytdlp(self):
+        logger.info("Checking and updating yt-dlp...")
+        logger.info(
+            f"Tip: change the 'ytdlp_update_interval' setting to control how often yt-dlp is updated. Set to -1 to disable or 0 to enable on every run. Current setting: {self.ytdlp_update_interval}"
+        )
         from importlib.metadata import version as get_version
 
-        old_version = get_version(package_name)
+        old_version = get_version("yt-dlp")
         try:
-            result = subprocess.run(["pip", "install", "--upgrade", package_name], check=True, capture_output=True)
-            if f"Successfully installed {package_name}" in result.stdout.decode():
-                new_version = importlib.metadata.version(package_name)
-                logger.info(f"{package_name} updated from {old_version} to {new_version}")
-                return True
-            logger.info(f"{package_name} already up to date")
-        except Exception as e:
-            logger.error(f"Error updating {package_name}: {e}")
-        return False
+            # try and update with pip (this works inside poetry environment and in a normal virtualenv)
+            result = subprocess.run(["pip", "install", "--upgrade", "yt-dlp"], check=True, capture_output=True)
 
-    def setup_po_tokens(self) -> None:
-        """Setup Proof of Origin Token method conditionally.
-        Uses provider: https://github.com/Brainicism/bgutil-ytdlp-pot-provider.
-        """
-        in_docker = os.environ.get("RUNNING_IN_DOCKER")
-        if self.bguils_po_token_method == "disabled":
-            # This allows disabling of the PO Token generation script in the Docker implementation.
-            logger.warning("Proof of Origin Token generation is disabled.")
-            return
-
-        if self.bguils_po_token_method == "auto" and not in_docker:
-            logger.info(
-                "Proof of Origin Token method not explicitly set. "
-                "If you're running an external HTTP server separately, you can safely ignore this message. "
-                "To reduce the likelihood of bot detection, enable one of the methods described in the documentation: "
-                "https://auto-archiver.readthedocs.io/en/settings_page/installation/authentication.html#proof-of-origin-tokens"
-            )
-            return
-
-        # Either running in Docker, or "script" method is set beyond this point
-        self.setup_token_generation_script()
-
-    def setup_token_generation_script(self) -> None:
-        """This function sets up the Proof of Origin Token generation script method for
-        bgutil-ytdlp-pot-provider if enabled or in Docker."""
-        missing_tools = [tool for tool in ("node", "yarn", "npx") if shutil.which(tool) is None]
-        if missing_tools:
-            logger.error(
-                f"Cannot set up PO Token script; missing required tools: {', '.join(missing_tools)}. "
-                "Install these tools or run bgutils via Docker. "
-                "See: https://github.com/Brainicism/bgutil-ytdlp-pot-provider"
-            )
-            return
-        try:
-            from importlib.metadata import version as get_version
-
-            plugin_version = get_version("bgutil-ytdlp-pot-provider")
-            base_dir = os.path.expanduser("~/bgutil-ytdlp-pot-provider")
-            server_dir = os.path.join(base_dir, "server")
-            version_file = os.path.join(server_dir, ".VERSION")
-            transpiled_script = os.path.join(server_dir, "build", "generate_once.js")
-
-            # Skip setup if version is correct and transpiled script exists
-            if os.path.isfile(transpiled_script) and os.path.isfile(version_file):
-                with open(version_file) as vf:
-                    if vf.read().strip() == plugin_version:
-                        logger.info("PO Token script already set up and up to date.")
+            if "Successfully installed yt-dlp" in result.stdout.decode():
+                new_version = importlib.metadata.version("yt-dlp")
+                logger.info(f"yt-dlp successfully (from {old_version} to {new_version})")
+                importlib.reload(yt_dlp)
             else:
-                # Remove an outdated directory and pull a new version
-                if os.path.exists(base_dir):
-                    shutil.rmtree(base_dir)
-                os.makedirs(base_dir, exist_ok=True)
-
-                zip_url = (
-                    f"https://github.com/Brainicism/bgutil-ytdlp-pot-provider/archive/refs/tags/{plugin_version}.zip"
-                )
-                zip_path = os.path.join(base_dir, f"{plugin_version}.zip")
-                logger.info(f"Downloading bgutils release zip for version {plugin_version}...")
-                urlretrieve(zip_url, zip_path)
-                with zipfile.ZipFile(zip_path, "r") as z:
-                    z.extractall(base_dir)
-                os.remove(zip_path)
-
-                extracted_root = os.path.join(base_dir, f"bgutil-ytdlp-pot-provider-{plugin_version}")
-                shutil.move(os.path.join(extracted_root, "server"), server_dir)
-                shutil.rmtree(extracted_root)
-                logger.info("Installing dependencies and transpiling PoT Generator script...")
-                subprocess.run(["yarn", "install", "--frozen-lockfile"], cwd=server_dir, check=True)
-                subprocess.run(["npx", "tsc"], cwd=server_dir, check=True)
-
-                with open(version_file, "w") as vf:
-                    vf.write(plugin_version)
-
-            script_path = os.path.join(server_dir, "build", "generate_once.js")
-            if not os.path.exists(script_path):
-                logger.error("generate_once.js not found after transpilation.")
-                return
-
-            self.extractor_args.setdefault("youtubepot-bgutilscript", {})["script_path"] = script_path
-            logger.info(f"PO Token script configured at: {script_path}")
+                logger.info("yt-dlp already up to date")
 
         except Exception as e:
-            logger.error(f"Failed to set up PO Token script: {e}")
+            logger.error(f"Error updating yt-dlp: {e}")
 
     def suitable_extractors(self, url: str) -> Generator[str, None, None]:
         """
@@ -306,9 +204,9 @@ class GenericExtractor(Extractor):
             result.set_url(url)
 
         if "description" in video_data and not result.get("content"):
-            result.set_content(video_data.get("description"))
+            result.set_content(video_data["description"])
         # extract comments if enabled
-        if self.comments and video_data.get("comments", []) is not None:
+        if self.comments:
             result.set(
                 "comments",
                 [
@@ -367,29 +265,22 @@ class GenericExtractor(Extractor):
         # this time download
         ydl.params["getcomments"] = self.comments
         # TODO: for playlist or long lists of videos, how to download one at a time so they can be stored before the next one is downloaded?
-        try:
-            data = ydl.extract_info(url, ie_key=info_extractor.ie_key(), download=True)
-        except MaxDownloadsReached:  # proceed as normal once MaxDownloadsReached is raised
-            pass
-
+        data = ydl.extract_info(url, ie_key=info_extractor.ie_key(), download=True)
         if "entries" in data:
             entries = data.get("entries", [])
             if not len(entries):
-                logger.info("YoutubeDLArchiver could not find any video")
+                logger.warning("YoutubeDLArchiver could not find any video")
                 return False
         else:
             entries = [data]
+
         result = Metadata()
 
         for entry in entries:
             try:
-                filename = ydl_entry_to_filename(ydl, entry)
-
-                if not filename:
-                    # file was not downloaded or could not be retrieved, example: sensitive videos on YT without using cookies.
-                    continue
-
-                logger.debug(f"Using filename {filename} for entry {entry.get('id', 'unknown')}")
+                filename = ydl.prepare_filename(entry)
+                if not os.path.exists(filename):
+                    filename = filename.split(".")[0] + ".mkv"
 
                 new_media = Media(filename)
                 for x in ["duration", "original_url", "fulltitle", "description", "upload_date"]:
@@ -408,9 +299,6 @@ class GenericExtractor(Extractor):
                 result.add_media(new_media)
             except Exception as e:
                 logger.error(f"Error processing entry {entry}: {e}")
-        if not len(result.media):
-            logger.info(f"No media found for entry {entry}, skipping.")
-            return False
 
         return self.add_metadata(data, info_extractor, url, result)
 
@@ -469,13 +357,6 @@ class GenericExtractor(Extractor):
 
         dropin_submodule = self.dropin_for_name(info_extractor.ie_key())
 
-        def _helper_for_successful_extract_info(data, info_extractor, url, ydl):
-            if data.get("is_live", False) and not self.livestreams:
-                logger.warning("Livestream detected, skipping due to 'livestreams' configuration setting")
-                return False
-            # it's a valid video, that the youtubdedl can download out of the box
-            return self.get_metadata_for_video(data, info_extractor, url, ydl)
-
         try:
             if dropin_submodule and dropin_submodule.skip_ytdlp_download(url, info_extractor):
                 logger.debug(f"Skipping using ytdlp to download files for {info_extractor.ie_key()}")
@@ -483,12 +364,11 @@ class GenericExtractor(Extractor):
 
             # don't download since it can be a live stream
             data = ydl.extract_info(url, ie_key=info_extractor.ie_key(), download=False)
-
-            result = _helper_for_successful_extract_info(data, info_extractor, url, ydl)
-
-        except MaxDownloadsReached:
-            # yt-dlp raises an error when the max downloads limit is reached, and it shouldn't for our purposes, so we consider that a success
-            result = _helper_for_successful_extract_info(data, info_extractor, url, ydl)
+            if data.get("is_live", False) and not self.livestreams:
+                logger.warning("Livestream detected, skipping due to 'livestreams' configuration setting")
+                return False
+            # it's a valid video, that the youtubdedl can download out of the box
+            result = self.get_metadata_for_video(data, info_extractor, url, ydl)
 
         except Exception as e:
             if info_extractor.IE_NAME == "generic":
@@ -542,8 +422,6 @@ class GenericExtractor(Extractor):
             "--write-subs" if self.subtitles else "--no-write-subs",
             "--write-auto-subs" if self.subtitles else "--no-write-auto-subs",
             "--live-from-start" if self.live_from_start else "--no-live-from-start",
-            "--postprocessor-args",
-            "ffmpeg:-bitexact",  # ensure bitexact output to avoid mismatching hashes for same video
         ]
 
         # proxy handling
@@ -576,11 +454,11 @@ class GenericExtractor(Extractor):
         # Applying user-defined extractor_args
         if self.extractor_args:
             for key, args in self.extractor_args.items():
+                logger.debug(f"Setting extractor_args: {key}")
                 if isinstance(args, dict):
                     arg_str = ";".join(f"{k}={v}" for k, v in args.items())
                 else:
                     arg_str = str(args)
-                logger.debug(f"Setting extractor_args: {key}:{arg_str}")
                 ydl_options.extend(["--extractor-args", f"{key}:{arg_str}"])
 
         if self.ytdlp_args:

src/auto_archiver/modules/generic_extractor/tiktok.py

@@ -10,7 +10,7 @@ from .dropin import GenericDropin
 
 class Tiktok(GenericDropin):
     """
-    TikTok dropin for the Generic Extractor that uses an unofficial API if/when ytdlp fails.
+    TikTok droping for the Generic Extractor that uses an unofficial API if/when ytdlp fails.
     It's useful for capturing content that requires a login, like sensitive content.
     """
 

src/auto_archiver/modules/generic_extractor/twitter.py

@@ -7,7 +7,8 @@ from slugify import slugify
 from auto_archiver.core.metadata import Metadata, Media
 from auto_archiver.utils import url as UrlUtil, get_datetime_from_str
 from auto_archiver.core.extractor import Extractor
-from auto_archiver.modules.generic_extractor.dropin import GenericDropin, InfoExtractor
+
+from .dropin import GenericDropin, InfoExtractor
 
 
 class Twitter(GenericDropin):

src/auto_archiver/modules/gsheet_feeder_db/gsheet_feeder_db.py

@@ -10,13 +10,12 @@ The filtered rows are processed into `Metadata` objects.
 """
 
 import os
-from typing import Tuple, Union, Iterator
+from typing import Tuple, Union
 from urllib.parse import quote
 
 import gspread
 from loguru import logger
 from slugify import slugify
-from retrying import retry
 
 from auto_archiver.core import Feeder, Database, Media
 from auto_archiver.core import Metadata
@@ -34,10 +33,10 @@ class GsheetsFeederDB(Feeder, Database):
     def open_sheet(self):
         if self.sheet:
             return self.gsheets_client.open(self.sheet)
-        else:
+        else:  # self.sheet_id
             return self.gsheets_client.open_by_key(self.sheet_id)
 
-    def __iter__(self) -> Iterator[Metadata]:
+    def __iter__(self) -> Metadata:
         sh = self.open_sheet()
         for ii, worksheet in enumerate(sh.worksheets()):
             if not self.should_process_sheet(worksheet.title):
@@ -46,14 +45,14 @@ class GsheetsFeederDB(Feeder, Database):
             logger.info(f"Opening worksheet {ii=}: {worksheet.title=} header={self.header}")
             gw = GWorksheet(worksheet, header_row=self.header, columns=self.columns)
             if len(missing_cols := self.missing_required_columns(gw)):
-                logger.debug(
+                logger.warning(
                     f"SKIPPED worksheet '{worksheet.title}' due to missing required column(s) for {missing_cols}"
                 )
                 continue
 
             # process and yield metadata here:
             yield from self._process_rows(gw)
-            logger.info(f"Finished worksheet {worksheet.title}")
+            logger.success(f"Finished worksheet {worksheet.title}")
 
     def _process_rows(self, gw: GWorksheet):
         for row in range(1 + self.header, gw.count_rows() + 1):
@@ -89,7 +88,10 @@ class GsheetsFeederDB(Feeder, Database):
         if len(self.allow_worksheets) and sheet_name not in self.allow_worksheets:
             # ALLOW rules exist AND sheet name not explicitly allowed
             return False
-        return not (self.block_worksheets and sheet_name in self.block_worksheets)
+        if len(self.block_worksheets) and sheet_name in self.block_worksheets:
+            # BLOCK rules exist AND sheet name is blocked
+            return False
+        return True
 
     def missing_required_columns(self, gw: GWorksheet) -> list:
         missing = []
@@ -99,7 +101,7 @@ class GsheetsFeederDB(Feeder, Database):
         return missing
 
     def started(self, item: Metadata) -> None:
-        logger.info(f"STARTED {item}")
+        logger.warning(f"STARTED {item}")
         gw, row = self._retrieve_gsheet(item)
         gw.set_cell(row, "status", "Archive in progress")
 
@@ -159,8 +161,9 @@ class GsheetsFeederDB(Feeder, Database):
         if (screenshot := item.get_media_by_id("screenshot")) and hasattr(screenshot, "urls"):
             batch_if_valid("screenshot", "\n".join(screenshot.urls))
 
-        if (thumbnail := item.get_first_image("thumbnail")) and hasattr(thumbnail, "urls"):
-            batch_if_valid("thumbnail", f'=IMAGE("{thumbnail.urls[0]}")')
+        if thumbnail := item.get_first_image("thumbnail"):
+            if hasattr(thumbnail, "urls"):
+                batch_if_valid("thumbnail", f'=IMAGE("{thumbnail.urls[0]}")')
 
         if browsertrix := item.get_media_by_id("browsertrix"):
             batch_if_valid("wacz", "\n".join(browsertrix.urls))
@@ -174,16 +177,7 @@ class GsheetsFeederDB(Feeder, Database):
                 ),
             )
 
-        @retry(
-            wait_incrementing_start=1000,
-            wait_incrementing_increment=3000,
-            wait_incrementing_max=20_000,
-            stop_max_attempt_number=5,
-        )
-        def batch_set_cell_with_retry(gw, cell_updates: list):
-            gw.batch_set_cell(cell_updates)
-
-        batch_set_cell_with_retry(gw, cell_updates)
+        gw.batch_set_cell(cell_updates)
 
     def _safe_status_update(self, item: Metadata, new_status: str) -> None:
         try:

src/auto_archiver/modules/html_formatter/templates/html_template.html

@@ -12,12 +12,6 @@
             font-family: 'Roboto', sans-serif;
         }
 
-        h2 {
-            white-space: normal;
-            overflow-wrap: break-word;
-            word-break: break-word;
-        }
-
         table {
             table-layout: fixed;
             width: 90%;
@@ -103,17 +97,13 @@
             background-color: #f1f1f1;
         }
 
-        .pem-certificate,
-        .text-preview {
+        .pem-certificate, .text-preview {
             text-align: left;
             font-size: small;
         }
-
-        .text-preview {
+        .text-preview{
             padding-left: 10px;
             padding-right: 10px;
-            max-height: 300px;
-            overflow: auto;
             white-space: pre-wrap;
         }
     </style>

src/auto_archiver/modules/instagram_api_extractor/__manifest__.py

@@ -31,11 +31,9 @@
         },
     },
     "description": """
-Archives Instagram content using a deployment of the [Instagrapi API](https://subzeroid.github.io/instagrapi/).
+Archives various types of Instagram content using the Instagrapi API.
 
-Requires either getting a token from using a hosted [(paid) service](https://api.instagrapi.com/docs) and setting this in the configuration file.
-Alternatively you can run your own server. We have a basic script which you can use for this which can be ran locally or using Docker.
-For more information, read the [how to guide](https://auto-archiver.readthedocs.io/en/latest/how_to/run_instagrapi_server.html) on this.
+Requires setting up an Instagrapi API deployment and providing an access token and API endpoint.
 
 ### Features
 - Connects to an Instagrapi API deployment to fetch Instagram profiles, posts, stories, highlights, reels, and tagged content.

src/auto_archiver/modules/instagram_tbot_extractor/instagram_tbot_extractor.py

@@ -58,7 +58,7 @@ class InstagramTbotExtractor(Extractor):
                 "If you do, disable at least one of the archivers for the first-time setup of the telethon session: {e}"
             )
         with self.client.start():
-            logger.info(f"SETUP {self.name} login works.")
+            logger.success(f"SETUP {self.name} login works.")
 
     def cleanup(self) -> None:
         logger.info(f"CLEANUP {self.name}.")
@@ -88,9 +88,6 @@ class InstagramTbotExtractor(Extractor):
 
             if message:
                 result.set_content(message).set_title(message[:128])
-            elif result.is_empty():
-                logger.debug(f"No media found for link {url=} for {self.name}: {message}")
-                return False
             return result.success("insta-via-bot")
 
     def _send_url_to_bot(self, url: str):
@@ -107,13 +104,13 @@ class InstagramTbotExtractor(Extractor):
         message = ""
         time.sleep(3)
         # media is added before text by the bot so it can be used as a stop-logic mechanism
-        while attempts < max(self.timeout - 3, 15) and (not message or not len(seen_media)):
+        while attempts < max(self.timeout - 3, 3) and (not message or not len(seen_media)):
             attempts += 1
             time.sleep(1)
             for post in self.client.iter_messages(chat, min_id=since_id):
                 since_id = max(since_id, post.id)
                 # Skip known filler message:
-                if "The bot receives information through https://hikerapi.com/" in post.message:
+                if post.message == "The bot receives information through https://hikerapi.com/p/hJqpppqi":
                     continue
                 if post.media and post.id not in seen_media:
                     filename_dest = os.path.join(tmp_dir, f"{chat.id}_{post.id}")

src/auto_archiver/modules/json_enricher/__init__.py

@@ -1 +0,0 @@
-from .json_enricher import JsonEnricher

src/auto_archiver/modules/json_enricher/__manifest__.py

@@ -1,16 +0,0 @@
-{
-    "name": "JSON Enricher",
-    "type": ["enricher"],
-    "requires_setup": True,
-    "dependencies": {
-        "python": ["loguru"],
-    },
-    "configs": {},
-    "description": """
-
-    Writes all archiving process metadata to a JSON file so it can be parsed by other tools. As this is an Enricher, it will not contain the final stored URLs. 
-	
-	WARNING: The resulting JSON may reveal sensitive information about the computer and settings in which the archiving process was run. 
-
-    """,
-}

src/auto_archiver/modules/json_enricher/json_enricher.py

@@ -1,19 +0,0 @@
-import json
-from loguru import logger
-import os
-
-from auto_archiver.core import Enricher
-from auto_archiver.core import Media, Metadata
-
-
-class JsonEnricher(Enricher):
-    def enrich(self, to_enrich: Metadata) -> None:
-        url = to_enrich.get_url()
-
-        logger.debug(f"JSON Enricher for {url=}")
-
-        item_path = os.path.join(self.tmp_dir, "metadata.json")
-        with open(item_path, mode="w", encoding="utf-8") as outf:
-            json.dump(to_enrich.to_dict(), outf, indent=4, default=str, ensure_ascii=False)
-
-        to_enrich.add_media(Media(filename=item_path), id="metadata_json")

src/auto_archiver/modules/opentimestamps_enricher/opentimestamps_enricher.py

@@ -20,7 +20,7 @@ class OpentimestampsEnricher(Enricher):
         # Get the media files to timestamp
         media_files = [m for m in to_enrich.media if m.filename and not m.get("opentimestamps")]
         if not media_files:
-            logger.debug(f"No files found to timestamp in {url=}")
+            logger.warning(f"No files found to timestamp in {url=}")
             return
 
         timestamp_files = []
@@ -119,7 +119,7 @@ class OpentimestampsEnricher(Enricher):
         if timestamp_files:
             to_enrich.set("opentimestamped", True)
             to_enrich.set("opentimestamps_count", len(timestamp_files))
-            logger.info(f"{len(timestamp_files)} OpenTimestamps proofs created for {url=}")
+            logger.success(f"{len(timestamp_files)} OpenTimestamps proofs created for {url=}")
         else:
             to_enrich.set("opentimestamped", False)
             logger.warning(f"No successful timestamps created for {url=}")

src/auto_archiver/modules/pdq_hash_enricher/__manifest__.py

@@ -15,7 +15,7 @@
     - Skips non-image media or files unsuitable for hashing (e.g., corrupted or unsupported formats).
 
     ### Notes
-    - Best used after enrichers like `thumbnail_enricher` or `antibot_extractor_enricher` (takes screenshots) to ensure images are available.
+    - Best used after enrichers like `thumbnail_enricher` or `screenshot_enricher` to ensure images are available.
     - Uses the `pdqhash` library to compute 256-bit perceptual hashes, which are stored as hexadecimal strings.
     """,
 }

src/auto_archiver/modules/pdq_hash_enricher/pdq_hash_enricher.py

@@ -6,7 +6,7 @@ objects and calculates perceptual hashes using the PDQ hashing algorithm.
 These hashes are designed specifically for images and can be used
 for detecting duplicate or near-duplicate visual content.
 
-This enricher is typically used after thumbnail or screenshot (antibot) enrichers
+This enricher is typically used after thumbnail or screenshot enrichers
 to ensure images are available for hashing.
 
 """

src/auto_archiver/modules/s3_storage/s3_storage.py

@@ -40,8 +40,6 @@ class S3Storage(Storage):
             try:
                 if media.mimetype:
                     extra_args["ContentType"] = media.mimetype
-                    if "text" in media.mimetype:
-                        extra_args["ContentType"] += "; charset=utf-8"
             except Exception as e:
                 logger.warning(f"Unable to get mimetype for {media.key=}, error: {e}")
         self.s3.upload_fileobj(file, Bucket=self.bucket, Key=media.key, ExtraArgs=extra_args)

src/auto_archiver/modules/screenshot_enricher/__init__.py

@@ -0,0 +1 @@
+from .screenshot_enricher import ScreenshotEnricher

src/auto_archiver/modules/screenshot_enricher/__manifest__.py

@@ -0,0 +1,44 @@
+{
+    "name": "Screenshot Enricher",
+    "type": ["enricher"],
+    "requires_setup": True,
+    "dependencies": {
+        "python": ["loguru", "selenium"],
+    },
+    "configs": {
+        "width": {"default": 1280, "type": "int", "help": "width of the screenshots"},
+        "height": {"default": 1024, "type": "int", "help": "height of the screenshots"},
+        "timeout": {"default": 60, "type": "int", "help": "timeout for taking the screenshot"},
+        "sleep_before_screenshot": {
+            "default": 4,
+            "type": "int",
+            "help": "seconds to wait for the pages to load before taking screenshot",
+        },
+        "http_proxy": {
+            "default": "",
+            "help": "http proxy to use for the webdriver, eg http://proxy-user:password@proxy-ip:port",
+        },
+        "save_to_pdf": {
+            "default": False,
+            "type": "bool",
+            "help": "save the page as pdf along with the screenshot. PDF saving options can be adjusted with the 'print_options' parameter",
+        },
+        "print_options": {
+            "default": {},
+            "help": "options to pass to the pdf printer, in JSON format. See https://www.selenium.dev/documentation/webdriver/interactions/print_page/ for more information",
+            "type": "json_loader",
+        },
+    },
+    "description": """
+    Captures screenshots and optionally saves web pages as PDFs using a WebDriver.
+
+    ### Features
+    - Takes screenshots of web pages, with configurable width, height, and timeout settings.
+    - Optionally saves pages as PDFs, with additional configuration for PDF printing options.
+    - Bypasses URLs detected as authentication walls.
+    - Integrates seamlessly with the metadata enrichment pipeline, adding screenshots and PDFs as media.
+
+    ### Notes
+    - Requires a WebDriver (e.g., ChromeDriver) installed and accessible via the system's PATH.
+    """,
+}

src/auto_archiver/modules/screenshot_enricher/screenshot_enricher.py

@@ -0,0 +1,61 @@
+from loguru import logger
+import time
+import os
+import base64
+
+from selenium.common.exceptions import TimeoutException
+
+
+from auto_archiver.core import Enricher
+from auto_archiver.utils import Webdriver, url as UrlUtil, random_str
+from auto_archiver.core import Media, Metadata
+
+
+class ScreenshotEnricher(Enricher):
+    def __init__(self, webdriver_factory=None):
+        super().__init__()
+        self.webdriver_factory = webdriver_factory or Webdriver
+
+    def enrich(self, to_enrich: Metadata) -> None:
+        url = to_enrich.get_url()
+
+        logger.debug(f"Enriching screenshot for {url=}")
+        auth = self.auth_for_site(url)
+
+        # screenshot enricher only supports cookie-type auth (selenium)
+        has_valid_auth = auth and (auth.get("cookies") or auth.get("cookies_jar") or auth.get("cookie"))
+
+        if UrlUtil.is_auth_wall(url) and not has_valid_auth:
+            logger.warning(f"[SKIP] SCREENSHOT since url is behind AUTH WALL and no login details provided: {url=}")
+            if any(auth.get(key) for key in ["username", "password", "api_key", "api_secret"]):
+                logger.warning(
+                    f"Screenshot enricher only supports cookie-type authentication, you have provided {auth.keys()} which are not supported.\
+                               Consider adding 'cookie', 'cookies_file' or 'cookies_from_browser' to your auth for this site."
+                )
+            return
+
+        with self.webdriver_factory(
+            self.width,
+            self.height,
+            self.timeout,
+            facebook_accept_cookies="facebook.com" in url,
+            http_proxy=self.http_proxy,
+            print_options=self.print_options,
+            auth=auth,
+        ) as driver:
+            try:
+                driver.get(url)
+                time.sleep(int(self.sleep_before_screenshot))
+                screenshot_file = os.path.join(self.tmp_dir, f"screenshot_{random_str(8)}.png")
+                driver.save_screenshot(screenshot_file)
+                to_enrich.add_media(Media(filename=screenshot_file), id="screenshot")
+                if self.save_to_pdf:
+                    pdf_file = os.path.join(self.tmp_dir, f"pdf_{random_str(8)}.pdf")
+                    pdf = driver.print_page(driver.print_options)
+                    with open(pdf_file, "wb") as f:
+                        f.write(base64.b64decode(pdf))
+                    to_enrich.add_media(Media(filename=pdf_file), id="pdf")
+            except TimeoutException:
+                logger.info("TimeoutException loading page for screenshot")
+            except Exception as e:
+                logger.error(f"Got error while loading webdriver for screenshot enricher: {e}")

src/auto_archiver/modules/telethon_extractor/__manifest__.py

@@ -19,7 +19,7 @@
         },
         "session_file": {
             "default": "secrets/anon",
-            "help": "Path of the file to save the telegram login session for future usage, '.session' will be appended to the provided path.",
+            "help": "optional, records the telegram login session for future usage, '.session' will be appended to the provided value.",
         },
         "join_channels": {
             "default": True,

src/auto_archiver/modules/telethon_extractor/telethon_extractor.py

@@ -1,10 +1,4 @@
-import os
 import shutil
-import re
-import time
-from pathlib import Path
-from datetime import date
-
 from telethon.sync import TelegramClient
 from telethon.errors import ChannelInvalidError
 from telethon.tl.functions.messages import ImportChatInviteRequest
@@ -14,9 +8,11 @@ from telethon.errors.rpcerrorlist import (
     InviteRequestSentError,
     InviteHashExpiredError,
 )
-
-from tqdm import tqdm
 from loguru import logger
+from tqdm import tqdm
+import re
+import time
+import os
 
 from auto_archiver.core import Extractor
 from auto_archiver.core import Metadata, Media
@@ -35,28 +31,16 @@ class TelethonExtractor(Extractor):
         """
         logger.info(f"SETUP {self.name} checking login...")
 
-        # in case the user already added '.session' to the session_file
-        base_session_name = self.session_file.removesuffix(".session")
-        base_session_filepath = f"{base_session_name}.session"
-
-        if self.session_file and not os.path.exists(base_session_filepath):
-            logger.warning(
-                f"SETUP - Session file {base_session_filepath} does not exist for {self.name}, creating an empty one."
-            )
-            Path(base_session_filepath).touch()
-
         # make a copy of the session that is used exclusively with this archiver instance
-        self.session_file = os.path.join(
-            os.path.dirname(base_session_filepath), f"telethon-{date.today().strftime('%Y-%m-%d')}{random_str(8)}"
-        )
-        logger.debug(f"Making a copy of the session file {base_session_filepath} to {self.session_file}.session")
-        shutil.copy(base_session_filepath, f"{self.session_file}.session")
+        new_session_file = os.path.join("secrets/", f"telethon-{time.strftime('%Y-%m-%d')}{random_str(8)}.session")
+        shutil.copy(self.session_file + ".session", new_session_file)
+        self.session_file = new_session_file.replace(".session", "")
 
         # initiate the client
         self.client = TelegramClient(self.session_file, self.api_id, self.api_hash)
 
         with self.client.start():
-            logger.info(f"SETUP {self.name} login works.")
+            logger.success(f"SETUP {self.name} login works.")
 
         if self.join_channels and len(self.channel_invites):
             logger.info(f"SETUP {self.name} joining channels...")
@@ -103,8 +87,8 @@ class TelethonExtractor(Extractor):
                     pbar.update()
 
     def cleanup(self) -> None:
-        logger.info(f"CLEANUP {self.name} - removing session file {self.session_file}.session")
-        session_file_name = f"{self.session_file}.session"
+        logger.info(f"CLEANUP {self.name}.")
+        session_file_name = self.session_file + ".session"
         if os.path.exists(session_file_name):
             os.remove(session_file_name)
 
@@ -190,7 +174,7 @@ class TelethonExtractor(Extractor):
         if getattr(original_post, "grouped_id", None) is None:
             return [original_post] if getattr(original_post, "media", False) else []
 
-        search_ids = list(range(original_post.id - max_amp, original_post.id + max_amp + 1))
+        search_ids = [i for i in range(original_post.id - max_amp, original_post.id + max_amp + 1)]
         posts = self.client.get_messages(chat, ids=search_ids)
         media = []
         for post in posts:

src/auto_archiver/modules/thumbnail_enricher/thumbnail_enricher.py

@@ -35,18 +35,16 @@ class ThumbnailEnricher(Enricher):
                 logger.debug(f"generating thumbnails for {m.filename}")
                 duration = m.get("duration")
 
-                try:
-                    probe = ffmpeg.probe(m.filename)
-                    duration = float(
-                        next(stream for stream in probe["streams"] if stream["codec_type"] == "video")["duration"]
-                    )
-                    to_enrich.media[m_id].set("duration", duration)
-                except Exception as e:
-                    logger.warning(f"failed to get duration with FFMPEG from {m.filename}: {e}")
-
-                if not duration or type(duration) not in [float, int] or duration <= 0:
-                    logger.warning(f"cannot generate thumbnails for {m.filename} without valid duration")
-                    continue
+                if duration is None:
+                    try:
+                        probe = ffmpeg.probe(m.filename)
+                        duration = float(
+                            next(stream for stream in probe["streams"] if stream["codec_type"] == "video")["duration"]
+                        )
+                        to_enrich.media[m_id].set("duration", duration)
+                    except Exception as e:
+                        logger.error(f"error getting duration of video {m.filename}: {e}")
+                        return
 
                 num_thumbs = int(min(max(1, (duration / 60) * self.thumbnails_per_minute), self.max_thumbnails))
                 timestamps = [duration / (num_thumbs + 1) * i for i in range(1, num_thumbs + 1)]
@@ -59,9 +57,6 @@ class ThumbnailEnricher(Enricher):
                     ).run()
 
                     try:
-                        if not os.path.exists(output_path):
-                            logger.info(f"thumbnail {index} for media {m.filename} was not created")
-                            continue
                         thumbnails_media.append(
                             Media(filename=output_path)
                             .set("id", f"thumbnail_{index}")

src/auto_archiver/modules/timestamping_enricher/__manifest__.py

@@ -3,38 +3,30 @@
     "type": ["enricher"],
     "requires_setup": True,
     "dependencies": {
-        "python": ["loguru", "slugify", "cryptography", "rfc3161_client", "certifi"],
+        "python": ["loguru", "slugify", "tsp_client", "asn1crypto", "certvalidator", "certifi"],
     },
     "configs": {
         "tsa_urls": {
             "default": [
-                # See https://github.com/trailofbits/rfc3161-client/issues/46 for a list of valid TSAs
-                # Full list of TSAs: https://gist.github.com/Manouchehri/fd754e402d98430243455713efada710
-                    "http://timestamp.identrust.com",
-                    "http://timestamp.ssl.trustwave.com",
-                    "http://zeitstempel.dfn.de",
-                    "http://ts.ssl.com",
-                    # "http://tsa.izenpe.com", # self-signed
-                    "http://tsa.lex-persona.com/tsa",
-                    # "http://ca.signfiles.com/TSAServer.aspx", # self-signed
-                    # "http://tsa.sinpe.fi.cr/tsaHttp/", # self-signed
-                    # "http://tsa.cra.ge/signserver/tsa?workerName=qtsa", # self-signed
-                    "http://tss.cnbs.gob.hn/TSS/HttpTspServer",
-                    "http://dss.nowina.lu/pki-factory/tsa/good-tsa",
-                    # "https://freetsa.org/tsr", # self-signed
-                ],
+                # [Adobe Approved Trust List] and [Windows Cert Store]
+                "http://timestamp.digicert.com",
+                "http://timestamp.identrust.com",
+                # "https://timestamp.entrust.net/TSS/RFC3161sha2TS", # not valid for timestamping
+                # "https://timestamp.sectigo.com", # wait 15 seconds between each request.
+                # [Adobe: European Union Trusted Lists].
+                # "https://timestamp.sectigo.com/qualified", # wait 15 seconds between each request.
+                # [Windows Cert Store]
+                "http://timestamp.globalsign.com/tsa/r6advanced1",
+                # [Adobe: European Union Trusted Lists] and [Windows Cert Store]
+                # "http://ts.quovadisglobal.com/eu", # not valid for timestamping
+                # "http://tsa.belgium.be/connect", # self-signed certificate in certificate chain
+                # "https://timestamp.aped.gov.gr/qtss", # self-signed certificate in certificate chain
+                # "http://tsa.sep.bg", # self-signed certificate in certificate chain
+                # "http://tsa.izenpe.com", #unable to get local issuer certificate
+                # "http://kstamp.keynectis.com/KSign", # unable to get local issuer certificate
+                "http://tss.accv.es:8318/tsa",
+            ],
             "help": "List of RFC3161 Time Stamp Authorities to use, separate with commas if passed via the command line.",
-        },
-        "cert_authorities": {
-            "default": None,
-            "help": "Path to a file containing trusted Certificate Authorities (CAs) in PEM format. If empty, the default system authorities are used.",
-            "type": "str",
-        },
-        "allow_selfsigned": {
-            "default": False,
-            "help": "Whether or not to allow and save self-signed Timestamping certificates. This allows for a greater range of timestamping servers to be used, \
-but they are not trusted authorities",
-            "type": "bool"
         }
     },
     "description": """

src/auto_archiver/modules/timestamping_enricher/timestamping_enricher.py

@@ -1,23 +1,15 @@
 import os
-
-from importlib.metadata import version
-import hashlib
-
-from slugify import slugify
-import requests
 from loguru import logger
-
-from rfc3161_client import (decode_timestamp_response,TimestampRequestBuilder,TimeStampResponse, VerifierBuilder)
-from rfc3161_client import VerificationError as Rfc3161VerificationError
-from rfc3161_client.base import HashAlgorithm
-from rfc3161_client.tsp import SignedData
-from cryptography import x509
-from cryptography.hazmat.primitives import serialization
+from tsp_client import TSPSigner, SigningSettings, TSPVerifier
+from tsp_client.algorithms import DigestAlgorithm
+from importlib.metadata import version
+from asn1crypto.cms import ContentInfo
+from certvalidator import CertificateValidator, ValidationContext
+from asn1crypto import pem
 import certifi
 
 from auto_archiver.core import Enricher
 from auto_archiver.core import Metadata, Media
-from auto_archiver.version import __version__
 
 
 class TimestampingEnricher(Enricher):
@@ -29,25 +21,6 @@ class TimestampingEnricher(Enricher):
     See https://gist.github.com/Manouchehri/fd754e402d98430243455713efada710 for list of timestamp authorities.
     """
 
-    session = None
-
-    def setup(self):
-        self.session = requests.Session()
-        self.session.headers.update(
-            {
-                "Content-Type": "application/timestamp-query",
-                "User-Agent": f"Auto-Archiver {__version__}",
-                "Accept": "application/timestamp-reply",
-            }
-        )
-
-    def cleaup(self) -> None:
-        """
-        Terminates the underlying network session.
-        """
-        if self.session:
-            self.session.close()
-
     def enrich(self, to_enrich: Metadata) -> None:
         url = to_enrich.get_url()
         logger.debug(f"RFC3161 timestamping existing files for {url=}")
@@ -58,11 +31,11 @@ class TimestampingEnricher(Enricher):
         ]
 
         if not len(hashes):
-            logger.debug(f"No hashes found in {url=}")
+            logger.warning(f"No hashes found in {url=}")
             return
 
-        
-        hashes_fn = os.path.join(self.tmp_dir, "hashes.txt")
+        tmp_dir = self.tmp_dir
+        hashes_fn = os.path.join(tmp_dir, "hashes.txt")
 
         data_to_sign = "\n".join(hashes)
         with open(hashes_fn, "w") as f:
@@ -70,160 +43,62 @@ class TimestampingEnricher(Enricher):
         hashes_media = Media(filename=hashes_fn)
 
         timestamp_tokens = []
+        from slugify import slugify
+
         for tsa_url in self.tsa_urls:
             try:
-                message = bytes(data_to_sign, encoding='utf8')
-
-                logger.debug(f"Timestamping {url=} with {tsa_url=}")
-                signed: TimeStampResponse = self.sign_data(tsa_url, message)
-                
-                # fail if there's any issue with the certificates, uses certifi list of trusted CAs or the user-defined `cert_authorities`
-                root_cert = self.verify_signed(signed, message)
-
-                if not root_cert:
-                    if self.allow_selfsigned:
-                        logger.warning(f"Allowing self-signed certificat from TSA {tsa_url=}")
-                    else:
-                        raise ValueError(f"No valid root certificate found for {tsa_url=}. Are you sure it's a trusted TSA? Or define an alternative trusted root with `cert_authorities`. (tried: {self.cert_authorities or certifi.where()})")
-
-                # save the timestamping certificate
-                cert_chain = self.save_certificate(signed, root_cert)
-
-                timestamp_token_path = self.save_timestamp_token(signed.time_stamp_token(), tsa_url)
-                timestamp_tokens.append(Media(filename=timestamp_token_path).set("tsa", tsa_url).set("cert_chain", cert_chain))
+                signing_settings = SigningSettings(tsp_server=tsa_url, digest_algorithm=DigestAlgorithm.SHA256)
+                signer = TSPSigner()
+                message = bytes(data_to_sign, encoding="utf8")
+                # send TSQ and get TSR from the TSA server
+                signed = signer.sign(message=message, signing_settings=signing_settings)
+                # fail if there's any issue with the certificates, uses certifi list of trusted CAs
+                TSPVerifier(certifi.where()).verify(signed, message=message)
+                # download and verify timestamping certificate
+                cert_chain = self.download_and_verify_certificate(signed)
+                # continue with saving the timestamp token
+                tst_fn = os.path.join(tmp_dir, f"timestamp_token_{slugify(tsa_url)}")
+                with open(tst_fn, "wb") as f:
+                    f.write(signed)
+                timestamp_tokens.append(Media(filename=tst_fn).set("tsa", tsa_url).set("cert_chain", cert_chain))
             except Exception as e:
                 logger.warning(f"Error while timestamping {url=} with {tsa_url=}: {e}")
 
         if len(timestamp_tokens):
             hashes_media.set("timestamp_authority_files", timestamp_tokens)
             hashes_media.set("certifi v", version("certifi"))
-            hashes_media.set("rfc3161-client v", version("rfc3161_client"))
-            hashes_media.set("cryptography v", version("cryptography"))
+            hashes_media.set("tsp_client v", version("tsp_client"))
+            hashes_media.set("certvalidator v", version("certvalidator"))
             to_enrich.add_media(hashes_media, id="timestamped_hashes")
             to_enrich.set("timestamped", True)
-            logger.info(f"{len(timestamp_tokens)} timestamp tokens created for {url=}")
+            logger.success(f"{len(timestamp_tokens)} timestamp tokens created for {url=}")
         else:
             logger.warning(f"No successful timestamps for {url=}")
 
-    def save_timestamp_token(self, timestamp_token: bytes, tsa_url: str) -> str:
-        """
-        Takes a timestamp token, and saves it to a file with the TSA URL as part of the filename.
-        """
-        tst_path = os.path.join(self.tmp_dir, f"timestamp_token_{slugify(tsa_url)}")
-        with open(tst_path, "wb") as f:
-            f.write(timestamp_token)
-        return tst_path
-
-    def verify_signed(self, timestamp_response: TimeStampResponse, message: bytes) ->  x509.Certificate:
-        """
-        Verify a Signed Timestamp Response is trusted by a known Certificate Authority.
-
-        Args:
-            timestamp_response (TimeStampResponse): The signed timestamp response.
-            message (bytes): The message that was timestamped.
-
-        Returns:
-            x509.Certificate: A valid root certificate that was used to sign the timestamp response, or None
-
-        Raises:
-            ValueError: If no valid root certificate was found in the trusted root store.
-        """
-
-        trusted_root_path = self.cert_authorities or certifi.where()
-        cert_authorities = []
-
-        with open(trusted_root_path, 'rb') as f:
-            cert_authorities = x509.load_pem_x509_certificates(f.read())
-
-        if not cert_authorities:
-            raise ValueError(f"No trusted roots found in {trusted_root_path}.")
-        
-        timestamp_certs = self.tst_certs(timestamp_response)
-        intermediate_certs = timestamp_certs[1:-1]
-
-        message_hash = None
-        hash_algorithm = timestamp_response.tst_info.message_imprint.hash_algorithm
-        if hash_algorithm == x509.ObjectIdentifier(value="2.16.840.1.101.3.4.2.3"):
-            message_hash = hashlib.sha512(message).digest()
-        elif hash_algorithm == x509.ObjectIdentifier(value="2.16.840.1.101.3.4.2.1"):
-            message_hash = hashlib.sha256(message).digest()
-        else:
-            raise ValueError(f"Unsupported hash algorithm: {hash_algorithm}")
-        
-        for certificate in cert_authorities:
-            builder = VerifierBuilder()
-            builder.add_root_certificate(certificate)
-
-            for intermediate_cert in intermediate_certs:
-                builder.add_intermediate_certificate(intermediate_cert)
-
-            verifier = builder.build()
-
-            
-            try:
-                verifier.verify(timestamp_response, message_hash)
-                return certificate
-            except Rfc3161VerificationError:
-                continue
-
-        return None
-
-    def sign_data(self, tsa_url: str, bytes_data: bytes) -> TimeStampResponse:
-        # see https://github.com/sigstore/sigstore-python/blob/99948d5b80525a5a104e904ffea58169dc6e0629/sigstore/_internal/timestamp.py#L84-L121
-
-        timestamp_request = (
-                TimestampRequestBuilder().data(bytes_data).nonce(nonce=True).build()
-            )
-        try:
-            response = self.session.post(tsa_url, data=timestamp_request.as_bytes(), timeout=10)
-            response.raise_for_status()
-        except requests.RequestException as e:
-            logger.error(f"Error while sending request to {tsa_url=}: {e}")
-            raise
-
-        # Check that we can parse the response but do not *verify* it
-        try:
-            timestamp_response = decode_timestamp_response(response.content)
-        except ValueError as e:
-            logger.error(f"Invalid timestamp response from server {tsa_url}: {e}")
-            raise
-        return timestamp_response
-    
-    def tst_certs(self, tsp_response: TimeStampResponse):
-        signed_data: SignedData = tsp_response.signed_data
-        certs = [x509.load_der_x509_certificate(c) for c in signed_data.certificates]
-        # reorder the certs to be in the correct order
-        ordered_certs = []
-        if len(certs) == 1:
-            return certs
-
-        while(len(ordered_certs) < len(certs)):
-            if len(ordered_certs) == 0:
-                for cert in certs:
-                    if not [c for c in certs if cert.subject == c.issuer]:
-                        ordered_certs.append(cert)
-                        break
-            else:
-                for cert in certs:
-                    if cert.subject == ordered_certs[-1].issuer:
-                        ordered_certs.append(cert)
-                        break
-        return ordered_certs
-
-    def save_certificate(self, tsp_response: TimeStampResponse, verified_root_cert: x509.Certificate) -> list[Media]:
+    def download_and_verify_certificate(self, signed: bytes) -> list[Media]:
         # returns the leaf certificate URL, fails if not set
+        tst = ContentInfo.load(signed)
 
-        certificates = self.tst_certs(tsp_response)
+        trust_roots = []
+        with open(certifi.where(), "rb") as f:
+            for _, _, der_bytes in pem.unarmor(f.read(), multiple=True):
+                trust_roots.append(der_bytes)
+        context = ValidationContext(trust_roots=trust_roots)
 
-        if verified_root_cert:
-            # add the verified root certificate (if there is one - self signed certs will have None here)
-            certificates += [verified_root_cert]
+        certificates = tst["content"]["certificates"]
+        first_cert = certificates[0].dump()
+        intermediate_certs = []
+        for i in range(1, len(certificates)):  # cannot use list comprehension [1:]
+            intermediate_certs.append(certificates[i].dump())
+
+        validator = CertificateValidator(first_cert, intermediate_certs=intermediate_certs, validation_context=context)
+        path = validator.validate_usage({"digital_signature"}, extended_key_usage={"time_stamping"})
 
         cert_chain = []
-        for i, cert in enumerate(certificates):
-            cert_fn = os.path.join(self.tmp_dir, f"{i+1} – {str(cert.serial_number)[:20]}.crt")
+        for cert in path:
+            cert_fn = os.path.join(self.tmp_dir, f"{str(cert.serial_number)[:20]}.crt")
             with open(cert_fn, "wb") as f:
-                f.write(cert.public_bytes(encoding=serialization.Encoding.PEM))
-            cert_chain.append(Media(filename=cert_fn).set("subject", cert.subject.get_attributes_for_oid(x509.NameOID.COMMON_NAME)[0].value))
+                f.write(cert.dump())
+            cert_chain.append(Media(filename=cert_fn).set("subject", cert.subject.native["common_name"]))
 
         return cert_chain

src/auto_archiver/modules/twitter_api_extractor/twitter_api_extractor.py

@@ -1,4 +1,3 @@
-from datetime import timezone
 import json
 import re
 import mimetypes
@@ -92,9 +91,7 @@ class TwitterApiExtractor(Extractor):
 
         result = Metadata()
         result.set_title(tweet.data.text)
-        result.set_timestamp(
-            get_datetime_from_str(tweet.data.created_at, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=timezone.utc)
-        )
+        result.set_timestamp(get_datetime_from_str(tweet.data.created_at, "%Y-%m-%dT%H:%M:%S.%fZ"))
 
         urls = []
         if tweet.includes:

src/auto_archiver/modules/vk_extractor/__init__.py

@@ -0,0 +1 @@
+from .vk_extractor import VkExtractor

src/auto_archiver/modules/vk_extractor/__manifest__.py

@@ -0,0 +1,37 @@
+{
+    "name": "VKontakte Extractor",
+    "type": ["extractor"],
+    "requires_setup": True,
+    "depends": ["core", "utils"],
+    "dependencies": {
+        "python": ["loguru", "vk_url_scraper"],
+    },
+    "configs": {
+        "username": {"required": True, "help": "valid VKontakte username"},
+        "password": {"required": True, "help": "valid VKontakte password"},
+        "session_file": {
+            "default": "secrets/vk_config.v2.json",
+            "help": "valid VKontakte password",
+        },
+    },
+    "description": """
+The `VkExtractor` fetches posts, text, and images from VK (VKontakte) social media pages. 
+This archiver is specialized for `/wall` posts and uses the `VkScraper` library to extract 
+and download content. Note that VK videos are handled separately by the `YTDownloader`.
+
+### Features
+- Extracts text, timestamps, and metadata from VK `/wall` posts.
+- Downloads associated images and attaches them to the resulting `Metadata` object.
+- Processes multiple segments of VK URLs that contain mixed content (e.g., wall, photo).
+- Outputs structured metadata and media using `Metadata` and `Media` objects.
+
+### Setup
+To use the `VkArchiver`, you must provide valid VKontakte login credentials and session information:
+- **Username**: A valid VKontakte account username.
+- **Password**: The corresponding password for the VKontakte account.
+- **Session File**: Optional. Path to a session configuration file (`.json`) for persistent VK login.
+
+Credentials can be set in the configuration file or directly via environment variables. Ensure you 
+have access to the VKontakte API by creating an account at [VKontakte](https://vk.com/).
+""",
+}

src/auto_archiver/modules/vk_extractor/vk_extractor.py

@@ -0,0 +1,43 @@
+from loguru import logger
+from vk_url_scraper import VkScraper
+
+from auto_archiver.utils.misc import dump_payload
+from auto_archiver.core import Extractor
+from auto_archiver.core import Metadata, Media
+
+
+class VkExtractor(Extractor):
+    """ "
+    VK videos are handled by YTDownloader, this archiver gets posts text and images.
+    Currently only works for /wall posts
+    """
+
+    def setup(self) -> None:
+        self.vks = VkScraper(self.username, self.password, session_file=self.session_file)
+
+    def download(self, item: Metadata) -> Metadata:
+        url = item.get_url()
+
+        if "vk.com" not in item.netloc:
+            return False
+
+        # some urls can contain multiple wall/photo/... parts and all will be fetched
+        vk_scrapes = self.vks.scrape(url)
+        if not len(vk_scrapes):
+            return False
+        logger.debug(f"VK: got {len(vk_scrapes)} scraped instances")
+
+        result = Metadata()
+        for scrape in vk_scrapes:
+            if not result.get_title():
+                result.set_title(scrape["text"])
+            if not result.get_timestamp():
+                result.set_timestamp(scrape["datetime"])
+
+        result.set_content(dump_payload(vk_scrapes))
+
+        filenames = self.vks.download_media(vk_scrapes, self.tmp_dir)
+        for filename in filenames:
+            result.add_media(Media(filename))
+
+        return result.success("vk")

src/auto_archiver/modules/wacz_extractor_enricher/__manifest__.py

@@ -40,31 +40,27 @@
     Creates .WACZ archives of web pages using the `browsertrix-crawler` tool, with options for media extraction and screenshot saving.
     [Browsertrix-crawler](https://crawler.docs.browsertrix.com/user-guide/) is a headless browser-based crawler that archives web pages in WACZ format.
 
+    ## Setup
+
+    **Docker**
+    If you are using the Docker file to run Auto Archiver (recommended), then everything is set up and you can use WACZ out of the box!
+    Otherwise, if you are using a local install of Auto Archiver (e.g. pip or dev install), then you will need to install Docker and run 
+    the docker daemon to be able to run the `browsertrix-crawler` tool.
+
+    **Browsertrix Profiles**
+    A browsertrix profile is a custom browser profile (login information, browser extensions, etc.) that can be used to archive private or dynamic content.
+    You can run the WACZ Enricher without a profile, but for more resilient archiving, it is recommended to create a profile. See the [Browsertrix documentation](https://crawler.docs.browsertrix.com/user-guide/browser-profiles/)
+    for more information.
+
+    ** Docker in Docker **
+    If you are running Auto Archiver within a Docker container, you will need to enable Docker in Docker to run the `browsertrix-crawler` tool.
+    This can be done by setting the `WACZ_ENABLE_DOCKER` environment variable to `1`.
+
     ## Features
     - Archives web pages into .WACZ format using Docker or direct invocation of `browsertrix-crawler`.
     - Supports custom profiles for archiving private or dynamic content.
     - Extracts media (images, videos, audio) and screenshots from the archive, optionally adding them to the enrichment pipeline.
     - Generates metadata from the archived page's content and structure (e.g., titles, text).
 
-    ## Setup
-
-    ### Using Docker
-    If you are using the Auto Archiver [Docker image](https://auto-archiver.readthedocs.io/en/latest/installation/installation.html#installing-with-docker)
-    to run Auto Archiver (recommended), then everything is set up and you can use WACZ out of the box!
-    Otherwise, if you are using a local install of Auto Archiver (e.g. pip or dev install), then you will need to install Docker and run 
-    the docker daemon to be able to run the `browsertrix-crawler` tool.
-
-    ### Browsertrix Profiles
-    A browsertrix profile is a custom browser profile (login information, browser extensions, etc.) that can be used to archive private or dynamic content.
-    You can run the WACZ Enricher without a profile, but for more resilient archiving, it is recommended to create a profile.
-    See the [Browsertrix documentation](https://crawler.docs.browsertrix.com/user-guide/browser-profiles/) for more information on how to use the `create-login-profile` tool.
-
-
-
-    ### Docker in Docker
-    If you are running Auto Archiver within a Docker container, you will need to enable Docker in Docker to run the `browsertrix-crawler` tool.
-    This can be done by setting the `WACZ_ENABLE_DOCKER` environment variable to `1`.
-
-
     """,
 }

src/auto_archiver/modules/wacz_extractor_enricher/wacz_extractor_enricher.py

@@ -86,12 +86,6 @@ class WaczExtractorEnricher(Enricher, Extractor):
         if self.docker_in_docker:
             cmd.extend(["--cwd", self.cwd_dind])
 
-        if self.auth_for_site(url):
-            # there's an auth for this site, but browsertrix only supports username/password auth
-            logger.warning(
-                "The WACZ enricher / Browsertrix does not support using the 'authentication' information for logging in. You should consider creating a Browser Profile for WACZ archiving. More information: https://auto-archiver.readthedocs.io/en/latest/modules/autogen/extractor/wacz_extractor_enricher.html#browsertrix-profiles"
-            )
-
         # call docker if explicitly enabled or we are running on the host (not in docker)
         if self.use_docker:
             logger.debug(f"generating WACZ in Docker for {url=}")
@@ -194,8 +188,7 @@ class WaczExtractorEnricher(Enricher, Extractor):
                         shutil.copyfileobj(infile, outfile)
 
         # get media out of .warc
-        counter_warc_files = 0
-        counter_screenshots = 0
+        counter = 0
         seen_urls = set()
 
         with open(warc_filename, "rb") as warc_stream:
@@ -204,12 +197,12 @@ class WaczExtractorEnricher(Enricher, Extractor):
                 if (
                     record.rec_type == "resource" and record.content_type == "image/png" and self.extract_screenshot
                 ):  # screenshots
-                    fn = os.path.join(tmp_dir, f"browsertrix-screenshot-{counter_screenshots}.png")
+                    fn = os.path.join(tmp_dir, f"warc-file-{counter}.png")
                     with open(fn, "wb") as outf:
                         outf.write(record.raw_stream.read())
                     m = Media(filename=fn)
-                    to_enrich.add_media(m, f"browsertrix-screenshot-{counter_screenshots}")
-                    counter_screenshots += 1
+                    to_enrich.add_media(m, "browsertrix-screenshot")
+                    counter += 1
                 if not self.extract_media:
                     continue
 
@@ -232,7 +225,7 @@ class WaczExtractorEnricher(Enricher, Extractor):
 
                 # create local file and add media
                 ext = mimetypes.guess_extension(content_type)
-                warc_fn = f"warc-file-{counter_warc_files}{ext}"
+                warc_fn = f"warc-file-{counter}{ext}"
                 fn = os.path.join(tmp_dir, warc_fn)
 
                 record_url_best_qual = UrlUtil.twitter_best_quality_url(record_url)
@@ -257,8 +250,6 @@ class WaczExtractorEnricher(Enricher, Extractor):
                     continue
 
                 to_enrich.add_media(m, warc_fn)
-                counter_warc_files += 1
+                counter += 1
                 seen_urls.add(record_url)
-        logger.info(
-            f"WACZ extract_media/extract_screenshot finished, found {counter_warc_files + counter_screenshots} relevant media file(s)"
-        )
+        logger.info(f"WACZ extract_media/extract_screenshot finished, found {counter} relevant media file(s)")

src/auto_archiver/utils/__init__.py

@@ -2,6 +2,7 @@
 
 # we need to explicitly expose the available imports here
 from .misc import *
+from .webdriver import Webdriver
 
 # handy utils from ytdlp
 from yt_dlp.utils import clean_html, traverse_obj, strip_or_none, url_or_none

src/auto_archiver/utils/misc.py

@@ -1,6 +1,5 @@
 import hashlib
 import json
-import mimetypes
 import os
 import uuid
 from datetime import datetime, timezone
@@ -117,26 +116,3 @@ def get_timestamp(ts, utc=True, iso=True, dayfirst=True) -> str | datetime | Non
 
 def get_current_timestamp() -> str:
     return get_timestamp(datetime.now())
-
-
-def ydl_entry_to_filename(ydl, entry: dict) -> str:
-    import yt_dlp
-
-    ydl: yt_dlp.YoutubeDL
-    entry_url = entry.get("url")
-
-    filename = ydl.prepare_filename(entry)
-    if os.path.exists(filename):
-        return filename
-
-    base_filename, _ = os.path.splitext(filename)  # '/get/path/to/file' ignore '.ext'
-    directory = os.path.dirname(base_filename)  # '/get/path/to'
-    basename = os.path.basename(base_filename)  # 'file'
-    for f in os.listdir(directory):
-        if (
-            f.startswith(basename)
-            or (entry_url and os.path.splitext(f)[0] in entry_url)
-            and "video/" in (mimetypes.guess_type(f)[0] or "")
-        ):
-            return os.path.join(directory, f)
-    return False

src/auto_archiver/utils/url.py

@@ -1,5 +1,5 @@
 import re
-from urllib.parse import parse_qsl, urlencode, urlparse, urlunparse
+from urllib.parse import urlparse, urlunparse
 from ipaddress import ip_address
 
 
@@ -53,11 +53,7 @@ def domain_for_url(url: str) -> str:
 
 
 def clean(url: str) -> str:
-    TRACKERS = {"utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content", "fbclid", "gclid"}
-
-    parsed = urlparse(url)
-    clean_qs = [(k, v) for k, v in parse_qsl(parsed.query) if k not in TRACKERS]
-    return parsed._replace(query=urlencode(clean_qs)).geturl()
+    return url
 
 
 def is_auth_wall(url: str) -> bool:
@@ -82,8 +78,6 @@ def remove_get_parameters(url: str) -> str:
 def is_relevant_url(url: str) -> bool:
     """
     Detect if a detected media URL is recurring and therefore irrelevant to a specific archive. Useful, for example, for the enumeration of the media files in WARC files which include profile pictures, favicons, etc.
-
-    Assumption: URLs are relevant if they refer to files that can be downloaded with curl/requests, so excludes extensions like .m3u8.
     """
     clean_url = remove_get_parameters(url)
 
@@ -110,21 +104,11 @@ def is_relevant_url(url: str) -> bool:
         ("vk.com/images/reaction/",),
         # wikipedia
         ("wikipedia.org/static",),
-        # reddit
-        ("styles.redditmedia.com",),  # opinionated but excludes may irrelevant images like avatars and banners
-        ("emoji.redditmedia.com",),
-        # linkedin
-        ("static.licdn.com",),
     ]
 
-    # TODO: make these globally configurable
     IRRELEVANT_ENDS_WITH = [
         ".svg",  # ignore SVGs
         ".ico",  # ignore icons
-        # ignore index files for videos, these should be handled by ytdlp
-        ".m3u8",
-        ".mpd",
-        ".ism",
     ]
 
     for end in IRRELEVANT_ENDS_WITH:
@@ -141,36 +125,6 @@ def is_relevant_url(url: str) -> bool:
 def twitter_best_quality_url(url: str) -> str:
     """
     some twitter image URLs point to a less-than best quality
-    this returns the URL pointing to the highest (original) quality (with 'name=orig')
+    this returns the URL pointing to the highest (original) quality
     """
-    parsed = urlparse(url)
-    query = parsed.query
-    if "name=" in query:
-        # Replace only the first occurrence of name=xxx with name=orig
-        new_query = re.sub(r"name=[^&]*", "name=orig", query, 1)
-        parsed = parsed._replace(query=new_query)
-        return urlunparse(parsed)
-    return url
-
-
-def get_media_url_best_quality(url: str) -> str:
-    """
-    Returns the best quality URL for the given media URL, it may not exist.
-    """
-    parsed = urlparse(url)
-
-    # twitter case
-    if any(d in parsed.netloc.replace("www", "") for d in ("twitter.com", "twimg.com", "x.com")):
-        url = twitter_best_quality_url(url)
-        parsed = urlparse(url)
-
-    # some cases https://example.com/media-1280x720.mp4 to https://example.com/media.mp4
-    basename = parsed.path.split("/")[-1]
-    match = re.match(r"(.+)-\d+x\d+(\.[a-zA-Z0-9]+)$", basename)
-    if match:
-        orig_basename = match.group(1) + match.group(2)
-        new_path = "/".join(parsed.path.split("/")[:-1] + [orig_basename])
-        parsed = parsed._replace(path=new_path)  # keep the query unchanged
-        url = urlunparse(parsed)
-
-    return url
+    return re.sub(r"name=(\w+)", "name=orig", url, 1)

src/auto_archiver/utils/webdriver.py

@@ -0,0 +1,167 @@
+"""This Webdriver class acts as a context manager for the selenium webdriver."""
+
+from __future__ import annotations
+
+import os
+import time
+import re
+
+# import domain_for_url
+from urllib.parse import urlparse, urlunparse
+from http.cookiejar import MozillaCookieJar
+
+from selenium import webdriver
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common import exceptions as selenium_exceptions
+from selenium.webdriver.common.print_page_options import PrintOptions
+from selenium.webdriver.common.by import By
+
+from loguru import logger
+
+
+class CookieSettingDriver(webdriver.Firefox):
+    facebook_accept_cookies: bool
+    cookie: str
+    cookie_jar: MozillaCookieJar
+
+    def __init__(self, cookie, cookie_jar, facebook_accept_cookies, *args, **kwargs):
+        if os.environ.get("RUNNING_IN_DOCKER"):
+            # Selenium doesn't support linux-aarch64 driver, we need to set this manually
+            kwargs["service"] = webdriver.FirefoxService(executable_path="/usr/local/bin/geckodriver")
+
+        super(CookieSettingDriver, self).__init__(*args, **kwargs)
+        self.cookie = cookie
+        self.cookie_jar = cookie_jar
+        self.facebook_accept_cookies = facebook_accept_cookies
+
+    def get(self, url: str):
+        if self.cookie_jar or self.cookie:
+            # set up the driver to make it not 'cookie averse' (needs a context/URL)
+            # get the 'robots.txt' file which should be quick and easy
+            robots_url = urlunparse(urlparse(url)._replace(path="/robots.txt", query="", fragment=""))
+            super(CookieSettingDriver, self).get(robots_url)
+
+            if self.cookie:
+                # an explicit cookie is set for this site, use that first
+                for cookie in self.cookies.split(";"):
+                    for name, value in cookie.split("="):
+                        self.driver.add_cookie({"name": name, "value": value})
+            elif self.cookie_jar:
+                domain = urlparse(url).netloc.removeprefix("www.")
+                regex = re.compile(f"(www)?.?{domain}$")
+                for cookie in self.cookie_jar:
+                    if regex.match(cookie.domain):
+                        try:
+                            self.add_cookie(
+                                {
+                                    "name": cookie.name,
+                                    "value": cookie.value,
+                                    "path": cookie.path,
+                                    "domain": cookie.domain,
+                                    "secure": bool(cookie.secure),
+                                    "expiry": cookie.expires,
+                                }
+                            )
+                        except Exception as e:
+                            logger.warning(f"Failed to add cookie ({cookie.domain}) to webdriver for url {domain}: {e}")
+
+        super(CookieSettingDriver, self).get(url)
+        time.sleep(2)
+
+        # Try and use some common button text to reject/accept cookies
+        for text in [
+            "Refuse non-essential cookies",
+            "Decline optional cookies",
+            "Reject additional cookies",
+            "Reject all",
+            "Accept all cookies",
+        ]:
+            try:
+                xpath = f"//*[contains(translate(text(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), '{text.lower()}')]"
+                self.find_element(By.XPATH, xpath).click()
+                time.sleep(2)
+            except selenium_exceptions.NoSuchElementException:
+                pass
+
+        # now get the actual URL
+        if self.facebook_accept_cookies:
+            # try and click the 'close' button on the 'login' window to close it
+            try:
+                xpath = "//div[@role='dialog']//div[@aria-label='Close']"
+                self.find_element(By.XPATH, xpath).click()
+                time.sleep(2)
+            except selenium_exceptions.NoSuchElementException:
+                logger.warning("Unable to find the 'close' button on the facebook login window")
+                pass
+
+        else:
+            # for all other sites, try and use some common button text to reject/accept cookies
+            for text in [
+                "Refuse non-essential cookies",
+                "Decline optional cookies",
+                "Reject additional cookies",
+                "Reject all",
+                "Accept all cookies",
+            ]:
+                try:
+                    xpath = f"//*[contains(translate(text(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), '{text.lower()}')]"
+                    WebDriverWait(self, 5).until(EC.element_to_be_clickable((By.XPATH, xpath))).click()
+                    break
+                except selenium_exceptions.WebDriverException:
+                    pass
+
+
+class Webdriver:
+    def __init__(
+        self,
+        width: int,
+        height: int,
+        timeout_seconds: int,
+        facebook_accept_cookies: bool = False,
+        http_proxy: str = "",
+        print_options: dict = {},
+        auth: dict = {},
+    ) -> webdriver:
+        self.width = width
+        self.height = height
+        self.timeout_seconds = timeout_seconds
+        self.auth = auth
+        self.facebook_accept_cookies = facebook_accept_cookies
+        self.http_proxy = http_proxy
+        # create and set print options
+        self.print_options = PrintOptions()
+        for k, v in print_options.items():
+            setattr(self.print_options, k, v)
+
+    def __enter__(self) -> webdriver:
+        options = webdriver.FirefoxOptions()
+        options.add_argument("--headless")
+        options.add_argument(f"--proxy-server={self.http_proxy}")
+        options.set_preference("network.protocol-handler.external.tg", False)
+        # if facebook cookie popup is present, force the browser to English since then it's easier to click the 'Decline optional cookies' option
+        if self.facebook_accept_cookies:
+            options.add_argument("--lang=en")
+
+        try:
+            self.driver = CookieSettingDriver(
+                cookie=self.auth.get("cookie"),
+                cookie_jar=self.auth.get("cookies_jar"),
+                facebook_accept_cookies=self.facebook_accept_cookies,
+                options=options,
+            )
+            self.driver.set_window_size(self.width, self.height)
+            self.driver.set_page_load_timeout(self.timeout_seconds)
+            self.driver.print_options = self.print_options
+        except selenium_exceptions.TimeoutException as e:
+            logger.error(
+                f"failed to get new webdriver, possibly due to insufficient system resources or timeout settings: {e}"
+            )
+
+        return self.driver
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.driver.close()
+        self.driver.quit()
+        del self.driver
+        return True

tests/.env.test.example

@@ -1,13 +0,0 @@
-# ANTIBOT reddit test credentials
-REDDIT_TEST_USERNAME=""
-REDDIT_TEST_PASSWORD=""
-
-# ANTIBOT linkedin test credentials
-LINKEDIN_TEST_USERNAME=""
-LINKEDIN_TEST_PASSWORD=""
-
-# twitter test credentials
-TWITTER_BEARER_TOKEN="TEST_KEY"
-
-# some geo/VPN IPs are blocked by truth social, disable if you have issues
-TEST_TRUTH_SOCIAL="true"

tests/conftest.py

@@ -9,51 +9,15 @@ from tempfile import TemporaryDirectory
 from typing import Dict, Tuple
 import hashlib
 
-from loguru import logger
 import pytest
-from auto_archiver.core.metadata import Metadata, Media
+from auto_archiver.core.metadata import Metadata
 from auto_archiver.core.module import ModuleFactory
 
 # Test names inserted into this list will be run last. This is useful for expensive/costly tests
 # that you only want to run if everything else succeeds (e.g. API calls). The order here is important
 # what comes first will be run first (at the end of all other tests not mentioned)
 # format is the name of the module (python file) without the .py extension
-TESTS_TO_RUN_LAST = ["test_generic_archiver", "test_twitter_api_archiver"]
-
-
-def pytest_configure():
-    # load environment variables from .env.test file.
-    env_path = os.path.join(os.path.dirname(__file__), ".env.test")
-    if os.path.exists(env_path):
-        with open(env_path) as f:
-            for line in f:
-                line = line.strip()
-                if not line or line.startswith("#"):
-                    continue
-                if "=" in line:
-                    key, value = line.split("=", 1)
-                    os.environ[key.strip()] = value.strip().lstrip('"').rstrip('"')
-    else:
-        logger.warning(
-            f"Environment file {env_path} not found. Skipping loading environment variables, some tests may fail."
-        )
-
-
-# don't check for ytdlp updates in tests
-@pytest.fixture(autouse=True)
-def skip_check_for_update(mocker):
-    update_ytdlp = mocker.patch(
-        "auto_archiver.modules.generic_extractor.generic_extractor.GenericExtractor.update_package"
-    )
-    update_ytdlp.return_value = False
-
-
-@pytest.fixture
-def get_lazy_module():
-    def _get_lazy_module(module_name):
-        return ModuleFactory().get_module_lazy(module_name)
-
-    return _get_lazy_module
+TESTS_TO_RUN_LAST = ["test_twitter_api_archiver"]
 
 
 @pytest.fixture
@@ -170,21 +134,12 @@ def unpickle():
 
 @pytest.fixture
 def mock_binary_dependencies(mocker):
-    mocker.patch("subprocess.run").return_value = mocker.Mock(returncode=0)
     mock_shutil_which = mocker.patch("shutil.which")
     # Mock all binary dependencies as available
     mock_shutil_which.return_value = "/usr/bin/fake_binary"
     return mock_shutil_which
 
 
-@pytest.fixture
-def sample_media(tmp_path) -> Media:
-    """Fixture creating a Media object with temporary source file"""
-    src_file = tmp_path / "source.txt"
-    src_file.write_text("test content")
-    return Media(_key="subdir/test.txt", filename=str(src_file))
-
-
 @pytest.fixture
 def sample_datetime():
     return datetime(2023, 1, 1, 12, 0, tzinfo=timezone.utc)

tests/data/test_modules/example_extractor/example_extractor.py

@@ -1,11 +1,6 @@
 from auto_archiver.core import Extractor
 
-from loguru import logger
-
 
 class ExampleExtractor(Extractor):
     def download(self, item):
-        logger.info("download")
-
-    def cleanup(self):
-        logger.info("cleanup")
+        print("download")

tests/data/test_modules/example_module/example_module.py

@@ -1,29 +1,27 @@
 from auto_archiver.core import Extractor, Enricher, Feeder, Database, Storage, Formatter, Metadata
 
-from loguru import logger
-
 
 class ExampleModule(Extractor, Enricher, Feeder, Database, Storage, Formatter):
     def download(self, item):
-        logger.info("download")
+        print("download")
 
     def __iter__(self):
         yield Metadata().set_url("https://example.com")
 
     def done(self, result):
-        logger.info("done")
+        print("done")
 
     def enrich(self, to_enrich):
-        logger.info("enrich")
+        print("enrich")
 
     def get_cdn_url(self, media):
         return "nice_url"
 
     def save(self, item):
-        logger.info("save")
+        print("save")
 
     def uploadf(self, file, key, **kwargs):
-        logger.info("uploadf")
+        print("uploadf")
 
     def format(self, item):
-        logger.info("format")
+        print("format")

tests/enrichers/test_screenshot_enricher.py

@@ -0,0 +1,216 @@
+import base64
+
+import pytest
+from selenium.common.exceptions import TimeoutException
+
+from auto_archiver.core import Metadata, Media
+from auto_archiver.modules.screenshot_enricher import ScreenshotEnricher
+
+
+@pytest.fixture
+def mock_selenium_env(mocker):
+    """Patches Selenium calls and driver checks in one place."""
+
+    # Patch external dependencies
+    mock_which = mocker.patch("shutil.which")
+    mock_driver_class = mocker.patch("auto_archiver.utils.webdriver.CookieSettingDriver")
+    mock_binary_paths = mocker.patch("selenium.webdriver.common.selenium_manager.SeleniumManager.binary_paths")
+    mocker.patch("pathlib.Path.is_file", return_value=True)
+    mock_popen = mocker.patch("subprocess.Popen")
+    mocker.patch("selenium.webdriver.common.service.Service.is_connectable", return_value=True)
+    mock_firefox_options = mocker.patch("selenium.webdriver.FirefoxOptions")
+
+    # Define side effect for `shutil.which`
+    def mock_which_side_effect(dep):
+        return "/mock/geckodriver" if dep == "geckodriver" else None
+
+    mock_which.side_effect = mock_which_side_effect
+
+    # Mock binary paths
+    mock_binary_paths.return_value = {
+        "driver_path": "/mock/driver",
+        "browser_path": "/mock/browser",
+    }
+    # Mock `subprocess.Popen`
+    mock_proc = mocker.MagicMock()
+    mock_proc.poll.return_value = None
+    mock_popen.return_value = mock_proc
+    # Mock `CookieSettingDriver`
+    mock_driver = mocker.MagicMock()
+    mock_driver_class.return_value = mock_driver
+    # Mock `FirefoxOptions`
+    mock_options_instance = mocker.MagicMock()
+    mock_firefox_options.return_value = mock_options_instance
+    yield mock_driver, mock_driver_class, mock_options_instance
+
+
+@pytest.fixture
+def common_patches(tmp_path, mocker):
+    """Patches common utilities used across multiple tests."""
+    mocker.patch("auto_archiver.utils.url.is_auth_wall", return_value=False)
+    mocker.patch("os.path.join", return_value=str(tmp_path / "test.png"))
+    mocker.patch("time.sleep")
+    yield
+
+
+@pytest.fixture
+def screenshot_enricher(setup_module, mock_binary_dependencies) -> ScreenshotEnricher:
+    configs: dict = {
+        "width": 1280,
+        "height": 720,
+        "timeout": 60,
+        "sleep_before_screenshot": 4,
+        "http_proxy": "",
+        "save_to_pdf": "False",
+        "print_options": {},
+    }
+    return setup_module("screenshot_enricher", configs)
+
+
+@pytest.fixture
+def metadata_with_video():
+    m = Metadata()
+    m.set_url("https://example.com")
+    m.add_media(Media(filename="video.mp4").set("id", "video1"))
+    return m
+
+
+def test_enrich_adds_screenshot(
+    screenshot_enricher,
+    metadata_with_video,
+    mock_selenium_env,
+    common_patches,
+    tmp_path,
+):
+    mock_driver, mock_driver_class, mock_options_instance = mock_selenium_env
+    screenshot_enricher.enrich(metadata_with_video)
+    mock_driver_class.assert_called_once_with(
+        cookie=None,
+        cookie_jar=None,
+        facebook_accept_cookies=False,
+        options=mock_options_instance,
+    )
+    # Verify the actual calls on the returned mock_driver
+    mock_driver.get.assert_called_once_with("https://example.com")
+    mock_driver.save_screenshot.assert_called_once_with(str(tmp_path / "test.png"))
+    # Check that the media was added (2 = original video + screenshot)
+    assert len(metadata_with_video.media) == 2
+    assert metadata_with_video.media[1].properties.get("id") == "screenshot"
+
+
+@pytest.mark.parametrize(
+    "url,is_auth",
+    [
+        ("https://example.com", False),
+        ("https://private.com", True),
+    ],
+)
+def test_enrich_auth_wall(
+    screenshot_enricher, metadata_with_video, mock_selenium_env, common_patches, url, is_auth, mocker
+):
+    # Testing with and without is_auth_wall
+    mock_driver, mock_driver_class, _ = mock_selenium_env
+    mocker.patch("auto_archiver.utils.url.is_auth_wall", return_value=is_auth)
+    metadata_with_video.set_url(url)
+    screenshot_enricher.enrich(metadata_with_video)
+
+    if is_auth:
+        mock_driver.get.assert_not_called()
+        assert len(metadata_with_video.media) == 1
+        assert metadata_with_video.media[0].properties.get("id") == "video1"
+    else:
+        mock_driver.get.assert_called_once_with(url)
+        assert len(metadata_with_video.media) == 2
+        assert metadata_with_video.media[1].properties.get("id") == "screenshot"
+
+
+def test_skip_authwall_no_cookies(screenshot_enricher, caplog):
+    with caplog.at_level("WARNING"):
+        screenshot_enricher.enrich(Metadata().set_url("https://instagram.com"))
+    assert "[SKIP] SCREENSHOT since url" in caplog.text
+
+
+@pytest.mark.parametrize(
+    "auth",
+    [
+        {"cookie": "cookie"},
+        {"cookies_jar": "cookie"},
+    ],
+)
+def test_dont_skip_authwall_with_cookies(screenshot_enricher, caplog, mocker, mock_selenium_env, auth):
+    mocker.patch("auto_archiver.utils.url.is_auth_wall", return_value=True)
+
+    # patch the authentication dict:
+    screenshot_enricher.authentication = {"example.com": auth}
+    with caplog.at_level("WARNING"):
+        screenshot_enricher.enrich(Metadata().set_url("https://example.com"))
+    assert "[SKIP] SCREENSHOT since url" not in caplog.text
+
+
+def test_show_warning_wrong_auth_type(screenshot_enricher, caplog, mocker, mock_selenium_env):
+    mock_driver, mock_driver_class, _ = mock_selenium_env
+    mocker.patch("auto_archiver.utils.url.is_auth_wall", return_value=True)
+    screenshot_enricher.authentication = {"example.com": {"username": "user", "password": "pass"}}
+    with caplog.at_level("WARNING"):
+        screenshot_enricher.enrich(Metadata().set_url("https://example.com"))
+    assert "Screenshot enricher only supports cookie-type authentication" in caplog.text
+
+
+def test_handle_timeout_exception(screenshot_enricher, metadata_with_video, mock_selenium_env, mocker):
+    mock_driver, mock_driver_class, mock_options_instance = mock_selenium_env
+
+    mock_driver.get.side_effect = TimeoutException
+    mock_log = mocker.patch("loguru.logger.info")
+    screenshot_enricher.enrich(metadata_with_video)
+    mock_log.assert_called_once_with("TimeoutException loading page for screenshot")
+    assert len(metadata_with_video.media) == 1
+
+
+def test_handle_general_exception(screenshot_enricher, metadata_with_video, mock_selenium_env, mocker):
+    """Test proper handling of unexpected general exceptions"""
+    mock_driver, mock_driver_class, mock_options_instance = mock_selenium_env
+    # Simulate a generic exception when save_screenshot is called
+    mock_driver.get.return_value = None
+    mock_driver.save_screenshot.side_effect = Exception("Unexpected Error")
+
+    mock_log = mocker.patch("loguru.logger.error")
+    screenshot_enricher.enrich(metadata_with_video)
+    # Verify that the exception was logged with the log
+    mock_log.assert_called_once_with("Got error while loading webdriver for screenshot enricher: Unexpected Error")
+    # And no new media was added due to the error
+    assert len(metadata_with_video.media) == 1
+
+
+def test_pdf_creation(mocker, screenshot_enricher, metadata_with_video, mock_selenium_env):
+    """Test PDF creation when save_to_pdf is enabled"""
+    mock_driver, mock_driver_class, mock_options_instance = mock_selenium_env
+    # Override the save_to_pdf option
+    screenshot_enricher.save_to_pdf = True
+    # Mock the print_page method to return base64-encoded content
+    mock_driver.print_page.return_value = base64.b64encode(b"fake_pdf_content").decode("utf-8")
+    # Patch functions with mocker
+    mocker.patch("os.path.join", side_effect=lambda *args: f"{args[-1]}")
+    mocker.patch(
+        "auto_archiver.modules.screenshot_enricher.screenshot_enricher.random_str",
+        return_value="fixed123",
+    )
+    mock_open = mocker.patch("builtins.open", new_callable=mocker.mock_open)
+
+    screenshot_enricher.enrich(metadata_with_video)
+    # Verify screenshot and PDF creation
+    mock_driver.save_screenshot.assert_called_once()
+    mock_driver.print_page.assert_called_once_with(mock_driver.print_options)
+    # Check that PDF file was opened and written
+    mock_open.assert_any_call("pdf_fixed123.pdf", "wb")
+
+    # Ensure both screenshot and PDF were added as media
+    assert len(metadata_with_video.media) == 3
+    assert metadata_with_video.media[1].properties.get("id") == "screenshot"
+    assert metadata_with_video.media[2].properties.get("id") == "pdf"
+
+
+@pytest.fixture(autouse=True)
+def cleanup_files(tmp_path):
+    yield
+    for file in tmp_path.iterdir():
+        file.unlink()

tests/enrichers/test_thumbnail_enricher.py

@@ -25,7 +25,6 @@ def mock_ffmpeg_environment(mocker):
     # Mocking all the ffmpeg calls in one place
     mock_ffmpeg_input = mocker.patch("ffmpeg.input")
     mock_makedirs = mocker.patch("os.makedirs")
-    mocker.patch("os.path.exists", return_value=True)
     (mocker.patch.object(Media, "is_video", return_value=True),)
     mock_probe = mocker.patch(
         "ffmpeg.probe",
@@ -75,12 +74,12 @@ def test_enrich_thumbnail_limits(
 def test_enrich_handles_probe_failure(thumbnail_enricher, metadata_with_video, mocker):
     mocker.patch("ffmpeg.probe", side_effect=Exception("Probe error"))
     mocker.patch("os.makedirs")
-    mock_logger = mocker.patch("loguru.logger.warning")
+    mock_logger = mocker.patch("loguru.logger.error")
     mocker.patch.object(Media, "is_video", return_value=True)
 
     thumbnail_enricher.enrich(metadata_with_video)
     # Ensure error was logged
-    mock_logger.assert_called_with("cannot generate thumbnails for video.mp4 without valid duration")
+    mock_logger.assert_called_with("error getting duration of video video.mp4: Probe error")
     # Ensure no thumbnails were created
     thumbnails = metadata_with_video.media[0].get("thumbnails")
     assert thumbnails is None
@@ -127,14 +126,11 @@ def test_enrich_handles_short_video(
     assert len(thumbnails) == expected_count
 
 
-def test_uses_existing_duration_on_exception(thumbnail_enricher, metadata_with_video, mock_ffmpeg_environment, mocker):
-    mock_logger = mocker.patch("loguru.logger.warning")
-    mock_probe = mocker.patch("ffmpeg.probe", side_effect=Exception("New probe error"))
-    metadata_with_video.media[0].set("duration", 3)
+def test_uses_existing_duration(thumbnail_enricher, metadata_with_video, mock_ffmpeg_environment):
+    metadata_with_video.media[0].set("duration", 60)
     thumbnail_enricher.enrich(metadata_with_video)
-    mock_probe.assert_called_once()
-    mock_logger.assert_called_with("failed to get duration with FFMPEG from video.mp4: New probe error")
-    assert mock_ffmpeg_environment["mock_output"].run.call_count == 3
+    mock_ffmpeg_environment["mock_probe"].assert_not_called()
+    assert mock_ffmpeg_environment["mock_output"].run.call_count == 4
 
 
 def test_enrich_metadata_structure(thumbnail_enricher, metadata_with_video, mock_ffmpeg_environment, mocker):

tests/enrichers/test_timestamping_enricher.py

@@ -1,215 +0,0 @@
-from pathlib import Path
-import pytest
-
-from rfc3161_client import (
-    TimeStampResponse,
-    decode_timestamp_response,
-)
-import requests
-
-from auto_archiver.modules.timestamping_enricher.timestamping_enricher import TimestampingEnricher
-from auto_archiver.core import Metadata
-
-
-@pytest.fixture
-def timestamp_response() -> TimeStampResponse:
-    with open("tests/data/timestamping/valid_timestamp.tsr", "rb") as f:
-        return decode_timestamp_response(f.read())
-
-
-@pytest.fixture
-def wrong_order_timestamp_response() -> TimeStampResponse:
-    with open("tests/data/timestamping/rfc3161-client-issue-104.tsr", "rb") as f:
-        return decode_timestamp_response(f.read())
-
-
-@pytest.fixture
-def selfsigned_response() -> TimeStampResponse:
-    with open("tests/data/timestamping/self_signed.tsr", "rb") as f:
-        return decode_timestamp_response(f.read())
-
-
-@pytest.fixture
-def digicert_response() -> TimeStampResponse:
-    with open("tests/data/timestamping/digicert.tsr", "rb") as f:
-        return f.read()
-
-
-@pytest.fixture
-def filehash():
-    return "4b7b4e39f12b8c725e6e603e6d4422500316df94211070682ef10260ff5759ef"
-
-
-@pytest.mark.download
-def test_enriching(setup_module, sample_media):
-    tsp: TimestampingEnricher = setup_module("timestamping_enricher")
-
-    # tests the current TSAs set as default in the __manifest__ to make sure they are all still working
-
-    # test the enrich method
-    metadata = Metadata().set_url("https://example.com")
-    sample_media.set("hash", "4b7b4e39f12b8c725e6e603e6d4422500316df94211070682ef10260ff5759ef")
-    metadata.add_media(sample_media)
-    tsp.enrich(metadata)
-
-
-def test_full_enriching_selfsigned(setup_module, sample_media, mocker, selfsigned_response, filehash):
-    mock_post = mocker.patch("requests.sessions.Session.post")
-    mock_post.return_value.status_code = 200
-    mock_decode_timestamp_response = mocker.patch(
-        "auto_archiver.modules.timestamping_enricher.timestamping_enricher.decode_timestamp_response"
-    )
-    mock_decode_timestamp_response.return_value = selfsigned_response
-
-    tsp: TimestampingEnricher = setup_module("timestamping_enricher", {"tsa_urls": ["http://timestamp.identrust.com"]})
-    metadata = Metadata().set_url("https://example.com")
-    sample_media.set("hash", filehash)
-    metadata.add_media(sample_media)
-    tsp.enrich(metadata)
-
-    assert len(metadata.media) == 1  # doesn't allow self-signed
-
-    # set self-signed on tsp
-    tsp.allow_selfsigned = True
-    tsp.enrich(metadata)
-
-    assert len(metadata.media) == 2
-
-
-def test_full_enriching(setup_module, sample_media, mocker, timestamp_response, filehash):
-    mock_post = mocker.patch("requests.sessions.Session.post")
-    mock_post.return_value.status_code = 200
-    mock_decode_timestamp_response = mocker.patch(
-        "auto_archiver.modules.timestamping_enricher.timestamping_enricher.decode_timestamp_response"
-    )
-    mock_decode_timestamp_response.return_value = timestamp_response
-
-    tsp: TimestampingEnricher = setup_module("timestamping_enricher", {"tsa_urls": ["http://timestamp.identrust.com"]})
-    metadata = Metadata().set_url("https://example.com")
-    sample_media.set("hash", filehash)
-    metadata.add_media(sample_media)
-    tsp.enrich(metadata)
-
-    assert metadata.get("timestamped") is True
-    assert len(metadata.media) == 2  # the original 'sample_media' and the new 'timestamp_media'
-
-    timestamp_media = metadata.media[1]
-    assert timestamp_media.filename == f"{tsp.tmp_dir}/hashes.txt"
-    assert Path(timestamp_media.filename).read_text() == filehash
-
-    # we only have one authority file because we only used one TSA
-    assert len(timestamp_media.get("timestamp_authority_files")) == 1
-    timestamp_authority_file = timestamp_media.get("timestamp_authority_files")[0]
-    assert Path(timestamp_authority_file.filename).read_bytes() == timestamp_response.time_stamp_token()
-
-    cert_chain = timestamp_authority_file.get("cert_chain")
-    assert len(cert_chain) == 3
-    assert cert_chain[0].filename == f"{tsp.tmp_dir}/1 – 85078758028491331763.crt"
-    assert cert_chain[1].filename == f"{tsp.tmp_dir}/2 – 85078371663472981624.crt"
-    assert cert_chain[2].filename == f"{tsp.tmp_dir}/3 – 13298821034946342390.crt"
-
-
-def test_full_enriching_multiple_tsa(setup_module, sample_media, mocker, timestamp_response, filehash):
-    mock_post = mocker.patch("requests.sessions.Session.post")
-    mock_post.return_value.status_code = 200
-
-    mock_decode_timestamp_response = mocker.patch(
-        "auto_archiver.modules.timestamping_enricher.timestamping_enricher.decode_timestamp_response"
-    )
-    mock_decode_timestamp_response.return_value = timestamp_response
-
-    tsp: TimestampingEnricher = setup_module(
-        "timestamping_enricher", {"tsa_urls": ["http://example.com/timestamp1", "http://example.com/timestamp2"]}
-    )
-    metadata = Metadata().set_url("https://example.com")
-    sample_media.set("hash", filehash)
-    metadata.add_media(sample_media)
-    tsp.enrich(metadata)
-
-    assert metadata.get("timestamped") is True
-    assert len(metadata.media) == 2  # the original 'sample_media' and the new 'timestamp_media'
-
-    timestamp_media = metadata.media[1]
-    assert len(timestamp_media.get("timestamp_authority_files")) == 2
-    for timestamp_token_media in timestamp_media.get("timestamp_authority_files"):
-        assert Path(timestamp_token_media.filename).read_bytes() == timestamp_response.time_stamp_token()
-        assert len(timestamp_token_media.get("cert_chain")) == 3
-
-
-def test_fails_for_digicert(setup_module, mocker, digicert_response):
-    """
-    Digicert TSRs are not compliant with RFC 3161.
-    See https://github.com/trailofbits/rfc3161-client/issues/104#issuecomment-2621960840
-    """
-    mocker.patch("requests.sessions.Session.post", return_value=requests.Response())
-    mocker.patch("requests.Response.raise_for_status")
-    mocker.patch("requests.Response.content", new_callable=mocker.PropertyMock, return_value=digicert_response)
-
-    tsa_url = "http://timestamp.digicert.com"
-    tsp: TimestampingEnricher = setup_module("timestamping_enricher")
-
-    data = b"4b7b4e39f12b8c725e6e603e6d4422500316df94211070682ef10260ff5759ef"
-    with pytest.raises(ValueError) as e:
-        tsp.sign_data(tsa_url, data)
-    assert "ASN.1 parse error: ParseError" in str(e.value)
-
-
-@pytest.mark.download
-def test_download_tsr(setup_module):
-    tsa_url = "http://timestamp.identrust.com"
-    tsp: TimestampingEnricher = setup_module("timestamping_enricher")
-
-    data = b"4b7b4e39f12b8c725e6e603e6d4422500316df94211070682ef10260ff5759ef"
-    result: TimeStampResponse = tsp.sign_data(tsa_url, data)
-    assert isinstance(result, TimeStampResponse)
-
-    verified_root_cert = tsp.verify_signed(result, data)
-    assert verified_root_cert.subject.rfc4514_string() == "CN=IdenTrust Commercial Root CA 1,O=IdenTrust,C=US"
-
-    # test downloading the cert
-    cert_chain = tsp.save_certificate(result, verified_root_cert)
-    assert len(cert_chain) == 3
-
-
-def test_verify_save(setup_module, timestamp_response):
-    tsp: TimestampingEnricher = setup_module("timestamping_enricher")
-
-    verified_root_cert = tsp.verify_signed(
-        timestamp_response, b"4b7b4e39f12b8c725e6e603e6d4422500316df94211070682ef10260ff5759ef"
-    )
-    assert verified_root_cert.subject.rfc4514_string() == "CN=IdenTrust Commercial Root CA 1,O=IdenTrust,C=US"
-
-    cert_chain = tsp.save_certificate(timestamp_response, verified_root_cert)
-    assert len(cert_chain) == 3
-
-    assert cert_chain[0].filename == f"{tsp.tmp_dir}/1 – 85078758028491331763.crt"
-    assert cert_chain[1].filename == f"{tsp.tmp_dir}/2 – 85078371663472981624.crt"
-    assert cert_chain[2].filename == f"{tsp.tmp_dir}/3 – 13298821034946342390.crt"
-
-
-def test_order_crt_correctly(setup_module, wrong_order_timestamp_response):
-    # reference: https://github.com/trailofbits/rfc3161-client/issues/104#issuecomment-2711244010
-    tsp: TimestampingEnricher = setup_module("timestamping_enricher")
-
-    # get the certificates, make sure the reordering is working:
-
-    ordered_certs = tsp.tst_certs(wrong_order_timestamp_response)
-    assert len(ordered_certs) == 2
-    assert ordered_certs[0].subject.rfc4514_string() == "CN=TrustID Timestamp Authority,O=IdenTrust,C=US"
-    assert ordered_certs[1].subject.rfc4514_string() == "CN=TrustID Timestamping CA 3,O=IdenTrust,C=US"
-
-
-def test_invalid_tsa_invalid_response(setup_module, mocker):
-    mocker.patch("requests.sessions.Session.post", return_value=requests.Response())
-    raise_for_status = mocker.patch("requests.Response.raise_for_status")
-    raise_for_status.side_effect = requests.exceptions.HTTPError("404 Client Error")
-    tsp = setup_module("timestamping_enricher")
-
-    with pytest.raises(requests.exceptions.HTTPError, match="404 Client Error"):
-        tsp.sign_data("http://bellingcat.com/page-not-found/", b"my-message")
-
-
-def test_fail_on_selfsigned_cert(setup_module, selfsigned_response):
-    tsp = setup_module("timestamping_enricher")
-    root_cert = tsp.verify_signed(selfsigned_response, b"my-message")
-    assert root_cert is None

tests/enrichers/test_wacz_enricher.py

@@ -119,4 +119,4 @@ def test_extract_media(wacz_enricher, metadata, tmp_path, mocker) -> None:
     metadata.add_media(Media("something.wacz"), "browsertrix")
     wacz_enricher.extract_media_from_wacz(metadata, str(wacz_file))
     assert len(metadata.media) == 2
-    assert metadata.media[1].properties.get("id") == "browsertrix-screenshot-0"
+    assert metadata.media[1].properties.get("id") == "browsertrix-screenshot"

tests/extractors/test_antibot_dropin_vk.py

@@ -1,101 +0,0 @@
-import pytest
-from auto_archiver.modules.antibot_extractor_enricher.dropins.vk import VkDropin
-
-
-@pytest.mark.parametrize(
-    "input_url,expected",
-    [
-        # Unrelated URL, should return unchanged
-        (
-            "https://vk.com/id123456",
-            "https://vk.com/id123456",
-        ),
-        (
-            "https://example.com/",
-            "https://example.com/",
-        ),
-        # Wall post modal URL
-        (
-            "https://vk.com/somepage?w=wall-123456_7890",
-            "https://vk.com/wall-123456_7890",
-        ),
-        # Wall post modal URL with no dash
-        (
-            "https://vk.com/somepage?w=wall123456_7890",
-            "https://vk.com/wall123456_7890",
-        ),
-        # Photo modal URL
-        (
-            "https://vk.com/somepage?w=photo-654321_9876",
-            "https://vk.com/photo-654321_9876",
-        ),
-        # Photo modal URL with no dash
-        (
-            "https://vk.com/somepage?w=photo654321_9876",
-            "https://vk.com/photo654321_9876",
-        ),
-        # Video modal URL
-        (
-            "https://vk.com/somepage?w=video-111222_3334",
-            "https://vk.com/video-111222_3334",
-        ),
-        # Video modal URL with extra part
-        (
-            "https://vk.com/somepage?w=video-111222_3334_ABC",
-            "https://vk.com/video-111222_3334_ABC",
-        ),
-        # Video modal URL with no dash
-        (
-            "https://vk.com/somepage?w=video111222_3334",
-            "https://vk.com/video111222_3334",
-        ),
-        # No modal, should return unchanged
-        (
-            "https://vk.com/wall-123456_7890",
-            "https://vk.com/wall-123456_7890",
-        ),
-        (
-            "https://vk.com/photo-654321_9876",
-            "https://vk.com/photo-654321_9876",
-        ),
-        (
-            "https://vk.com/video-111222_3334",
-            "https://vk.com/video-111222_3334",
-        ),
-        # Clip modal URL
-        (
-            "https://vk.com/somepage?w=clip-555666_7778",
-            "https://vk.com/clip-555666_7778",
-        ),
-        # Clip modal URL with no dash
-        (
-            "https://vk.com/somepage?w=clip555666_7778",
-            "https://vk.com/clip555666_7778",
-        ),
-        # Clip modal URL with extra part
-        (
-            "https://vk.com/somepage?w=clip-555666_7778_ABC",
-            "https://vk.com/clip-555666_7778",
-        ),
-        # No modal, should return unchanged (clip)
-        (
-            "https://vk.com/clip-555666_7778",
-            "https://vk.com/clip-555666_7778",
-        ),
-        # Modal with multiple params, should still work with right priority
-        (
-            "https://vk.com/somepage?z=photo-654321_9876&w=wall-123456_7890",
-            "https://vk.com/wall-123456_7890",
-        ),
-        (
-            "https://vk.com/somepage?z=photo-654321_9876&w=video-111222_3334",
-            "https://vk.com/video-111222_3334",
-        ),
-        (
-            "https://vk.com/somepage?z=video-111222_3334&w=wall-654321_9876",
-            "https://vk.com/wall-654321_9876",
-        ),
-    ],
-)
-def test_sanitize_url(input_url, expected):
-    assert VkDropin.sanitize_url(input_url) == expected

tests/extractors/test_antibot_extractor_enricher.py

@@ -1,264 +0,0 @@
-import os
-import pytest
-
-from auto_archiver.modules.antibot_extractor_enricher.antibot_extractor_enricher import AntibotExtractorEnricher
-from .test_extractor_base import TestExtractorBase
-
-
-class DummySB:
-    def __init__(self, url="", title="", visible_texts=None, visible_elements=None):
-        self._url = url
-        self._title = title
-        self._visible_texts = visible_texts or set()
-        self._visible_elements = visible_elements or set()
-
-    def get_current_url(self):
-        return self._url
-
-    def get_title(self):
-        return self._title
-
-    def is_text_visible(self, text):
-        return text in self._visible_texts
-
-    def is_element_visible(self, selector):
-        return selector in self._visible_elements
-
-
-class TestAntibotExtractorEnricher(TestExtractorBase):
-    """Tests Antibot Extractor/Enricher"""
-
-    extractor_module = "antibot_extractor_enricher"
-    extractor: AntibotExtractorEnricher
-
-    config = {
-        "save_to_pdf": False,
-        "max_download_images": 0,
-        "max_download_videos": 0,
-        "user_data_dir": "./tests/tmp/user_data",
-        "proxy": None,
-        "authentication": {
-            "reddit.com": {
-                "username": os.environ.get("REDDIT_TEST_USERNAME"),
-                "password": os.environ.get("REDDIT_TEST_PASSWORD"),
-            },
-            "linkedin.com": {
-                "username": os.environ.get("LINKEDIN_TEST_USERNAME"),
-                "password": os.environ.get("LINKEDIN_TEST_PASSWORD"),
-            },
-        },
-    }
-
-    @pytest.mark.download
-    @pytest.mark.parametrize(
-        "url,in_title,in_text,image_count,video_count",
-        [
-            (
-                "https://en.wikipedia.org/wiki/Western_barn_owl",
-                "western barn owl",
-                "Tyto alba",
-                5,
-                0,
-            ),
-            (
-                "https://www.bellingcat.com/news/2025/04/29/open-sources-show-myanmar-junta-airstrike-damages-despite-post-earthquake-ceasefire/",
-                "open sources show myanmar",
-                "Bellingcat has geolocated",
-                5,
-                0,
-            ),
-            (
-                "https://www.bellingcat.com/news/2025/03/27/gaza-israel-palestine-shot-killed-injured-destroyed-dangerous-drone-journalists-in-gaza/",
-                "shot from above",
-                "continued the work of Gazan journalists",
-                5,
-                1,
-            ),
-            (
-                "https://www.bellingcat.com/about/general-information",
-                "general information",
-                "Stichting Bellingcat",
-                0,  # SVGs are ignored
-                0,
-            ),
-            (
-                "https://vk.com/wikipedia?from=search&w=wall-36156673_20451",
-                "Hounds of Love",
-                "16 сентября 1985 года лейблом EMI Records.",
-                5,
-                0,
-            ),
-        ],
-    )
-    def test_download_pages_with_media(self, setup_module, make_item, url, in_title, in_text, image_count, video_count):
-        """
-        Test downloading pages with media.
-        """
-        self.extractor = setup_module(
-            self.extractor_module,
-            self.config
-            | {
-                "save_to_pdf": True,
-                "max_download_images": 5,
-                "max_download_videos": "inf",
-            },
-        )
-        url = self.extractor.sanitize_url(url)
-        item = make_item(url)
-        result = self.extractor.download(item)
-
-        assert result.status == "antibot", "Expected status to be 'antibot'"
-
-        # Check title contains all required words (case-insensitive)
-        page_title = result.get_title() or ""
-        assert in_title.lower() in page_title.lower(), f"Expected title to contain '{in_title}', got '{page_title}'"
-
-        # Check text contains all required words (case-insensitive)
-        with open(result.get_media_by_id("html_source_code").filename, "r", encoding="utf-8") as f:
-            html_content = f.read()
-            assert in_text.lower() in html_content.lower(), (
-                f"Expected HTML to contain '{in_text}', got '{html_content}'"
-            )
-
-        image_media = [m for m in result.media if m.is_image() and not m.get("id") == "screenshot"]
-        assert len(image_media) == image_count, f"Expected {image_count} image items, got {len(image_media)}"
-        video_media = [m for m in result.media if m.is_video()]
-        assert len(video_media) == video_count, f"Expected {video_count} video items, got {len(video_media)}"
-
-        for expected_id in ["screenshot", "pdf", "html_source_code"]:
-            assert any(m.get("id") == expected_id for m in result.media), (
-                f"Expected media with id '{expected_id}' not found"
-            )
-
-    @pytest.mark.skipif(
-        not os.environ.get("REDDIT_TEST_USERNAME") or not os.environ.get("REDDIT_TEST_PASSWORD"),
-        reason="No Reddit test credentials provided",
-    )
-    @pytest.mark.download
-    @pytest.mark.parametrize(
-        "url,in_title,in_text,image_count,video_count",
-        [
-            (
-                "https://www.reddit.com/r/BeAmazed/comments/1l6b1n4/duy_tran_is_the_owner_and_prime_wood_work_artist/",
-                "Duy tran is the owner and prime wood work artist",
-                " Created Jan 26, 2015",
-                4,
-                0,
-            ),
-        ],
-    )
-    def test_reddit_download_with_login(
-        self, setup_module, make_item, url, in_title, in_text, image_count, video_count
-    ):
-        self.test_download_pages_with_media(setup_module, make_item, url, in_title, in_text, image_count, video_count)
-
-    @pytest.mark.skipif(
-        not os.environ.get("LINKEDIN_TEST_USERNAME") or not os.environ.get("LINKEDIN_TEST_PASSWORD"),
-        reason="No LinkedIn test credentials provided",
-    )
-    @pytest.mark.download
-    @pytest.mark.parametrize(
-        "url,in_title,in_text,image_count,video_count",
-        [
-            (
-                "https://www.linkedin.com/posts/bellingcat_live-podcast-bellingcat-activity-7331725631799398400-xocM/",
-                "Post",
-                "It takes time to go from hunch to reporting...",
-                2,
-                0,
-            ),
-        ],
-    )
-    def test_linkedin_download_with_login(
-        self, setup_module, make_item, url, in_title, in_text, image_count, video_count
-    ):
-        self.test_download_pages_with_media(setup_module, make_item, url, in_title, in_text, image_count, video_count)
-
-    @pytest.mark.download
-    @pytest.mark.parametrize(
-        "url,in_html",
-        [
-            (
-                "https://myrotvorets.center/about/",
-                "Центр «Миротворець»",
-            ),
-            (
-                "https://seleniumbase.io/apps/turnstile",
-                '<img id="captcha-success" src="https://seleniumbase.io/cdn/img/green_check.png" style="" width="180">',
-            ),
-            (
-                "https://seleniumbase.io/apps/form_turnstile",
-                '<img id="captcha-success" src="https://seleniumbase.io/cdn/img/green_check.png" width="120" style="">',
-            ),
-            (
-                "https://gitlab.com/users/sign_in",
-                "Password",
-            ),
-        ],
-    )
-    def test_overcome_cloudflare_turnstile(self, setup_module, make_item, url, in_html):
-        """
-        Test downloading a page with Cloudflare Turnstile captcha.
-        """
-
-        self.extractor = setup_module(
-            self.extractor_module,
-            {
-                "save_to_pdf": True,
-                "detect_auth_wall": False,
-                "max_download_images": 5,
-                "max_download_videos": "inf",
-            },
-        )
-
-        item = make_item(url)
-        self.extractor.enrich(item)
-
-        assert item.status != "antibot", "Expected status not to be 'antibot' after handling Cloudflare Turnstile"
-
-        html_media = item.get_media_by_id("html_source_code")
-        with open(html_media.filename, "r", encoding="utf-8") as f:
-            html_content = f.read()
-            assert in_html.lower() in html_content.lower(), f"Expected HTML to contain '{in_html}'"
-
-    @pytest.mark.parametrize(
-        "url,title,visible_texts,visible_elements,expected",
-        [
-            # URL triggers
-            ("https://example.com/login", "Welcome", set(), set(), True),
-            ("https://example.com/somepage", "Just a moment...", set(), set(), True),
-            ("https://example.com/", "Welcome", {"Please log in"}, set(), True),
-            ("https://example.com/", "Welcome", set(), {"input[type='password']"}, True),
-            ("https://example.com/", "Welcome", set("No issue here"), set(), False),
-            # Title triggers
-            ("https://example.com/", "Log in", set(), set(), True),
-            ("https://example.com/", "Verification required", set(), set(), True),
-            # Text triggers (case-insensitive)
-            ("https://example.com/", "Welcome", {"Sign up or log in"}, set(), True),
-            ("https://example.com/", "Welcome", {"sign up or log in"}, set(), True),
-            # Element triggers
-            ("https://example.com/", "Welcome", set(), {"input[name='email']"}, True),
-            # No triggers
-            ("https://example.com/", "Welcome", set(), set(), False),
-        ],
-    )
-    def test_hit_auth_wall(self, url, title, visible_texts, visible_elements, expected):
-        extractor = AntibotExtractorEnricher()
-        sb = DummySB(url=url, title=title, visible_texts=visible_texts, visible_elements=visible_elements)
-        assert extractor._hit_auth_wall(sb) == expected
-
-    def test_enrich_handles_sb_exception(self, make_item, mocker):
-        """
-        Test that enrich returns False and logs error if SB raises an exception.
-        """
-
-        # Patch SB to raise an exception on context enter
-        mock_sb = mocker.patch("auto_archiver.modules.antibot_extractor_enricher.antibot_extractor_enricher.SB")
-        mock_logger = mocker.patch("auto_archiver.modules.antibot_extractor_enricher.antibot_extractor_enricher.logger")
-        mock_sb.side_effect = Exception("SB failed")
-
-        item = make_item("https://example.com/")
-        result = self.extractor.enrich(item)
-
-        assert result is False
-        mock_logger.error.assert_called()

tests/extractors/test_extractor_base.py

@@ -25,5 +25,5 @@ class TestExtractorBase(object):
         else:
             assert status == test_response.status
 
-        assert title in test_response.get_title()
-        assert timestamp == test_response.get("timestamp")
+        assert title == test_response.get_title()
+        assert timestamp, test_response.get("timestamp")

tests/extractors/test_generic_extractor.py

@@ -10,7 +10,6 @@ from auto_archiver.modules.generic_extractor.generic_extractor import GenericExt
 from .test_extractor_base import TestExtractorBase
 
 CI = os.getenv("GITHUB_ACTIONS", "") == "true"
-TEST_TRUTH_SOCIAL = os.getenv("TEST_TRUTH_SOCIAL", "") == "true"
 
 
 class TestGenericExtractor(TestExtractorBase):
@@ -30,7 +29,6 @@ class TestGenericExtractor(TestExtractorBase):
         "proxy": None,
         "cookies_from_browser": False,
         "cookie_file": None,
-        "pot_provider": False,
     }
 
     def test_load_dropin(self):
@@ -38,7 +36,7 @@ class TestGenericExtractor(TestExtractorBase):
         package = "auto_archiver.modules.generic_extractor"
         assert self.extractor.dropin_for_name("bluesky", package=package)
 
-        # test loading dropins via filepath
+        # test loading dropings via filepath
         path = os.path.join(dirname(dirname(__file__)), "data/")
         assert self.extractor.dropin_for_name("dropin", additional_paths=[path])
 
@@ -98,7 +96,7 @@ class TestGenericExtractor(TestExtractorBase):
     )
     def test_download_nonexistent_media(self, make_item, url):
         """
-        Test to make sure that the extractor doesn't break on non-existent posts/media
+        Test to make sure that the extractor doesn't break on non-existend posts/media
 
         It should return 'False'
         """
@@ -123,7 +121,7 @@ class TestGenericExtractor(TestExtractorBase):
             == "Buy NEW Keyboard Cat Merch! https://keyboardcat.creator-spring.com\n\nxo Keyboard Cat memes make your day better!\nhttp://www.keyboardcatstore.com/\nhttps://www.facebook.com/thekeyboardcat\nhttp://www.charlieschmidt.com/"
         )
         assert len(result.media) == 2
-        assert "J---aiyznGQ" in Path(result.media[0].filename).name
+        assert Path(result.media[0].filename).name == "J---aiyznGQ.webm"
         assert Path(result.media[1].filename).name == "hqdefault.jpg"
 
     @pytest.mark.download
@@ -150,7 +148,6 @@ class TestGenericExtractor(TestExtractorBase):
         result = self.extractor.download(item)
         assert result is not False
 
-    @pytest.mark.skipif(not TEST_TRUTH_SOCIAL, reason="Truth social download tests disabled in environment variables.")
     @pytest.mark.skipif(CI, reason="Truth social blocks GH actions.")
     @pytest.mark.download
     def test_truthsocial_download_video(self, make_item):
@@ -159,7 +156,6 @@ class TestGenericExtractor(TestExtractorBase):
         assert len(result.media) == 1
         assert result is not False
 
-    @pytest.mark.skipif(not TEST_TRUTH_SOCIAL, reason="Truth social download tests disabled in environment variables.")
     @pytest.mark.skipif(CI, reason="Truth social blocks GH actions.")
     @pytest.mark.download
     def test_truthsocial_download_no_media(self, make_item):
@@ -167,7 +163,6 @@ class TestGenericExtractor(TestExtractorBase):
         result = self.extractor.download(item)
         assert result is not False
 
-    @pytest.mark.skipif(not TEST_TRUTH_SOCIAL, reason="Truth social download tests disabled in environment variables.")
     @pytest.mark.skipif(CI, reason="Truth social blocks GH actions.")
     @pytest.mark.download
     def test_truthsocial_download_poll(self, make_item):
@@ -175,7 +170,6 @@ class TestGenericExtractor(TestExtractorBase):
         result = self.extractor.download(item)
         assert result is not False
 
-    @pytest.mark.skipif(not TEST_TRUTH_SOCIAL, reason="Truth social download tests disabled in environment variables.")
     @pytest.mark.skipif(CI, reason="Truth social blocks GH actions.")
     @pytest.mark.download
     def test_truthsocial_download_single_image(self, make_item):
@@ -184,7 +178,6 @@ class TestGenericExtractor(TestExtractorBase):
         assert len(result.media) == 1
         assert result is not False
 
-    @pytest.mark.skipif(not TEST_TRUTH_SOCIAL, reason="Truth social download tests disabled in environment variables.")
     @pytest.mark.skipif(CI, reason="Truth social blocks GH actions.")
     @pytest.mark.download
     def test_truthsocial_download_multiple_images(self, make_item):
@@ -225,7 +218,7 @@ class TestGenericExtractor(TestExtractorBase):
         post = self.extractor.download(make_item(url))
         self.assertValidResponseMetadata(
             post,
-            "Bellingcat - This month's Bellingchat Premium is with @KolinaKoltai",
+            "Bellingcat - This month's Bellingchat Premium is with @KolinaKoltai. She reveals how she investigated a platform allowing users to create AI-generated child sexual abuse material and explains why it's crucial to investigate the people behind these services",
             datetime.datetime(2024, 12, 24, 13, 44, 46, tzinfo=datetime.timezone.utc),
         )
 
@@ -282,7 +275,6 @@ class TestGenericExtractor(TestExtractorBase):
 
         assert "Bellingchat Premium is with Kolina Koltai" in post.get_title()
 
-    @pytest.mark.skip(reason="Newer yt-dlp versions don't support image download.")
     @pytest.mark.download
     def test_download_facebook_image(self, make_item):
         post = self.extractor.download(
@@ -299,42 +291,3 @@ class TestGenericExtractor(TestExtractorBase):
         post = self.extractor.download(make_item(url))
         assert "Bellingcat researcher Kolina Koltai delves deeper into Clothoff" in post.get("content")
         assert post.get_title() == "Bellingcat"
-
-
-class TestGenericExtractorPoToken:
-    @pytest.fixture
-    def extractor(self, mocker):
-        extractor = GenericExtractor()
-        extractor.extractor_args = {}
-        extractor.setup_token_generation_script = mocker.Mock()
-        return extractor
-
-    def test_po_token_disabled_does_not_call_setup(self, extractor):
-        extractor.bguils_po_token_method = "disabled"
-        extractor.in_docker = True
-        extractor.setup_po_tokens()
-        extractor.setup_token_generation_script.assert_not_called()
-
-    def test_po_token_default_in_docker_calls_setup(self, extractor, mocker):
-        extractor.bguils_po_token_method = "auto"
-        mocker.patch.dict(os.environ, {"RUNNING_IN_DOCKER": "1"})
-        extractor.setup_po_tokens()
-        extractor.setup_token_generation_script.assert_called_once()
-
-    def test_po_token_default_local_does_not_call_setup(self, extractor, caplog, mocker):
-        extractor.bguils_po_token_method = "auto"
-        # clears env vars for this test
-        mocker.patch.dict(os.environ, {}, clear=True)
-        extractor.setup_po_tokens()
-        extractor.setup_token_generation_script.assert_not_called()
-        assert "Proof of Origin Token method not explicitly set" in caplog.text
-
-    def test_po_token_script_always_calls_setup(self, extractor):
-        extractor.bguils_po_token_method = "script"
-        extractor.in_docker = False
-        extractor.setup_po_tokens()
-        extractor.setup_token_generation_script.assert_called_once()
-        extractor.setup_token_generation_script.reset_mock()
-        extractor.in_docker = True
-        extractor.setup_po_tokens()
-        extractor.setup_token_generation_script.assert_called_once()

tests/extractors/test_instagram_tbot_extractor.py

@@ -68,12 +68,6 @@ def test_download_invalid(extractor, metadata_sample, mocker):
     assert extractor.download(metadata_sample) is False
 
 
-def test_fails_with_empty_response(extractor, metadata_sample, mocker):
-    mocker.patch.object(extractor, "_send_url_to_bot", return_value=(mocker.MagicMock(), 101))
-    mocker.patch.object(extractor, "_process_messages", return_value="")
-    assert extractor.download(metadata_sample) is False
-
-
 @pytest.mark.skip(reason="Requires authentication.")
 class TestInstagramTbotExtractorReal(TestExtractorBase):
     # To run these tests set the TELEGRAM_API_ID and TELEGRAM_API_HASH environment variables, and ensure the session file exists.

tests/extractors/test_telethon_extractor.py

@@ -1,26 +0,0 @@
-import os
-from datetime import date
-
-import pytest
-
-
-@pytest.fixture(autouse=True)
-def mock_client_setup(mocker):
-    mocker.patch("telethon.client.auth.AuthMethods.start")
-
-
-def test_setup_fails_clear_session_file(get_lazy_module, tmp_path, mocker):
-    start = mocker.patch("telethon.client.auth.AuthMethods.start")
-    start.side_effect = Exception("Test exception")
-
-    # make sure the default setup file is created
-    session_file = tmp_path / "test.session"
-
-    lazy_module = get_lazy_module("telethon_extractor")
-
-    with pytest.raises(Exception):
-        lazy_module.load({"telethon_extractor": {"session_file": str(session_file), "api_id": 123, "api_hash": "ABC"}})
-
-    assert session_file.exists()
-    assert f"telethon-{date.today().strftime('%Y-%m-%d')}" in lazy_module._instance.session_file
-    assert os.path.exists(lazy_module._instance.session_file + ".session")

tests/extractors/test_twitter_api_extractor.py

@@ -140,22 +140,22 @@ class TestTwitterApiExtractor(TestExtractorBase):
             (
                 "https://x.com/SozinhoRamalho/status/1876710769913450647",
                 "ignore tweet, testing sensitivity warning nudity https://t.co/t3u0hQsSB1",
-                datetime.datetime(2025, 1, 7, 19, 21, 29, tzinfo=datetime.timezone.utc),
+                datetime.datetime(2024, 12, 31, 14, 18, 33, tzinfo=datetime.timezone.utc),
             ),
             (
                 "https://x.com/SozinhoRamalho/status/1876710875475681357",
                 "ignore tweet, testing sensitivity warning violence https://t.co/syYDSkpjZD",
-                datetime.datetime(2025, 1, 7, 19, 21, 54, tzinfo=datetime.timezone.utc),
+                datetime.datetime(2024, 12, 31, 14, 18, 33, tzinfo=datetime.timezone.utc),
             ),
             (
                 "https://x.com/SozinhoRamalho/status/1876711053813227618",
                 "ignore tweet, testing sensitivity warning sensitive https://t.co/XE7cRdjzYq",
-                datetime.datetime(2025, 1, 7, 19, 22, 37, tzinfo=datetime.timezone.utc),
+                datetime.datetime(2024, 12, 31, 14, 18, 33, tzinfo=datetime.timezone.utc),
             ),
             (
                 "https://x.com/SozinhoRamalho/status/1876711141314801937",
                 "ignore tweet, testing sensitivity warning nudity, violence, sensitivity https://t.co/YxCFbbhYE3",
-                datetime.datetime(2025, 1, 7, 19, 22, 58, tzinfo=datetime.timezone.utc),
+                datetime.datetime(2024, 12, 31, 14, 18, 33, tzinfo=datetime.timezone.utc),
             ),
         ],
     )