Install dvlt from a vendored prebuilt wheel (ZeroGPU, no git/sys.path)

packages/dvlt/
repo/ verbatim nv-tlabs/dvlt @ 265fe61, diff = 3 relaxed pins
(torch, torchvision, pydantic) so it resolves with the
ZeroGPU torch>=2.8 + gradio 5.50 stack
wheels/ prebuilt wheel (built by build.sh)
build.sh builds repo/ -> wheels/

requirements.txt installs that wheel via the Space's HTTPS resolve URL
(git+url and local-path installs both fail on HF's Gradio build). No sys.path.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.gitattributes

@@ -7,3 +7,4 @@
 *.gif filter=lfs diff=lfs merge=lfs -text
 *.glb filter=lfs diff=lfs merge=lfs -text
 *.onnx filter=lfs diff=lfs merge=lfs -text
+*.whl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -55,14 +55,13 @@ The `@spaces.GPU` decorator is a no-op off-Spaces, so it runs on CPU or a local
 GPU unchanged.
 
 > **ZeroGPU note:** ZeroGPU runs on Blackwell GPUs that need `torch>=2.8`, but
-> the official `dvlt` package hard-pins `torch==2.5.1`. This repo therefore
-> **vendors** `dvlt` under [`packages/dvlt`](packages/dvlt) — a clone of
-> [`nv-tlabs/dvlt`](https://github.com/nv-tlabs/dvlt) @ `265fe61` with only its
-> `torch`/`torchvision` pins relaxed. HF installs `requirements.txt` *before*
-> copying the repo, so that subdirectory is pip-installed via git against this
-> Space's own repo (`git+…/spaces/blanchon/dvlt@main#subdirectory=packages/dvlt`).
-> The Python source is unmodified; see
-> [`packages/dvlt/README.md`](packages/dvlt/README.md) for the exact edits.
+> the official `dvlt` package hard-pins `torch==2.5.1`. This repo **vendors**
+> `dvlt` under [`packages/dvlt`](packages/dvlt): `repo/` is
+> [`nv-tlabs/dvlt`](https://github.com/nv-tlabs/dvlt) @ `265fe61` with a 3-line
+> pin relaxation (`torch`/`torchvision`/`pydantic`), and `wheels/` holds the
+> prebuilt wheel (`build.sh`). It's installed from that wheel via the Space's
+> own HTTPS `resolve` URL — not git or a local path, both of which fail on HF's
+> Gradio build. See [`packages/dvlt/README.md`](packages/dvlt/README.md).
 
 ## Credits
 

app.py

@@ -4,8 +4,8 @@ Déjà View (DVLT) — Looping Transformers for Multi-View 3D Reconstruction.
 ZeroGPU-ready: GPU work is wrapped in `@spaces.GPU` (see `dvlt_demo.model`),
 and falls back to CPU when no GPU / `spaces` package is available.
 
-`dvlt_demo` sits next to this file (importable directly), and `dvlt` is
-installed as a path dependency from `packages/dvlt` — no sys.path juggling.
+`dvlt` is installed from the vendored wheel in `packages/dvlt/wheels/` (see
+`requirements.txt`); `dvlt_demo` sits next to this file. Nothing touches sys.path.
 """
 
 from dvlt_demo.ui import build_demo

packages/dvlt/README.md

@@ -1,26 +1,28 @@
-# dvlt — vendored clone (edited)
+# Vendored `dvlt`
 
-This is a clone of the official **Déjà View (DVLT)** package,
-[`nv-tlabs/dvlt`](https://github.com/nv-tlabs/dvlt) @ commit `265fe61`, vendored
-into the [`blanchon/dvlt`](https://huggingface.co/spaces/blanchon/dvlt) Space.
-It's pip-installed from this subdirectory via git
-(`git+…/spaces/blanchon/dvlt@main#subdirectory=packages/dvlt`), because HF
-installs `requirements.txt` before copying the repo, so a bare local path can't
-be used. Locally, `uv` installs it from the path (`tool.uv.sources`).
+- **`repo/`** — a verbatim copy of the upstream **Déjà View (DVLT)** repository,
+  [`nv-tlabs/dvlt`](https://github.com/nv-tlabs/dvlt) @ commit `265fe61`. The
+  **only** edit is in `repo/pyproject.toml`: the `torch`/`torchvision` pins were
+  relaxed from `==` to `>=` (ZeroGPU runs on Blackwell GPUs that need
+  `torch>=2.8`, and the `torchvision==0.20.1` pin transitively forced
+  `torch==2.5.1`). Everything else is unmodified.
+- **`build.sh`** — builds the wheel from `repo/` into `wheels/`.
+- **`wheels/`** — the prebuilt wheel the Space installs.
 
-## What was edited
+## Why a vendored wheel instead of `pip install dvlt`
 
-Only `pyproject.toml` — the Python source under `src/dvlt/` is **unmodified**:
+The Space (Gradio SDK + ZeroGPU) can't install this any other way:
 
-- `torch==2.5.1` → `torch>=2.5` — ZeroGPU runs on Blackwell GPUs (sm_120) which
-  need `torch>=2.8`; the exact pin made the package uninstallable there.
-- `torchvision==0.20.1` → `torchvision>=0.20` — must track the installed torch.
-- `huggingface-hub==1.16.4` → `huggingface-hub>=0.30` — so it co-resolves with
-  the Gradio/Spaces stack the Space pulls in.
+- a local path dep (`./packages/dvlt/repo`) isn't available when HF runs
+  `pip install -r requirements.txt` — it installs requirements *before* copying
+  the repo;
+- `pip install git+https://huggingface.co/...` fails — pip clones with
+  `--filter=blob:none`, and HF's git backend can't serve that partial fetch in
+  the build sandbox.
 
-Edited 2026-06-01 by Julien Blanchon (with Claude) for the demo Space only.
-For anything else, use the upstream repository.
+So the wheel is committed here and installed via the Space's own HTTPS
+`resolve` URL (a plain download — no git, no `sys.path`). See `../../requirements.txt`.
 
 Upstream code is Apache-2.0; the `nvidia/dvlt` weights are under the NVIDIA
-non-commercial research license. See `LICENSE`, `LICENSES/`, and
-`THIRD_PARTY_LICENSES.md`.
+non-commercial research license (see `repo/LICENSE`, `repo/LICENSES/`,
+`repo/THIRD_PARTY_LICENSES.md`).

packages/dvlt/build.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Build the vendored dvlt wheel from repo/ into wheels/.
+#
+# The Space installs dvlt from the resulting wheel via its HTTPS resolve URL
+# (see ../../requirements.txt) — not from git or a local path, both of which
+# fail on Hugging Face's Gradio build (see ../../README.md). Re-run this after
+# editing repo/ and commit the refreshed wheel.
+set -euo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+rm -rf "$HERE/wheels"
+mkdir -p "$HERE/wheels"
+
+if command -v uv >/dev/null 2>&1; then
+    uv build --wheel "$HERE/repo" --out-dir "$HERE/wheels"
+else
+    python -m build --wheel --outdir "$HERE/wheels" "$HERE/repo"
+fi
+
+# Keep repo/ a pristine copy of upstream — drop in-tree build artifacts.
+rm -rf "$HERE/repo/build" "$HERE/repo"/src/*.egg-info
+
+echo "Built:"
+ls -1 "$HERE/wheels"

packages/dvlt/repo/.gitattributes

@@ -0,0 +1,2 @@
+# SCM syntax highlighting & preventing 3-way merges
+pixi.lock merge=binary linguist-language=YAML linguist-generated=true

packages/dvlt/repo/.gitignore

@@ -0,0 +1,201 @@
+.hydra/
+output/
+ckpt/
+dependency/
+# Byte-compiled / optimized / DLL files
+__pycache__/
+**/__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Profiling data
+.prof
+
+# Folder specific to your needs
+**/tmp/
+**/outputs/skyseg.onnx
+skyseg.onnx
+
+# pixi environments
+.pixi
+*.egg-info
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+.cursor/
+.ruff_cache/
+*.swp
+*.swo
+
+# DNRM specific
+/datasets/
+outputs/
+third_party/
+visualization/
+checkpoints/
+
+# wandb
+wandb/
+
+# local configs
+local.yaml

packages/dvlt/repo/.pre-commit-config.yaml

@@ -0,0 +1,32 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: check-added-large-files
+
+-   repo: https://github.com/psf/black
+    rev: 25.1.0
+    hooks:
+    -   id: black
+        language_version: python3.12
+        files: ^(src/|tests/)
+
+-   repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.4
+    hooks:
+    -   id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+        files: ^(src/|tests/)
+
+-   repo: local
+    hooks:
+    -   id: pytest-cpu
+        name: pytest-cpu-tests
+        entry: python tests/run_tests.py -c cpu
+        language: system
+        pass_filenames: false
+        always_run: true
+        stages: [pre-commit]

packages/dvlt/repo/CONTRIBUTING.md

@@ -0,0 +1,68 @@
+# Contributing to DVLT
+
+We appreciate your interest in contributing to DVLT! This document provides
+guidelines and information for contributors.
+
+For development setup, code style, testing, and design overview, see
+[docs/CONTRIB.md](docs/CONTRIB.md).
+
+## Signing Your Work
+
+We require that all contributors "sign-off" on their commits. This certifies
+that the contribution is your original work, or you have rights to submit it
+under the same license, or a compatible license.
+
+Any contribution which contains commits that are not Signed-Off will not be
+accepted.
+
+To sign off on a commit you simply use the `--signoff` (or `-s`) option when
+committing your changes:
+
+```bash
+$ git commit -s -m "Add cool feature."
+```
+
+This will append the following to your commit message:
+
+```
+Signed-off-by: Your Name <your@email.com>
+```
+
+## Full text of the DCO
+
+```
+    Developer Certificate of Origin
+    Version 1.1
+
+    Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+
+    Everyone is permitted to copy and distribute verbatim copies of this
+    license document, but changing it is not allowed.
+
+
+    Developer's Certificate of Origin 1.1
+
+    By making a contribution to this project, I certify that:
+
+    (a) The contribution was created in whole or in part by me and I
+        have the right to submit it under the open source license
+        indicated in the file; or
+
+    (b) The contribution is based upon previous work that, to the best
+        of my knowledge, is covered under an appropriate open source
+        license and I have the right under that license to submit that
+        work with modifications, whether created in whole or in part
+        by me, under the same open source license (unless I am
+        permitted to submit under a different license), as indicated
+        in the file; or
+
+    (c) The contribution was provided directly to me by some other
+        person who certified (a), (b) or (c) and I have not modified
+        it.
+
+    (d) I understand and agree that this project and the contribution
+        are public and that a record of the contribution (including all
+        personal information I submit with it, including my sign-off) is
+        maintained indefinitely and may be redistributed consistent with
+        this project or the open source license(s) involved.
+```

packages/dvlt/repo/README.md

@@ -0,0 +1,262 @@
+<div align="center">
+<h1>Déjà View: Looping Transformers for Multi-View 3D Reconstruction</h1>
+
+<a href="https://research.nvidia.com/labs/dvl/projects/dvlt/"><img src="https://img.shields.io/badge/Project-Page-1f72b1.svg" alt="Project Page"></a>
+<a href="https://arxiv.org/abs/2605.30215"><img src="https://img.shields.io/badge/arXiv-2605.30215-b31b1b.svg" alt="arXiv"></a>
+<a href="https://huggingface.co/nvidia/dvlt"><img src="https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Model-yellow" alt="Hugging Face"></a>
+
+**[NVIDIA](https://www.nvidia.com/)** &nbsp;&nbsp;&nbsp; **[University of Modena and Reggio Emilia](https://www.unimore.it/it)** &nbsp;&nbsp;&nbsp; **[University of Toronto](https://www.utoronto.ca/)** &nbsp;&nbsp;&nbsp; **[ETH Zurich](https://ethz.ch/)**
+
+[Alessandro Burzio*](https://research.nvidia.com/labs/dvl/author/alessandro-burzio/), [Tobias Fischer*](https://tobiasfshr.github.io/), [Sven Elflein](https://selflein.github.io/), [Qunjie Zhou](https://research.nvidia.com/labs/dvl/author/qunjie-zhou/), [Riccardo de Lutio](https://riccardodelutio.github.io/), [Jiawei Ren](https://jiawei-ren.github.io/), [Jiahui Huang](https://huangjh-pub.github.io/), [Shengyu Huang](https://shengyuh.github.io/), [Marc Pollefeys](https://people.inf.ethz.ch/marc.pollefeys/), [Laura Leal-Taixé](https://research.nvidia.com/labs/dvl/author/laura-leal-taixe/), [Zan Gojcic+](https://zgojcic.github.io/), [Haithem Turki+](https://haithemturki.com/)
+</div>
+
+<p align="center">
+  <img src="assets/nvidia-hq-dvlt.gif" alt="Déjà View demo" width="100%">
+</p>
+
+## Overview
+
+DéjàView (DVLT) is a recurrent transformer for multi-view 3D reconstruction. It
+loops a shared block of frame/global attention with discrete depth indexing,
+producing per-pixel rays, depth, confidence, and camera poses from an unordered
+set of images. Trained once, the number of refinement steps `K` becomes an
+inference-time compute knob, matching or outperforming substantially larger
+feed-forward baselines at a fraction of their parameters.
+
+This repository contains:
+
+- The DVLT model + four configurable ablations (vanilla, decoupled blocks,
+  no `s_out` token, no depth-scaling).
+- Evaluation wrappers for five baselines: VGGT, VGGT-Omega, Depth-Anything-3,
+  MapAnything, and Pi3. Each wrapper imports the upstream package (installed
+  separately — see [INSTALL.md](docs/INSTALL.md)).
+- A training stack built on `accelerate` + Hydra, with optional W&B logging.
+- A Stage-2 fine-tune recipe for the depth-conv head.
+- Rerun-based visualization tools.
+
+## Release status
+
+- [x] Inference code
+- [x] Model weights
+- [x] Evaluation code
+  - [x] eval datasets preprocess and loaders
+- [x] Training code
+  - [x] ScanNet++ training dataset loader
+  - [ ] other training dataset loaders
+
+## Quickstart
+
+### Install
+
+See [docs/INSTALL.md](docs/INSTALL.md). The short version:
+
+```bash
+conda create -n dvlt python=3.12 && conda activate dvlt
+conda install pytorch=2.5.1 torchvision pytorch-cuda=12.4 -c pytorch -c nvidia -c conda-forge
+pip install -e .[all]
+```
+
+### Quick setup
+
+Quick example script:
+
+```python
+import torch
+from accelerate import Accelerator
+
+from dvlt.model.dvlt.model import DVLT
+from dvlt.util.preprocess import load_sequence, preprocess_images
+
+checkpoint_path = "nvidia/dvlt"  # local dir, HTTPS URL, or HF Hub repo id
+# load_sequence accepts a directory, a single video, or an explicit list of files.
+input_path = "path/to/scene_dir"
+# Or: input_path = "path/to/clip.mp4"
+# Or: from glob import glob; input_path = sorted(glob("path/to/scene_dir/*.png"))
+
+accelerator = Accelerator(mixed_precision="bf16")
+
+model = DVLT(img_size=504)
+model.load_pretrained(checkpoint_path, strict=True)
+model.setup_test(accelerator)
+
+_, frames = load_sequence(input_path)
+batch = preprocess_images(frames, img_size=504, patch_size=14, device=accelerator.device)
+
+with torch.no_grad(), accelerator.autocast():
+    predictions = model.predict(batch, accelerator)
+
+cameras = predictions["cameras"][0]            # Cameras object with shape [S]
+extrinsics_c2w = cameras.camera_to_worlds       # (S, 3, 4) — OpenCV convention [R | t]
+intrinsics = cameras.get_intrinsics_matrices()  # (S, 3, 3)
+
+depths = predictions["depths"][0]              # (S, H, W)
+world_points = predictions["world_points"][0]  # (S, H, W, 3)
+```
+
+### Train
+
+```bash
+# Single-GPU
+python -m dvlt.scripts.train --config-name dvlt-large data=scannetpp
+
+# Multi-GPU (4 GPUs)
+accelerate launch --num-processes 4 -m dvlt.scripts.train --config-name dvlt-large data=scannetpp
+
+# Resume
+python -m dvlt.scripts.train \
+    --config-dir=outputs/<run> \
+    --config-name=config.yaml \
+    trainer.resume_from_checkpoint=latest
+```
+
+### Evaluate
+
+`benchmark_lite` (DTU, ETH3D, 7Scenes) is a convenience benchmark over the
+datasets that don't require heavy preprocessing; the full `benchmark` adds
+[ScanNet++](src/dvlt/scripts/preprocess/preprocess_scannetpp.md) and
+[NuScenes](src/dvlt/scripts/preprocess/preprocess_nuscenes.md).
+
+```bash
+python -m dvlt.scripts.test --config-name dvlt data=benchmark
+# multi-GPU: accelerate launch --num-processes <N> -m dvlt.scripts.test --config-name dvlt data=benchmark
+python -m dvlt.scripts.test --config-name dvlt data=benchmark_lite
+# multi-GPU: accelerate launch --num-processes <N> -m dvlt.scripts.test --config-name dvlt data=benchmark_lite
+```
+
+DVLT reference results on the full `benchmark`:
+
+| Dataset | Pose AUC@3 | Pose AUC@30 | Depth inlier@3% | Depth AbsRel |
+|---|---|---|---|---|
+| DTU | 0.8319 | 0.9880 | 0.9706 | 0.0093 |
+| ETH3D | 0.6604 | 0.9536 | 0.7717 | 0.0267 |
+| 7Scenes | 0.1393 | 0.8172 | 0.7437 | 0.0349 |
+| ScanNet++ | 0.7941 | 0.9803 | 0.9239 | 0.0167 |
+| NuScenes | 0.4340 | 0.8534 | 0.5853 | 0.0673 |
+
+
+### Interactive demo
+
+Browser UI for uploading images / video and exploring the predicted 3D point
+cloud, depth maps and camera trajectory. The dropdown switches between DVLT
+and the baseline wrappers (VGGT, VGGT-Omega, DA3, Pi3, MapAnything);
+each baseline requires its upstream package installed (see
+[docs/INSTALL.md](docs/INSTALL.md)).
+
+```bash
+# Launch on http://localhost:7860 (DVLT preselected)
+python -m dvlt.scripts.gradio_demo
+```
+
+The same script also has a headless **offline mode** that skips Gradio
+and writes a `.glb` + `.rrd` per (sequence, model) under
+`demo_outputs/<sequence_name>/`. `--input` accepts a directory of images, a
+single image, or a video file (mp4/mov/gif/...), and may be repeated to
+process multiple sequences in one go; `--models` is a comma-separated list of
+config names from the curated registry (or `all`).
+
+```bash
+# Run two models on two sequences (one image dir, one video)
+python -m dvlt.scripts.gradio_demo --offline \
+    --input /path/to/scene_dir \
+    --input /path/to/clip.mp4 \
+    --models dvlt
+
+# Run every registered model on one sequence
+python -m dvlt.scripts.gradio_demo --offline --input /path/to/scene_dir --models all
+```
+
+## Configuration
+
+DVLT uses [Hydra](https://hydra.cc) for configuration. Top-level experiment
+configs live in `src/dvlt/config/experiments/`:
+
+| Config | Description |
+|---|---|
+| `dvlt-large` | Stage-1 recipe (large model, full training schedule, linear depth head). |
+| `dvlt-large-ablation` | Vanilla ablation parent — toggle decoupled blocks, no-`s_out`, no-depthscale via overrides. |
+| `dvlt-large-ablation-decoupled` | Fully decoupled blocks (`recurrence_mode=none`, no looping): a distinct block per step, fixed 16 steps. |
+| `dvlt-large-depthconv-stage2` | Stage-2 depth-conv head fine-tune (matches the released checkpoint and the model's default `depth_head_type="conv"`). |
+| `dvlt` | Inference-only alias for the released stage-2 checkpoint. |
+| `vggt`, `vggt_omega`, `da3-{base,large,giant}`, `pi3`, `pi3x`, `mapanything` | Eval-only baseline wrappers. Require the upstream package installed (see [INSTALL.md](docs/INSTALL.md)). |
+
+### User configuration (data paths)
+
+Per-user settings (most importantly, the dataset root) live in
+`src/dvlt/config/experiments/user/`. Copy `default.yaml` to `local.yaml`,
+edit `data_root`, and select it via `user=local`:
+
+```bash
+python -m dvlt.scripts.train --config-name dvlt-large data=scannetpp user=local
+```
+
+`user.data_root` can also be overridden inline or via the `DVLT_DATA_ROOT`
+environment variable.
+
+### Selecting datasets
+
+Pick a single curated dataset config:
+
+```bash
+python -m dvlt.scripts.train --config-name dvlt-large data=scannetpp
+python -m dvlt.scripts.train --config-name dvlt-large data=mixed_all
+```
+
+## Tab completion
+
+For scripts using the `@cli` decorator (train, test, visualize):
+
+```bash
+eval "$(python -m dvlt.scripts.train -sc install)"
+# later, to remove:
+eval "$(python -m dvlt.scripts.train -sc uninstall)"
+```
+
+## Documentation
+
+- [docs/INSTALL.md](docs/INSTALL.md) — environment setup + baseline installs
+- [docs/data/DATA.md](docs/data/DATA.md) — data pipeline overview + how to
+  add a new dataset parser
+- [docs/CONTRIB.md](docs/CONTRIB.md) — dev setup, code style, tests
+- [docs/TESTING.md](docs/TESTING.md) — full test-runner documentation
+
+## Acknowledgments
+
+We are also grateful to several other open-source repositories that we drew inspiration from or built upon during the development of our pipeline:
+- [VGGT](https://github.com/facebookresearch/vggt)
+- [Pi3](https://github.com/yyfz/Pi3)
+- [CUT3R](https://github.com/CUT3R/CUT3R)
+- [MapAnything](https://github.com/facebookresearch/map-anything)
+- [Depth-Anything-3](https://github.com/bytedance-seed/depth-anything-3)
+
+## Citation
+
+If you find this work useful, please cite:
+
+```bibtex
+@article{burzio2026dejaview,
+  title   = {D\'ej\`a View: Looping Transformers for Multi-View 3D Reconstruction},
+  author  = {Burzio, Alessandro and Fischer, Tobias and Elflein, Sven and Zhou, Qunjie and de Lutio, Riccardo and Ren, Jiawei and Huang, Jiahui and Huang, Shengyu and Pollefeys, Marc and Leal-Taix{\'e}, Laura and Gojcic, Zan and Turki, Haithem},
+  journal = {arXiv preprint arXiv:2605.30215},
+  year    = {2026}
+}
+```
+
+## License + attribution
+
+The DVLT **code** is released under the **Apache License, Version 2.0** — see
+[LICENSE](LICENSE). The **model weights** (the `nvidia/dvlt` checkpoint) are
+released under the **NVIDIA License** — non-commercial, research-and-evaluation
+use only; see [LICENSES/NVIDIA-LICENSE.txt](LICENSES/NVIDIA-LICENSE.txt).
+
+Portions of the codebase are adapted from third-party open-source projects
+(DINOv2, PyTorch3D, MoGe, AnyCalib, MultiNeRF, Depth-Anything-3, VGGT). Each
+adapted file carries the upstream copyright + license notice in its header;
+see [THIRD_PARTY_LICENSES.md](THIRD_PARTY_LICENSES.md) for the full attribution
+map and full upstream license texts. The VGGT-derived files are distributed
+under the VGGT License; see [LICENSES/VGGT-LICENSE.txt](LICENSES/VGGT-LICENSE.txt).
+
+The baseline evaluation wrappers in `src/dvlt/model/{vggt,vggt_omega,da3,mapanything,pi3}/`
+import (do not vendor) their respective upstream packages, each of which is
+governed by its own license — see
+[THIRD_PARTY_LICENSES.md](THIRD_PARTY_LICENSES.md) §"Upstream packages used
+for evaluation".

packages/dvlt/repo/docs/CONTRIB.md

@@ -0,0 +1,97 @@
+# Contribution guidelines
+
+If you contribute to the codebase, please follow these steps
+
+
+## Development Setup
+
+If you're contributing to the codebase, we recommend installing the development dependencies and setting up pre-commit hooks:
+
+```bash
+# Install development dependencies
+pip install -e .[dev]
+
+# Install pre-commit hooks
+pip install pre-commit
+pre-commit install
+```
+
+### Code Style
+
+This project uses:
+- Black for code formatting
+- Ruff for linting and import sorting
+- Google-style docstrings
+
+You can manually run the formatters:
+```bash
+# Format code with Black
+black src tests
+
+# Run Ruff linter and auto-fix Ruff violations where possible
+ruff check --fix src tests
+```
+
+### Running Tests
+
+The project has a comprehensive test suite with smart hardware detection. For quick development feedback:
+
+```bash
+# Fast CPU-only tests (recommended for development)
+python tests/run_tests.py --category cpu
+
+# All tests appropriate for your hardware
+python tests/run_tests.py
+
+# Run specific test categories
+python tests/run_tests.py --category cpu           # CPU-only tests (fast, no GPU required)
+python tests/run_tests.py --category gpu           # GPU tests (single GPU, not integration)
+python tests/run_tests.py --category integration   # Integration tests (requires GPU for performance)
+python tests/run_tests.py --category distributed   # Distributed tests (requires accelerate launch)
+python tests/run_tests.py --category slow          # Slow/comprehensive tests
+
+# List all available test categories
+python tests/run_tests.py --list
+```
+
+For direct pytest usage:
+```bash
+# Run all tests (NOTE: Cannot run distributed tests)
+pytest
+
+# Run specific test file
+pytest tests/path/to/test_file.py
+```
+
+See [docs/TESTING.md](TESTING.md) for comprehensive testing documentation.
+
+The pre-commit hooks automatically run fast tests before each commit to ensure code quality.
+
+## Sanity Check Mode
+
+For quick development testing of training functionality, use the built-in sanity check mode (with your desired config):
+
+```bash
+# Instead of long training runs for testing
+python -m dvlt.scripts.train --config-name dvlt-large.yaml trainer.sanity_check=True
+```
+
+This mode:
+- **Tests all key functions**: train_step, test_step, log_train, log_test, model saving
+- **Uses temporary directories**: No persistent output clutter
+- **Mock loggers**: Prints logged keys/types instead of creating wandb runs
+- **Fast execution**: Runs 11 training steps + 2 validation batches (~1-2 minutes)
+- **Auto cleanup**: Removes temporary files when complete
+
+Automatically overrides settings to:
+- `max_train_steps=11`, `validation_steps=11`, `validation_batches=2`
+- `log_every_n_steps=1`
+
+
+## Design
+
+Check [DATA.md](docs/data/DATA.md) for an overview of the data pipeline flow. We explain there:
+
+- How to add new parsers for arbitrary new datasets
+- How to maintain and extend the data preprocessing code
+- What batch format the model will be fed during training and evaluation

packages/dvlt/repo/docs/INSTALL.md

@@ -0,0 +1,74 @@
+# Installation
+
+Tested with **Python 3.11**, **PyTorch 2.5.1**, and **CUDA 12.4** on Linux.
+
+```bash
+conda create -n dvlt python=3.11 && conda activate dvlt
+conda install pytorch=2.5.1 torchvision pytorch-cuda=12.4 -c pytorch -c nvidia -c conda-forge
+
+git clone <YOUR-DVLT-REMOTE>.git dvlt && cd dvlt
+pip install -e .[all]
+```
+
+Extras (pick what you need): `pip install -e .[demos|dev|all]`
+
+- `demos` — Gradio demos (`gradio`, `onnxruntime-gpu`, `trimesh`)
+- `dev`   — `black`, `ruff`, `pre-commit`, `pytest`
+- `all`   — both
+
+## Baselines (optional)
+
+The baseline wrappers in `src/dvlt/model/{vggt,vggt_omega,da3,mapanything,pi3}/`
+import the upstream packages at runtime. Install only the ones you plan to
+evaluate:
+
+```bash
+# VGGT — code: commercial-use-friendly; checkpoints: original
+# is non-commercial, VGGT-1B-Commercial allows commercial use. See upstream LICENSE.
+pip install git+https://github.com/facebookresearch/vggt.git --no-deps
+
+# VGGT-Omega — FAIR Noncommercial Research License (non-commercial / research-only;
+# applies to both code and checkpoints). See upstream LICENSE.
+pip install git+https://github.com/facebookresearch/vggt-omega.git --no-deps
+
+# Depth-Anything-3 — Apache-2.0
+pip install git+https://github.com/ByteDance-Seed/Depth-Anything-3.git --no-deps
+
+# MapAnything — Apache-2.0
+pip install git+https://github.com/facebookresearch/map-anything.git --no-deps
+pip install uniception==0.1.6
+
+# Pi3 / Pi3X — BSD-3-Clause (clone into third_party/Pi3 first)
+git clone https://github.com/<pi3-upstream>/Pi3.git third_party/Pi3
+pip install -e third_party/Pi3 --no-deps
+```
+
+See [THIRD_PARTY_LICENSES.md](../THIRD_PARTY_LICENSES.md) §"Upstream packages
+used for evaluation" for license details — verify each upstream's terms suit
+your use case before installing.
+
+## Data backend (`dataverse`)
+
+DVLT's dataset parsers depend on the `dataverse` package.
+
+```bash
+git clone <YOUR-DATAVERSE-REMOTE>.git third_party/dataverse
+pip install -e third_party/dataverse
+```
+
+Some datasets need extra dependencies — install the matching extras as needed,
+for example:
+
+```bash
+pip install -e 'third_party/dataverse[kubric]'
+```
+
+The Gradio demos and `dvlt.scripts.visualize` work without `dataverse`; the
+full training stack does not.
+
+## Sanity check
+
+```bash
+python -c "import dvlt; print('dvlt OK')"
+pytest -q tests/data/datasets/
+```

packages/dvlt/repo/docs/TESTING.md

@@ -0,0 +1,134 @@
+# Testing Guide
+
+## 🚀 Quick Start
+
+```bash
+# Run all appropriate tests for your hardware (default)
+python tests/run_tests.py
+
+# Run specific categories
+python tests/run_tests.py -c cpu              # CPU tests only
+python tests/run_tests.py -c gpu              # GPU tests (requires CUDA)
+python tests/run_tests.py -c integration      # Integration tests (requires GPU)
+python tests/run_tests.py -c distributed      # Distributed tests (requires multiple GPUs)
+
+# See all available categories
+python tests/run_tests.py --list
+```
+
+## 📋 Test Categories
+
+The system uses **explicit pytest markers** to categorize tests:
+
+### Available Categories
+
+| Category | Command | Marker Required | Hardware | Description |
+|----------|---------|----------------|----------|-------------|
+| **cpu** | `pytest tests/ -m "not gpu and not distributed and not slow and not integration"` | None | Any CPU | Fast CPU-only tests |
+| **gpu** | `pytest tests/ -m "gpu and not distributed and not integration"` | `@pytest.mark.gpu` | NVIDIA GPU | GPU tests (excluding integration) |
+| **integration** | `pytest tests/ -m "integration and not distributed"` | `@pytest.mark.integration` | NVIDIA GPU | End-to-end tests |
+| **slow** | `pytest tests/ -m "slow"` | `@pytest.mark.slow` | Varies | Time-intensive tests |
+| **distributed** | `accelerate launch --num_processes 2 -m pytest tests/ -m "distributed"` | `@pytest.mark.distributed` | 2+ GPUs | Multi-GPU tests |
+
+### Default Behavior (Intelligent Hardware Detection)
+
+When no category is specified, the system automatically runs appropriate tests:
+- **CPU only**: Runs CPU tests
+- **Single GPU**: Runs CPU + GPU + Integration tests
+- **Multiple GPUs**: Runs All tests including Distributed
+
+## 🎯 Test Markers
+
+### Required Markers for Non-CPU Tests
+
+```python
+# CPU test (no marker needed - default)
+def test_utility_function():
+    """Fast CPU-only test."""
+    pass
+
+# GPU test
+@pytest.mark.gpu
+def test_device_computation():
+    """Test requiring GPU acceleration."""
+    pass
+
+# Integration test (requires GPU for performance)
+@pytest.mark.integration
+def test_training_pipeline():
+    """End-to-end integration test."""
+    pass
+
+# Distributed test
+@pytest.mark.distributed
+def test_multi_process_sync():
+    """Test requiring multiple GPUs with accelerate launch."""
+    pass
+
+# Slow test
+@pytest.mark.slow
+def test_comprehensive_scenario():
+    """Time-intensive comprehensive test."""
+    pass
+```
+
+## 🚀 Development Workflow
+
+**Recommended testing order:**
+1. **Development**: `python tests/run_tests.py -c cpu` (fast feedback)
+2. **Feature Testing**: `python tests/run_tests.py -c gpu` (when GPU available)
+3. **Integration**: `python tests/run_tests.py -c integration` (end-to-end validation)
+4. **Full Testing**: `python tests/run_tests.py` (all appropriate tests)
+
+## 📝 Adding New Tests
+
+**Choose appropriate marker:**
+- No marker = CPU test (default)
+- `@pytest.mark.gpu` = GPU required
+- `@pytest.mark.integration` = End-to-end test (GPU needed for performance)
+- `@pytest.mark.distributed` = Multi-GPU test
+- `@pytest.mark.slow` = Time-intensive test
+
+**Verify categorization:**
+```bash
+# Test your specific function
+pytest tests/path/to/test_file.py::test_function_name -v
+
+# Run the expected category
+python tests/run_tests.py -c [expected_category]
+```
+
+## 📊 Example Test Structure
+
+```python
+import pytest
+import torch
+from src.dvlt.model.base import BaseModel
+
+# CPU test (no marker)
+def test_model_initialization():
+    model = BaseModel()
+    assert model is not None
+
+# GPU test
+@pytest.mark.gpu
+def test_model_cuda_operations():
+    if not torch.cuda.is_available():
+        pytest.skip("CUDA not available")
+    model = BaseModel().cuda()
+    x = torch.randn(1, 3, 224, 224).cuda()
+    output = model(x)
+    assert output.device.type == 'cuda'
+
+# Integration test
+@pytest.mark.integration
+def test_training_integration():
+    # ... comprehensive training test
+    pass
+
+# Distributed test
+@pytest.mark.distributed
+def test_multi_gpu_training():
+    # ... distributed training test
+    pass
+```

packages/dvlt/repo/docs/data/DATA.md

@@ -0,0 +1,138 @@
+# Dataset Preparation
+
+All dataset paths are resolved from a single config variable, `user.data_root`.
+It defaults to `<project root>/datasets`, and can be overridden with the CLI
+flag `user.data_root=/path/to/data`. The per-dataset configs under
+[`src/dvlt/config/experiments/data/`](../../src/dvlt/config/experiments/data/)
+read from `${user.data_root}/{train,test}/<dataset>`.
+
+Supported datasets and per-dataset preparation:
+
+| Dataset | Use | Preparation | Config |
+|---|---|---|---|
+| DTU | eval | download only (Spann3R mvsnet, see below) | [`dtu.yaml`](../../src/dvlt/config/experiments/data/test_datasets/dtu.yaml) |
+| ETH3D | eval | [`preprocess_eth3d.md`](../../src/dvlt/scripts/preprocess/preprocess_eth3d.md) | [`eth3d.yaml`](../../src/dvlt/config/experiments/data/test_datasets/eth3d.yaml) |
+| 7Scenes | eval | [`preprocess_7scenes.md`](../../src/dvlt/scripts/preprocess/preprocess_7scenes.md) | [`sevenscenes.yaml`](../../src/dvlt/config/experiments/data/test_datasets/sevenscenes.yaml) |
+| NuScenes | eval | [`preprocess_nuscenes.md`](../../src/dvlt/scripts/preprocess/preprocess_nuscenes.md) | [`nuscenes.yaml`](../../src/dvlt/config/experiments/data/test_datasets/nuscenes.yaml) |
+| ScanNet++ | train + eval | [`preprocess_scannetpp.md`](../../src/dvlt/scripts/preprocess/preprocess_scannetpp.md) | [`scannetpp.yaml`](../../src/dvlt/config/experiments/data/test_datasets/scannetpp.yaml) |
+
+Preprocessing scripts live under
+[`src/dvlt/scripts/preprocess/`](../../src/dvlt/scripts/preprocess/) and are run
+as modules, e.g. `python -m dvlt.scripts.preprocess.<dataset>.<script>`. See the
+per-dataset docs above for download + preprocessing details.
+
+---
+
+## DTU (evaluation, download only)
+
+Follow Spann3R for DTU download (mvsnet preprocessed):
+<https://github.com/HengyiWang/spann3r/blob/main/docs/data_preprocess.md#dtu>
+
+Expected layout, one directory per scan, placed under `${user.data_root}/test/dtu`:
+
+```text
+test/dtu/
+└── scanN/
+    ├── images/{00000000.jpg, 00000001.jpg, ...}
+    ├── cams/{00000000_cam.txt, ...}        # MVSnet camera format (world-to-camera)
+    ├── depths/{00000000.npy, ...}          # depth in millimetres
+    └── binary_masks/{00000000.png, ...}    # foreground masks
+```
+
+Consumed by [`test_datasets/dtu.yaml`](../../src/dvlt/config/experiments/data/test_datasets/dtu.yaml)
+(`DTU`).
+
+---
+
+## ETH3D (evaluation)
+
+High-resolution multi-view benchmark. Download the undistorted DSLR images +
+calibration and the GT depth, then undistort the distorted GT depth onto the
+pinhole cameras. Lands under `${user.data_root}/test/eth3d`.
+
+See [`preprocess_eth3d.md`](../../src/dvlt/scripts/preprocess/preprocess_eth3d.md)
+for download + preprocessing. Consumed by
+[`test_datasets/eth3d.yaml`](../../src/dvlt/config/experiments/data/test_datasets/eth3d.yaml).
+
+---
+
+## 7Scenes (evaluation)
+
+Microsoft 7-Scenes RGB-D (640×480). Download the seven scenes and generate the
+projected pseudo-GT depth (via SimpleRecon). Lands under
+`${user.data_root}/test/sevenscenes`. Intrinsics are fixed (focal 525, principal
+point at image centre).
+
+See [`preprocess_7scenes.md`](../../src/dvlt/scripts/preprocess/preprocess_7scenes.md)
+for download + preprocessing. Consumed by
+[`test_datasets/sevenscenes.yaml`](../../src/dvlt/config/experiments/data/test_datasets/sevenscenes.yaml).
+
+---
+
+## NuScenes (evaluation)
+
+Autonomous-driving dataset. Download **v1.0-trainval** (contains the 50 eval
+scenes) and convert to one `scene.h5` per scene (CAM_FRONT images, sparse LiDAR
+depth, camera extrinsics + intrinsics). Lands under
+`${user.data_root}/test/nuscenes/trainval/<scene>/scene.h5`.
+
+See [`preprocess_nuscenes.md`](../../src/dvlt/scripts/preprocess/preprocess_nuscenes.md)
+for download + preprocessing. Consumed by
+[`test_datasets/nuscenes.yaml`](../../src/dvlt/config/experiments/data/test_datasets/nuscenes.yaml).
+
+---
+
+## ScanNet++ (training + evaluation)
+
+Indoor DSLR captures. Render per-frame metric depth from the aligned GT mesh and
+rectify the fisheye images/depth to a pinhole model. The train split
+(`nvs_sem_train`) lands under `${user.data_root}/train/scannetpp`, the eval split
+(`nvs_sem_val`) under `${user.data_root}/test/scannetpp`.
+
+See [`preprocess_scannetpp.md`](../../src/dvlt/scripts/preprocess/preprocess_scannetpp.md)
+for download + preprocessing. Consumed by
+[`train_datasets/scannetpp.yaml`](../../src/dvlt/config/experiments/data/train_datasets/scannetpp.yaml)
+and
+[`test_datasets/scannetpp.yaml`](../../src/dvlt/config/experiments/data/test_datasets/scannetpp.yaml).
+
+---
+
+## Training datasets
+
+Only **ScanNet++** is included as a runnable training dataset in this release.
+The other training-dataset configs under
+[`train_datasets/`](../../src/dvlt/config/experiments/data/train_datasets/) are
+kept so that the per-dataset frame/view-sampling configuration stays visible
+(`view_ranking`, `view_sampling`, `window_size_ratio`, `max_depth_thresh`,
+etc.), but their loaders and preprocess scripts are WIP.
+
+---
+
+## Data pipeline (overview)
+
+Parsers convert dataset-specific formats into a unified representation in three
+stages:
+
+1. **Parse + per-frame preprocess** - `TrainDataset.get_data()` (training) or
+   `EvalDataset.__getitem__()` (eval): sample frames, read raw data, then
+   resize/crop each frame and update intrinsics/depth/world-points accordingly.
+   Output: per-frame numpy arrays.
+2. **Sequence-level processing** - `MultiSourceDataset._build_sample()`: color
+   augmentations (training), scene normalization (centre + scale factor), and
+   conversion to PyTorch tensors.
+3. **Batch assembly** - `default_collate_fn()`: stack samples into a batch with
+   field-specific padding.
+
+The batched sample the model consumes (keys are `DataField`s):
+
+```python
+{
+    DataField.IMAGES:        torch.Tensor,  # [B, S, C, H, W], float32, [0,1]
+    DataField.DEPTHS:        torch.Tensor,  # [B, S, H, W],    float32
+    DataField.EXTRINSICS_C2W:torch.Tensor,  # [B, S, 4, 4],    float32 (normalized)
+    DataField.INTRINSICS:    torch.Tensor,  # [B, S, 3, 3],    float32
+    DataField.WORLD_POINTS:  torch.Tensor,  # [B, S, H, W, 3], float32 (normalized)
+    DataField.POINT_MASKS:   torch.Tensor,  # [B, S, H, W],    bool
+    DataField.SCALE_FACTOR:  torch.Tensor,  # [B],             float32
+}
+```

packages/dvlt/{pyproject.toml → repo/pyproject.toml}

@@ -3,7 +3,7 @@ name = "dvlt"
 version = "0.0.1"
 description = "Déjà View: Looping Transformers for Multi-View 3D Reconstruction"
 readme = "README.md"
-requires-python = ">= 3.10"
+requires-python = ">= 3.11"
 license = { file = "LICENSE" }
 authors = [
     {name = "Tobias Fischer", email = "tobiasfischer623@gmail.com"},
@@ -24,17 +24,17 @@ dependencies = [
     # core
     "accelerate==1.8.1",
     "h5py==3.16.0",
-    "huggingface-hub>=0.30",     # EDIT: was ==1.16.4 — relaxed so it co-resolves with gradio/spaces on the Space
+    "huggingface-hub==1.16.4",
     "hydra-core==1.3.2",
     "numpy==2.4.4",
     "omegaconf==2.3.0",
     "opencv-python==4.11.0.86",
     "Pillow==11.2.1",
-    "pydantic==2.12.4",
+    "pydantic>=2.0",
     "safetensors==0.5.3",
     "scipy==1.16.0",
-    "torch>=2.5",                # EDIT: was ==2.5.1 — ZeroGPU (Blackwell) ships torch>=2.8
-    "torchvision>=0.20",         # EDIT: was ==0.20.1 — must track the installed torch
+    "torch>=2.5.1",
+    "torchvision>=0.20.1",
     "tqdm==4.67.1",
     # logging + console
     "rich==14.3.3",
@@ -50,6 +50,7 @@ dependencies = [
 
 [project.optional-dependencies]
 demos = [
+    # interactive gradio demos
     "gradio==6.1.0",
     "onnxruntime-gpu==1.25.0",
     "requests==2.32.4",
@@ -63,10 +64,104 @@ dev = [
 ]
 all = ["dvlt[demos,dev]"]
 
+
+# Using setuptools as the build backend
 [build-system]
 requires = ["setuptools>=61.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
+# setuptools configuration
 [tool.setuptools.packages.find]
 where = ["src"]
 include = ["dvlt*"]
+
+# Black configuration
+[tool.black]
+line-length = 120
+target-version = ["py310"]
+include = '\.pyi?$'
+extend-exclude = '''
+# A regex preceded with ^/ will apply only to files and directories
+# in the root of the project.
+^/build/
+'''
+
+# Ruff configuration
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+# Enable various linting rules:
+# E: pycodestyle errors (PEP 8 style guide)
+# F: Pyflakes (detects logical errors)
+# I: isort (import sorting)
+# N: pep8-naming (naming conventions)
+# W: pycodestyle warnings
+# B: flake8-bugbear (additional bug detection)
+# UP: pyupgrade (upgrade syntax to newer Python)
+# PL: Pylint (general Python linting)
+# RUF: Ruff-specific rules
+lint.select = ["E", "F", "I", "W", "B", "PLE", "PLW", "PLC", "PLR"]
+lint.ignore = [
+    "E731",  # lambda expression
+    "E501",  # Line too long.
+    "PLR2004",  # Magic value used in comparison.
+    "PLR0915",  # Too many statements.
+    "PLR0913",  # Too many arguments.
+    "PLC0414",  # Import alias does not rename variable. (this is used for exporting names)
+    "PLC1901",  # Use falsey strings.
+    "PLR0911",  # Too many return statements.
+    "PLR0912",  # Too many branches.
+    "PLW2901",  # For loop variable overwritten.
+    "B027",     # Allow empty methods in abstract base class
+]
+
+# Specify directories that should be checked
+include = ["src/**/*.py", "tests/**/*.py"]
+
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+]
+
+# Allow unused variables when underscore-prefixed.
+lint.dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.lint.mccabe]
+max-complexity = 10
+
+[tool.ruff.lint.isort]
+known-first-party = ["dvlt", "tests"]
+force-single-line = false
+lines-after-imports = 2
+
+[tool.ruff.lint.flake8-quotes]
+docstring-quotes = "double"
+inline-quotes = "single"
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]