django-rclone 0.1.0__tar.gz

django_rclone-0.1.0/.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+  - package-ecosystem: pip
+    directory: /
+    schedule:
+      interval: weekly
+
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly

django_rclone-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,37 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: astral-sh/setup-uv@v7
+      - run: uv sync
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: astral-sh/setup-uv@v7
+      - run: uv sync
+      - run: uv run ty check
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.13"]
+    steps:
+      - uses: actions/checkout@v6
+      - uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: uv sync
+      - run: uv run pytest

django_rclone-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,17 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v6
+      - uses: astral-sh/setup-uv@v7
+      - run: uv build
+      - uses: pypa/gh-action-pypi-publish@release/v1

django_rclone-0.1.0/.gitignore

@@ -0,0 +1,32 @@
+# Python artifacts
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+wheels/
+
+# Virtual environments
+.venv/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Coverage / test
+.coverage
+htmlcov/
+.pytest_cache/
+
+# Environment
+.env
+
+# rclone
+rclone.conf

django_rclone-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,15 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.0
+    hooks:
+      - id: ruff-check
+        args: [--fix]
+      - id: ruff-format
+  - repo: local
+    hooks:
+      - id: ty-check
+        name: ty check
+        entry: uv run ty check
+        language: system
+        types: [python]
+        pass_filenames: false

django_rclone-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

django_rclone-0.1.0/CLAUDE.md

@@ -0,0 +1,22 @@
+# django-rclone
+
+Django package that wraps rclone for database and media file backups. Intended as a replacement for `django-dbbackup`.
+
+The `django-dbbackup/` directory is included for reference only — it is not part of this project.
+
+## Document lookup
+Use `context7` to check documentation of packages.
+
+## Development
+
+```bash
+uv sync                      # Install dependencies
+uv run ruff check .          # Lint
+uv run ruff format --check . # Check formatting
+uv run ty check              # Type check
+uv run pytest                # Run tests
+```
+
+## CI
+
+GitHub Actions runs lint, type check, and tests on every push/PR. See `.github/workflows/ci.yml`.

django_rclone-0.1.0/PKG-INFO

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: django-rclone
+Version: 0.1.0
+Summary: rclone wrapper for Django database and media file backups
+Project-URL: Repository, https://github.com/j/django-rclone
+License-Expression: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.13
+Requires-Dist: django>=4.2
+Description-Content-Type: text/markdown
+
+# django-rclone
+
+Django database and media backup management commands, powered by [rclone](https://rclone.org/).
+
+django-rclone bridges Django's database layer with rclone's file transfer layer. You get native database dumps piped directly to any of rclone's 70+ supported cloud storage backends -- no temp files, no intermediate archives, no Python reimplementations of what rclone already does.
+
+## Why rclone instead of Django Storages?
+
+[django-dbbackup](https://github.com/Archmonger/django-dbbackup) is a mature and well-regarded backup solution. It wraps Django Storages for upload, implements GPG encryption in Python, handles gzip compression, and parses filenames with regex to manage backups.
+
+django-rclone takes a different approach: **delegate everything that isn't Django-specific to rclone**.
+
+| Concern | django-dbbackup | django-rclone |
+|---|---|---|
+| **Storage backends** | Django Storages (S3, GCS, etc.) | rclone (70+ backends natively) |
+| **Encryption** | GPG subprocess wrapper in Python | rclone `crypt` remote |
+| **Compression** | gzip in Python | rclone `compress` remote or `--compress` flag |
+| **Media backup** | Tar archive, then upload | `rclone sync` (incremental, no archiving) |
+| **Backup listing** | Filename regex parsing | `rclone lsjson` (structured JSON) |
+| **Temp files** | `SpooledTemporaryFile` | None -- pipes directly via `rclone rcat` |
+| **DB passwords** | Passed via CLI args (visible in `ps`) | Env vars for PostgreSQL/MySQL (`PGPASSWORD`, `MYSQL_PWD`) |
+
+The result is significantly less code doing significantly less work. Storage abstraction, encryption, compression, and incremental sync are all rclone's problem -- django-rclone only owns what Django must own: database connectors, management commands, and signals.
+
+## Requirements
+
+- Python 3.13+
+- Django 4.2+
+- [rclone](https://rclone.org/install/) installed and configured
+
+## Installation
+
+```bash
+pip install django-rclone
+```
+
+Add to your `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "django_rclone",
+]
+```
+
+Configure your rclone remote (see [rclone docs](https://rclone.org/docs/)):
+
+```bash
+rclone config
+```
+
+Then point django-rclone at it:
+
+```python
+DJANGO_RCLONE = {
+    "REMOTE": "myremote:backups",
+}
+```
+
+## Usage
+
+### Database backup and restore
+
+```bash
+# Backup the default database
+python manage.py dbbackup
+
+# Backup a specific database
+python manage.py dbbackup --database analytics
+
+# Backup and clean old backups beyond retention count
+python manage.py dbbackup --clean
+
+# Restore from the latest backup
+python manage.py dbrestore
+
+# Restore a specific backup
+python manage.py dbrestore --input-path default-2024-01-15-120000.dump
+
+# Non-interactive restore (for automation)
+python manage.py dbrestore --noinput --input-path default-2024-01-15-120000.dump
+```
+
+### Media backup and restore
+
+```bash
+# Sync MEDIA_ROOT to remote (incremental -- only changed files transfer)
+python manage.py mediabackup
+
+# Sync remote back to MEDIA_ROOT
+python manage.py mediarestore
+```
+
+### List backups
+
+```bash
+# List all database backups
+python manage.py listbackups
+
+# Filter by database
+python manage.py listbackups --database default
+
+# List media files on remote
+python manage.py listbackups --media
+```
+
+## Configuration
+
+All settings live under the `DJANGO_RCLONE` dict in your Django settings:
+
+```python
+DJANGO_RCLONE = {
+    # Required -- rclone remote and base path
+    "REMOTE": "myremote:backups",
+
+    # Optional -- rclone binary and config
+    "RCLONE_BINARY": "rclone",             # Path to rclone binary
+    "RCLONE_CONFIG": None,                 # Path to rclone.conf (None uses default)
+    "RCLONE_FLAGS": [],                    # Extra flags for every rclone call
+
+    # Database backup settings
+    "DB_BACKUP_DIR": "db",                 # Subdirectory for DB backups
+    "DB_FILENAME_TEMPLATE": "{database}-{datetime}.{ext}",  # Must start with {database}
+    "DB_DATE_FORMAT": "%Y-%m-%d-%H%M%S",
+    "DB_CLEANUP_KEEP": 10,                 # Keep N most recent backups per database
+
+    # Media backup settings
+    "MEDIA_BACKUP_DIR": "media",           # Subdirectory for media backups
+
+    # Database connector overrides
+    "CONNECTORS": {},                      # Per-database connector class overrides
+    "CONNECTOR_MAPPING": {},               # Engine-to-connector class overrides
+}
+```
+
+### Encryption and compression
+
+django-rclone does not implement encryption or compression. Instead, configure these at the rclone level where they belong:
+
+**Encryption** -- use a [crypt remote](https://rclone.org/crypt/):
+
+```bash
+rclone config create myremote-crypt crypt remote=myremote:backups password=your-password
+```
+
+Then set `"REMOTE": "myremote-crypt:"` in your Django settings.
+
+**Compression** -- use a [compress remote](https://rclone.org/compress/):
+
+```bash
+rclone config create myremote-compressed compress remote=myremote:backups
+```
+
+Or pass `--compress-level` via `RCLONE_FLAGS`.
+
+## Supported databases
+
+| Database | Connector | Dump tool | Format |
+|---|---|---|---|
+| PostgreSQL | `PgDumpConnector` | `pg_dump` / `pg_restore` | Custom (binary) |
+| PostGIS | `PgDumpGisConnector` | `pg_dump` / `pg_restore` | Custom (binary) |
+| MySQL / MariaDB | `MysqlDumpConnector` | `mysqldump` / `mysql` | SQL text |
+| SQLite | `SqliteConnector` | `sqlite3 .dump` | SQL text |
+| MongoDB | `MongoDumpConnector` | `mongodump` / `mongorestore` | Archive (binary) |
+
+GIS backends (`postgis`, `spatialite`, `gis/mysql`) and `django-prometheus` wrappers are also mapped automatically. See [connectors documentation](docs/connectors.md) for the full engine mapping table.
+
+## Signals
+
+django-rclone sends Django signals before and after each operation:
+
+```python
+from django_rclone.signals import pre_db_backup, post_db_backup
+
+@receiver(post_db_backup)
+def notify_on_backup(sender, database, path, **kwargs):
+    logger.info("Database %s backed up to %s", database, path)
+```
+
+Available signals: `pre_db_backup`, `post_db_backup`, `pre_db_restore`, `post_db_restore`, `pre_media_backup`, `post_media_backup`, `pre_media_restore`, `post_media_restore`.
+
+## Architecture
+
+```
+Management Commands (dbbackup, dbrestore, mediabackup, mediarestore, listbackups)
+        |                           |
+   DB Connectors              rclone.py
+   (pg, mysql, sqlite,    (subprocess wrapper)
+    mongodb)
+        |                           |
+   Database binary              rclone binary
+                          (70+ storage backends)
+```
+
+Database dumps stream directly from the dump process into `rclone rcat` via Unix pipes. No intermediate files are written. Restores work in reverse: `rclone cat` streams into the database restore process.
+
+Media backups use `rclone sync`, which is incremental by default -- only changed files are transferred.
+
+## License
+
+MIT

django_rclone-0.1.0/README.md

@@ -0,0 +1,201 @@
+# django-rclone
+
+Django database and media backup management commands, powered by [rclone](https://rclone.org/).
+
+django-rclone bridges Django's database layer with rclone's file transfer layer. You get native database dumps piped directly to any of rclone's 70+ supported cloud storage backends -- no temp files, no intermediate archives, no Python reimplementations of what rclone already does.
+
+## Why rclone instead of Django Storages?
+
+[django-dbbackup](https://github.com/Archmonger/django-dbbackup) is a mature and well-regarded backup solution. It wraps Django Storages for upload, implements GPG encryption in Python, handles gzip compression, and parses filenames with regex to manage backups.
+
+django-rclone takes a different approach: **delegate everything that isn't Django-specific to rclone**.
+
+| Concern | django-dbbackup | django-rclone |
+|---|---|---|
+| **Storage backends** | Django Storages (S3, GCS, etc.) | rclone (70+ backends natively) |
+| **Encryption** | GPG subprocess wrapper in Python | rclone `crypt` remote |
+| **Compression** | gzip in Python | rclone `compress` remote or `--compress` flag |
+| **Media backup** | Tar archive, then upload | `rclone sync` (incremental, no archiving) |
+| **Backup listing** | Filename regex parsing | `rclone lsjson` (structured JSON) |
+| **Temp files** | `SpooledTemporaryFile` | None -- pipes directly via `rclone rcat` |
+| **DB passwords** | Passed via CLI args (visible in `ps`) | Env vars for PostgreSQL/MySQL (`PGPASSWORD`, `MYSQL_PWD`) |
+
+The result is significantly less code doing significantly less work. Storage abstraction, encryption, compression, and incremental sync are all rclone's problem -- django-rclone only owns what Django must own: database connectors, management commands, and signals.
+
+## Requirements
+
+- Python 3.13+
+- Django 4.2+
+- [rclone](https://rclone.org/install/) installed and configured
+
+## Installation
+
+```bash
+pip install django-rclone
+```
+
+Add to your `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "django_rclone",
+]
+```
+
+Configure your rclone remote (see [rclone docs](https://rclone.org/docs/)):
+
+```bash
+rclone config
+```
+
+Then point django-rclone at it:
+
+```python
+DJANGO_RCLONE = {
+    "REMOTE": "myremote:backups",
+}
+```
+
+## Usage
+
+### Database backup and restore
+
+```bash
+# Backup the default database
+python manage.py dbbackup
+
+# Backup a specific database
+python manage.py dbbackup --database analytics
+
+# Backup and clean old backups beyond retention count
+python manage.py dbbackup --clean
+
+# Restore from the latest backup
+python manage.py dbrestore
+
+# Restore a specific backup
+python manage.py dbrestore --input-path default-2024-01-15-120000.dump
+
+# Non-interactive restore (for automation)
+python manage.py dbrestore --noinput --input-path default-2024-01-15-120000.dump
+```
+
+### Media backup and restore
+
+```bash
+# Sync MEDIA_ROOT to remote (incremental -- only changed files transfer)
+python manage.py mediabackup
+
+# Sync remote back to MEDIA_ROOT
+python manage.py mediarestore
+```
+
+### List backups
+
+```bash
+# List all database backups
+python manage.py listbackups
+
+# Filter by database
+python manage.py listbackups --database default
+
+# List media files on remote
+python manage.py listbackups --media
+```
+
+## Configuration
+
+All settings live under the `DJANGO_RCLONE` dict in your Django settings:
+
+```python
+DJANGO_RCLONE = {
+    # Required -- rclone remote and base path
+    "REMOTE": "myremote:backups",
+
+    # Optional -- rclone binary and config
+    "RCLONE_BINARY": "rclone",             # Path to rclone binary
+    "RCLONE_CONFIG": None,                 # Path to rclone.conf (None uses default)
+    "RCLONE_FLAGS": [],                    # Extra flags for every rclone call
+
+    # Database backup settings
+    "DB_BACKUP_DIR": "db",                 # Subdirectory for DB backups
+    "DB_FILENAME_TEMPLATE": "{database}-{datetime}.{ext}",  # Must start with {database}
+    "DB_DATE_FORMAT": "%Y-%m-%d-%H%M%S",
+    "DB_CLEANUP_KEEP": 10,                 # Keep N most recent backups per database
+
+    # Media backup settings
+    "MEDIA_BACKUP_DIR": "media",           # Subdirectory for media backups
+
+    # Database connector overrides
+    "CONNECTORS": {},                      # Per-database connector class overrides
+    "CONNECTOR_MAPPING": {},               # Engine-to-connector class overrides
+}
+```
+
+### Encryption and compression
+
+django-rclone does not implement encryption or compression. Instead, configure these at the rclone level where they belong:
+
+**Encryption** -- use a [crypt remote](https://rclone.org/crypt/):
+
+```bash
+rclone config create myremote-crypt crypt remote=myremote:backups password=your-password
+```
+
+Then set `"REMOTE": "myremote-crypt:"` in your Django settings.
+
+**Compression** -- use a [compress remote](https://rclone.org/compress/):
+
+```bash
+rclone config create myremote-compressed compress remote=myremote:backups
+```
+
+Or pass `--compress-level` via `RCLONE_FLAGS`.
+
+## Supported databases
+
+| Database | Connector | Dump tool | Format |
+|---|---|---|---|
+| PostgreSQL | `PgDumpConnector` | `pg_dump` / `pg_restore` | Custom (binary) |
+| PostGIS | `PgDumpGisConnector` | `pg_dump` / `pg_restore` | Custom (binary) |
+| MySQL / MariaDB | `MysqlDumpConnector` | `mysqldump` / `mysql` | SQL text |
+| SQLite | `SqliteConnector` | `sqlite3 .dump` | SQL text |
+| MongoDB | `MongoDumpConnector` | `mongodump` / `mongorestore` | Archive (binary) |
+
+GIS backends (`postgis`, `spatialite`, `gis/mysql`) and `django-prometheus` wrappers are also mapped automatically. See [connectors documentation](docs/connectors.md) for the full engine mapping table.
+
+## Signals
+
+django-rclone sends Django signals before and after each operation:
+
+```python
+from django_rclone.signals import pre_db_backup, post_db_backup
+
+@receiver(post_db_backup)
+def notify_on_backup(sender, database, path, **kwargs):
+    logger.info("Database %s backed up to %s", database, path)
+```
+
+Available signals: `pre_db_backup`, `post_db_backup`, `pre_db_restore`, `post_db_restore`, `pre_media_backup`, `post_media_backup`, `pre_media_restore`, `post_media_restore`.
+
+## Architecture
+
+```
+Management Commands (dbbackup, dbrestore, mediabackup, mediarestore, listbackups)
+        |                           |
+   DB Connectors              rclone.py
+   (pg, mysql, sqlite,    (subprocess wrapper)
+    mongodb)
+        |                           |
+   Database binary              rclone binary
+                          (70+ storage backends)
+```
+
+Database dumps stream directly from the dump process into `rclone rcat` via Unix pipes. No intermediate files are written. Restores work in reverse: `rclone cat` streams into the database restore process.
+
+Media backups use `rclone sync`, which is incremental by default -- only changed files are transferred.
+
+## License
+
+MIT