The Depot — Innovation Labs

Overview

The Depot is a single Docker container running on the home lab, reachable from any device on the local network. Its one job: store .exe and .zip files, organised by category, and make them fast to find and download when a job needs them. No login, no cloud, no accounts. Local network only. Just files, organised, available.

The smart bit is the auto-describe feature — when you drop a file, The Depot guesses a clean name, web-searches it, and suggests a one-line description and best-guess category. Both go into the form for you to keep or edit. Nothing is committed automatically. A "Look it up" button re-runs the search on demand.

Every upload is SHA-256 hashed. Re-uploading the same bytes is blocked with a clear message, even under a different filename. Two genuinely different files that happen to share a name still coexist fine.

500 MB per file cap

9 Categories

6 API Routes

1 Container

What It Does

📥

Store

› Drag-and-drop or click-to-browse upload
› .exe and .zip files, up to 500 MB each
› Each file filed with: name, category, type (Installer / Portable / Archive), optional description
› Auto-describe: guesses name + description + category from the filename via DuckDuckGo Instant Answer — editable before saving
› SHA-256 de-duplication — same bytes blocked even under a different filename

🔍

Browse & Find

› Crate grid showing name, badges, size, date, description
› Sort: Newest · Oldest · Name A–Z · Largest · Category
› Search: real-time client-side, matches name / description / filename
› Filter: category and type pills, stackable (e.g. Networking + Portable)
› Footer stats: live count of crates, total size, categories in use

📤

Retrieve & Manage

› One-click download — original filename preserved exactly
› Copy link — copies the absolute download URL to paste into another machine
› Delete — two-step confirm (Delete → "Sure?") so nothing goes by accident
› Deletes both the DB row and the file on disk
› Keyboard: / jumps to search, Esc cancels upload or clears search

Small Footprint. Fast to Load.

The entire UI lives in a single templates/index.html file — CSS and JS inline, no framework, no build step. After initial load, all search, filter, and sort operations are client-side and never round-trip to the server.

The Flask backend handles only what it needs to: file I/O, database writes, hashing, and the one external call — a DuckDuckGo Instant Answer lookup using Python's standard library (urllib only, no API key). Everything else is fully local.

Files are stored on disk as <id>_<originalname> — the ID prefix prevents collisions while the original name is preserved in the database and handed back verbatim on every download. In Docker both the files and the SQLite database live in a single /app/data directory that is bind-mounted to the host, so data survives every rebuild.

DATA FLOW

Upload ↓ SHA-256 hash → duplicate? block ↓ Write to disk _ ↓ SQLite row name, category, type, description, size, hash Download ↓ Serve file original filename preserved exactly Auto-describe ↓ DuckDuckGo API (stdlib urllib, no key) ↓ Suggest name + category editable before save

API Routes

Method	Route	Purpose
GET	/	Serve the UI
GET	/api/files	All file metadata as JSON
GET	/api/lookup?filename=…	Suggest a description + category from a filename — not saved
POST	/api/upload	Multipart upload + metadata; hashes and de-dupes
GET	/api/download/<id>	Serve the file with its original filename
DELETE	/api/delete/<id>	Remove file and metadata row

Database Schema

SQLITE — files TABLE

CREATE TABLE files ( id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, filename TEXT NOT NULL, -- original name, returned verbatim on download category TEXT NOT NULL, type TEXT NOT NULL, -- Installer | Portable | Archive description TEXT, size_bytes INTEGER, sha256 TEXT, -- exact-duplicate blocking uploaded_at DATETIME DEFAULT CURRENT_TIMESTAMP );

Older databases are auto-migrated to add the sha256 column on startup — no manual migration needed.

Design Decisions

Content-based de-duplication

De-duplication is by SHA-256 hash, not filename. The same tool downloaded twice is rejected; two different tools that share a name are both allowed.

Auto-describe suggests, never decides

Every guess from the DuckDuckGo lookup is editable before saving. The Depot removes the busywork without taking control away.

Single mounted data directory

Both uploads and the SQLite database live under one bind-mounted /app/data directory. Binding the DB as a lone file would cause Docker to silently create a directory instead, breaking SQLite.

Fixed category list in code

Categories are defined in app.py, not stored in the database. Keeps the UI clean. New categories are a one-line code change, not a UI feature.

Everything client-side after load

Search, filter, and sort never round-trip to the server. All file metadata is loaded once at page load; all operations run in the browser.

Two-step delete

Delete button changes to "Sure?" before committing. Prevents accidental deletion with no undo — the file and its DB row are both removed permanently.

Tech Stack

Python 3Backend language

FlaskWeb framework — lightweight, no ORM needed

gunicornProduction WSGI server — 2 workers, 600s timeout for large uploads

SQLiteOne file, no server — auto-migrated on startup

DockerSingle container, builds from source

Vanilla HTML/CSS/JSEntire UI in one template — no framework, no build step

urllib (stdlib)DuckDuckGo Instant Answer lookup — no API key, no third-party lib

hashlib (stdlib)SHA-256 for content de-duplication

PortainerContainer management on the home lab

Screenshot

THE DEPOT — FILE VAULT UI