s3rds 0.3.2__tar.gz → 0.3.4__tar.gz

{s3rds-0.3.2 → s3rds-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3rds
-Version: 0.3.2
+Version: 0.3.4
 Summary: A truly serverless RDS on your own AWS account: Lambda URL endpoint, SQLite on S3, ≈ $0 when idle. Drivers named after the standard clients: s3rds.sqlite, s3rds.pymysql, s3rds.psycopg2; SQLAlchemy via sqlite+s3rds://, Django via ENGINE s3rds.sqlite.
 Author: Frank Zhang
 License: MIT
@@ -16,20 +16,28 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.1
 Classifier: Topic :: Database
 Classifier: Topic :: Database :: Front-Ends
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: sqlglot<31,>=30.24
 Provides-Extra: mysql
+Requires-Dist: sqlglot<31,>=30.24; extra == "mysql"
+Provides-Extra: postgres
+Requires-Dist: sqlglot<31,>=30.24; extra == "postgres"
 Provides-Extra: server
 Requires-Dist: sqlean.py==3.50.4.5; extra == "server"
 Provides-Extra: sqlalchemy
 Requires-Dist: SQLAlchemy<2.1,>=2.0; extra == "sqlalchemy"
 Provides-Extra: django
-Requires-Dist: Django<6.2,>=6.1; extra == "django"
+Requires-Dist: Django<6.2,>=4.2; extra == "django"
 
 # s3rds
 
@@ -59,11 +67,13 @@ while nobody uses it. Deploy it once with Terraform from the
 **Python drivers for [s3rds](https://github.com/cloudformer/s3rds) — a truly serverless RDS:
 a Lambda URL as your database endpoint, SQLite on S3, ≈ $0 when idle.**
 
-One install, one dependency (sqlglot, used only by `s3rds.pymysql` and `s3rds.psycopg2`). Each driver is a submodule **named after the standard
-client it mirrors**, so moving to a real database is a one-line import change and nothing else:
+No dependencies for the native paths; the translating drivers take an extra. Each driver is a submodule **named after
+the standard client it mirrors**, so moving to a real database is a one-line import change and nothing else:
 
 ```bash
-pip install s3rds    # s3rds.sqlite, s3rds.pymysql, s3rds.psycopg2, sqlite+s3rds:// for SQLAlchemy, ENGINE s3rds.sqlite for Django
+pip install s3rds                # s3rds.sqlite, sqlite+s3rds:// for SQLAlchemy, ENGINE s3rds.sqlite for Django
+pip install "s3rds[mysql]"       # + s3rds.pymysql   (sqlglot: MySQL -> SQLite)
+pip install "s3rds[postgres]"    # + s3rds.psycopg2  (sqlglot: PostgreSQL -> SQLite)
 ```
 
 ```python
@@ -88,13 +98,15 @@ conn.transaction([                                 # all-or-nothing, single S3 w
 ])
 ```
 
-| Submodule | SQL dialect | Mirrors | Status |
-|---|---|---|---|
-| `s3rds.sqlite` | SQLite (no translation) | pymysql-shaped API | available |
-| `s3rds.pymysql` | MySQL, translated on the client | pymysql | available |
-| `s3rds.psycopg2` | PostgreSQL, translated on the client | psycopg2 (`extras`, `errors`, `extensions`) | available |
-| `sqlite+s3rds://` | SQLite, written by SQLAlchemy | SQLAlchemy Core / ORM | available — the URL is the only change |
-| `ENGINE: "s3rds.sqlite"` | SQLite, written by Django | Django's SQLite backend | available — the database settings are the only change |
+| Submodule | Kind | SQL dialect | Mirrors | Install |
+|---|---|---|---|---|
+| `s3rds.sqlite` | native | SQLite (no translation) | pymysql-shaped API | `s3rds` |
+| `sqlite+s3rds://` | native | SQLite, written by SQLAlchemy | SQLAlchemy 2.0 Core / ORM | `s3rds` (+ SQLAlchemy) |
+| `ENGINE: "s3rds.sqlite"` | native | SQLite, written by Django | Django 4.2, 5.2, 6.1 | `s3rds` (+ Django) |
+| `s3rds.pymysql` | translated | MySQL, translated on the client | pymysql | `"s3rds[mysql]"` |
+| `s3rds.psycopg2` | translated | PostgreSQL, translated on the client | psycopg2 (`extras`, `errors`, `extensions`) | `"s3rds[postgres]"` |
+
+Native is the most reliable: the SQL is SQLite's to begin with. For a new project, prefer SQLAlchemy or Django.
 
 **SQLAlchemy** (Core and ORM): only the URL changes — SQLAlchemy's own SQLite dialect writes the SQL,
 `s3rds.sqlite` replaces the standard library's `sqlite3` underneath.
@@ -144,11 +156,11 @@ What the report was verified with; the full report: [REPORT.md](https://github.c
 
 | | Version | Fixed by |
 |---|---|---|
-| Python (client) | 3.9 – 3.13: regression suite on 3.9.6, full comparison on 3.13.7 | `requires-python = ">=3.9"` |
+| Python (client) | 3.9, 3.10, 3.11, 3.12, 3.13, each in CI | `requires-python = ">=3.9"` |
 | Server runtime | AWS Lambda `python3.12` | `terraform/main.tf` |
 | SQLite (server engine) | 3.50.4, shipped in the Lambda zip (the runtime's own is 3.40.0) | extra `pip install "s3rds[server]"` = `sqlean.py==3.50.4.5` |
-| sqlglot (MySQL translation) | 30.24 | dependency `sqlglot>=30.24,<31` |
+| sqlglot (MySQL / PostgreSQL translation) | 30.24 | extras `"s3rds[mysql]"` / `"s3rds[postgres]"` = `sqlglot>=30.24,<31` |
 | SQLAlchemy | 2.0, tested on 2.0.55 | extra `pip install "s3rds[sqlalchemy]"` = `SQLAlchemy>=2.0,<2.1` |
-| Django | 6.1, tested on 6.1.2 (Python ≥ 3.12) | extra `pip install "s3rds[django]"` = `Django>=6.1,<6.2` |
+| Django | 4.2 (Python 3.9, 3.10), 5.2 (3.11, 3.12), 6.1 (3.12, 3.13), each in CI | extra `pip install "s3rds[django]"` = `Django>=4.2,<6.2` |
 | MySQL (reference) | 8.0.46 in Docker | `tests/compat/docker-compose.yml`: `mysql:8.0.46` |
 

{s3rds-0.3.2 → s3rds-0.3.4}/README.md

@@ -26,11 +26,13 @@ while nobody uses it. Deploy it once with Terraform from the
 **Python drivers for [s3rds](https://github.com/cloudformer/s3rds) — a truly serverless RDS:
 a Lambda URL as your database endpoint, SQLite on S3, ≈ $0 when idle.**
 
-One install, one dependency (sqlglot, used only by `s3rds.pymysql` and `s3rds.psycopg2`). Each driver is a submodule **named after the standard
-client it mirrors**, so moving to a real database is a one-line import change and nothing else:
+No dependencies for the native paths; the translating drivers take an extra. Each driver is a submodule **named after
+the standard client it mirrors**, so moving to a real database is a one-line import change and nothing else:
 
 ```bash
-pip install s3rds    # s3rds.sqlite, s3rds.pymysql, s3rds.psycopg2, sqlite+s3rds:// for SQLAlchemy, ENGINE s3rds.sqlite for Django
+pip install s3rds                # s3rds.sqlite, sqlite+s3rds:// for SQLAlchemy, ENGINE s3rds.sqlite for Django
+pip install "s3rds[mysql]"       # + s3rds.pymysql   (sqlglot: MySQL -> SQLite)
+pip install "s3rds[postgres]"    # + s3rds.psycopg2  (sqlglot: PostgreSQL -> SQLite)
 ```
 
 ```python
@@ -55,13 +57,15 @@ conn.transaction([                                 # all-or-nothing, single S3 w
 ])
 ```
 
-| Submodule | SQL dialect | Mirrors | Status |
-|---|---|---|---|
-| `s3rds.sqlite` | SQLite (no translation) | pymysql-shaped API | available |
-| `s3rds.pymysql` | MySQL, translated on the client | pymysql | available |
-| `s3rds.psycopg2` | PostgreSQL, translated on the client | psycopg2 (`extras`, `errors`, `extensions`) | available |
-| `sqlite+s3rds://` | SQLite, written by SQLAlchemy | SQLAlchemy Core / ORM | available — the URL is the only change |
-| `ENGINE: "s3rds.sqlite"` | SQLite, written by Django | Django's SQLite backend | available — the database settings are the only change |
+| Submodule | Kind | SQL dialect | Mirrors | Install |
+|---|---|---|---|---|
+| `s3rds.sqlite` | native | SQLite (no translation) | pymysql-shaped API | `s3rds` |
+| `sqlite+s3rds://` | native | SQLite, written by SQLAlchemy | SQLAlchemy 2.0 Core / ORM | `s3rds` (+ SQLAlchemy) |
+| `ENGINE: "s3rds.sqlite"` | native | SQLite, written by Django | Django 4.2, 5.2, 6.1 | `s3rds` (+ Django) |
+| `s3rds.pymysql` | translated | MySQL, translated on the client | pymysql | `"s3rds[mysql]"` |
+| `s3rds.psycopg2` | translated | PostgreSQL, translated on the client | psycopg2 (`extras`, `errors`, `extensions`) | `"s3rds[postgres]"` |
+
+Native is the most reliable: the SQL is SQLite's to begin with. For a new project, prefer SQLAlchemy or Django.
 
 **SQLAlchemy** (Core and ORM): only the URL changes — SQLAlchemy's own SQLite dialect writes the SQL,
 `s3rds.sqlite` replaces the standard library's `sqlite3` underneath.
@@ -111,11 +115,11 @@ What the report was verified with; the full report: [REPORT.md](https://github.c
 
 | | Version | Fixed by |
 |---|---|---|
-| Python (client) | 3.9 – 3.13: regression suite on 3.9.6, full comparison on 3.13.7 | `requires-python = ">=3.9"` |
+| Python (client) | 3.9, 3.10, 3.11, 3.12, 3.13, each in CI | `requires-python = ">=3.9"` |
 | Server runtime | AWS Lambda `python3.12` | `terraform/main.tf` |
 | SQLite (server engine) | 3.50.4, shipped in the Lambda zip (the runtime's own is 3.40.0) | extra `pip install "s3rds[server]"` = `sqlean.py==3.50.4.5` |
-| sqlglot (MySQL translation) | 30.24 | dependency `sqlglot>=30.24,<31` |
+| sqlglot (MySQL / PostgreSQL translation) | 30.24 | extras `"s3rds[mysql]"` / `"s3rds[postgres]"` = `sqlglot>=30.24,<31` |
 | SQLAlchemy | 2.0, tested on 2.0.55 | extra `pip install "s3rds[sqlalchemy]"` = `SQLAlchemy>=2.0,<2.1` |
-| Django | 6.1, tested on 6.1.2 (Python ≥ 3.12) | extra `pip install "s3rds[django]"` = `Django>=6.1,<6.2` |
+| Django | 4.2 (Python 3.9, 3.10), 5.2 (3.11, 3.12), 6.1 (3.12, 3.13), each in CI | extra `pip install "s3rds[django]"` = `Django>=4.2,<6.2` |
 | MySQL (reference) | 8.0.46 in Docker | `tests/compat/docker-compose.yml`: `mysql:8.0.46` |
 

{s3rds-0.3.2 → s3rds-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "s3rds"
-version = "0.3.2"
+version = "0.3.4"
 description = "A truly serverless RDS on your own AWS account: Lambda URL endpoint, SQLite on S3, ≈ $0 when idle. Drivers named after the standard clients: s3rds.sqlite, s3rds.pymysql, s3rds.psycopg2; SQLAlchemy via sqlite+s3rds://, Django via ENGINE s3rds.sqlite."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -17,21 +17,28 @@ classifiers = [
   "License :: OSI Approved :: MIT License",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Framework :: Django",
+  "Framework :: Django :: 4.2",
+  "Framework :: Django :: 5.2",
+  "Framework :: Django :: 6.1",
   "Topic :: Database",
   "Topic :: Database :: Front-Ends",
 ]
-# one install for every driver. sqlglot: s3rds.pymysql's / s3rds.psycopg2's MySQL / PostgreSQL -> SQLite translation, imported only when a MySQL
-# statement is translated; pinned to the release the compatibility report was verified with (translations
-# change between releases). SQLAlchemy is not a dependency: the applications that use sqlite+s3rds:// have it.
-dependencies = ["sqlglot>=30.24,<31"]
+# no dependencies: s3rds.sqlite (and SQLAlchemy / Django on it) is the standard library only. The translating drivers
+# need sqlglot (MySQL / PostgreSQL -> SQLite), pinned to the series the compatibility report was verified with
+# (translations change between releases): pip install "s3rds[mysql]" / "s3rds[postgres]".
+dependencies = []
 
 [project.optional-dependencies]
-mysql = []  # kept so that pip install "s3rds[mysql]" from 0.1.x keeps working
+mysql = ["sqlglot>=30.24,<31"]       # s3rds.pymysql
+postgres = ["sqlglot>=30.24,<31"]    # s3rds.psycopg2
 server = ["sqlean.py==3.50.4.5"]      # the Lambda: s3rds.server + SQLite 3.50.4 instead of the runtime's 3.40.0
 sqlalchemy = ["SQLAlchemy>=2.0,<2.1"]   # the series the compatibility report verified; pip install "s3rds[sqlalchemy]"
-django = ["Django>=6.1,<6.2"]          # the same for Django (ENGINE "s3rds.sqlite"); Django 6.1 needs Python >= 3.12
+django = ["Django>=4.2,<6.2"]          # ENGINE "s3rds.sqlite"; CI runs 4.2 (Python 3.9, 3.10), 5.2 (3.11, 3.12), 6.1 (3.12, 3.13)
 
 [project.entry-points."sqlalchemy.dialects"]
 "sqlite.s3rds" = "s3rds.sqlite:SQLAlchemyDialect"
@@ -52,13 +59,13 @@ packages = ["s3rds", "s3rds.sqlite", "s3rds.psycopg2", "s3rds.server"]
 
 # The versions tests/compat/REPORT.md was verified with; README.md, README.zh.md and client/README.md state the same.
 [tool.s3rds.verified]
-python = ["3.9.6", "3.13.7"]       # the client: regression suite on 3.9.6, the full comparison on 3.13.7
+python = ["3.9", "3.10", "3.11", "3.12", "3.13"]   # the client: the full suite in CI (.github/workflows/test.yml)
 lambda_runtime = "python3.12"      # the server (terraform/main.tf)
 sqlite = "3.50.4"                  # the server's engine, shipped in the Lambda zip (the runtime's own is 3.40.0)
 sqlean = "3.50.4.5"                # sqlean.py, which carries it (extra "server")
 sqlglot = "30.24.0"
 sqlalchemy = "2.0.55"
-django = "6.1.2"
+django = ["4.2", "5.2", "6.1"]      # series; CI installs the latest release of each
 mysql_reference = "8.0.46"         # tests/compat/docker-compose.yml
 postgres_reference = "16.4"       # the same
 psycopg2 = "2.9.12"                # the reference client (psycopg2-binary)

{s3rds-0.3.2 → s3rds-0.3.4}/s3rds/__init__.py

@@ -14,9 +14,16 @@ uses SQLAlchemy's SQLite dialect with s3rds.sqlite as its driver; on RDS the URL
 Django needs no import either: DATABASES ENGINE "s3rds.sqlite" (s3rds/sqlite/base.py) is Django's SQLite
 backend on s3rds.sqlite; on RDS the ENGINE becomes django.db.backends.mysql.
 """
-from . import sqlite  # noqa: F401
-from . import pymysql  # noqa: F401  (sqlglot is only needed when a MySQL statement is actually translated)
-from . import psycopg2  # noqa: F401
+from . import sqlite  # noqa: F401  (standard library only)
 
 __all__ = ["sqlite", "pymysql", "psycopg2"]
 __version__ = sqlite.__version__
+
+
+def __getattr__(name):
+    """s3rds.pymysql / s3rds.psycopg2 load on first use: they translate with sqlglot (extras "mysql" / "postgres"),
+    which s3rds.sqlite, SQLAlchemy, Django and the server (s3rds.server) never need."""
+    if name in ("pymysql", "psycopg2"):
+        import importlib
+        return importlib.import_module(f".{name}", __name__)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{s3rds-0.3.2 → s3rds-0.3.4}/s3rds/psycopg2/__init__.py

@@ -1,5 +1,7 @@
 """s3rds.psycopg2 — the PostgreSQL-dialect driver for s3rds. Write PostgreSQL; it runs on the s3rds endpoint (SQLite engine).
 
+    pip install "s3rds[postgres]"          # the extra brings sqlglot, the dialect translation
+
     from s3rds import psycopg2             # later: `import psycopg2` on a real RDS, nothing else changes
     from s3rds.psycopg2.extras import RealDictCursor
     conn = psycopg2.connect(host="xxx.lambda-url.us-east-2.on.aws", dbname="blog", user="admin", password="...")
@@ -26,8 +28,9 @@ try:
     import sqlglot
     from sqlglot import exp
     from sqlglot.errors import ParseError
-except ImportError:  # the error surfaces on first query, with install instructions
-    sqlglot = None
+except ImportError:
+    raise ImportError('s3rds.psycopg2 translates PostgreSQL with sqlglot, which is not installed: '
+                      'pip install "s3rds[postgres]"') from None
 
 __version__ = _sqlite.__version__
 apilevel = "2.0"
@@ -170,8 +173,6 @@ def _translate(sql):
         tables = [t.strip().strip('"') for t in m.group(1).split(",")]
         return tuple([f'DELETE FROM "{t}"' for t in tables]
                      + ([f"DELETE FROM sqlite_sequence WHERE name = '{t}'" for t in tables] if m.group(2) else []))
-    if sqlglot is None:
-        raise NotSupportedError("the PostgreSQL dialect needs sqlglot (an s3rds dependency): pip install s3rds")
     try:
         tree = sqlglot.parse_one(sql, read="postgres")
     except ParseError as e:

{s3rds-0.3.2 → s3rds-0.3.4}/s3rds/pymysql.py

@@ -1,6 +1,6 @@
 """s3rds.pymysql — the MySQL-dialect driver for s3rds. Write MySQL; it runs on the s3rds endpoint (SQLite engine).
 
-    pip install s3rds                      # sqlglot (the dialect translation) comes with it
+    pip install "s3rds[mysql]"             # the extra brings sqlglot, the dialect translation
 
     from s3rds import pymysql              # later: `import pymysql` on a real RDS, nothing else changes
     conn = pymysql.connect(host="xxx.lambda-url.us-east-2.on.aws",
@@ -42,8 +42,9 @@ try:
     import sqlglot
     from sqlglot import exp
     from sqlglot.errors import ParseError
-except ImportError:  # the error surfaces on first query, with install instructions
-    sqlglot = None
+except ImportError:
+    raise ImportError('s3rds.pymysql translates MySQL with sqlglot, which is not installed: '
+                      'pip install "s3rds[mysql]"') from None
 
 __version__ = _sqlite.__version__
 apilevel = "2.0"
@@ -557,8 +558,6 @@ def _fix_delete_join(tree):
 def _translate_stmts(sql):
     """MySQL statement -> tuple of SQLite statements (usually one; CREATE TABLE with inline indexes and
     RENAME TABLE give several, a type-only ALTER gives none)."""
-    if sqlglot is None:
-        raise NotSupportedError(0, "the MySQL dialect needs sqlglot (an s3rds dependency): pip install s3rds")
     m = _RENAME_TABLE.match(sql)
     if m:
         pairs = _RENAME_PAIR.findall(m.group(1))

{s3rds-0.3.2 → s3rds-0.3.4}/s3rds/server/index.html

@@ -191,9 +191,9 @@ dialog .form-grid { grid-template-columns: 1fr; }
 
   <div class="controls">
     <label>Database</label><select id="dbs"></select>
-    <button class="btn btn-secondary" id="newdb">＋ New database</button>
+    <button class="btn btn-secondary" id="newdb">+ New database</button>
     <label>Table</label><select id="tables"></select>
-    <button class="btn btn-secondary" id="newtable">＋ New table</button>
+    <button class="btn btn-secondary" id="newtable">+ New table</button>
     <button class="btn btn-ghost" id="refresh">refresh</button>
   </div>
 
@@ -397,13 +397,13 @@ function render(){
   $('#info-db').textContent = state.db || '-';
   const main = $('#main');
   if (!state.db){
-    main.innerHTML = '<div class="table-section"><div class="empty">Pick a database above, or click “＋ New database”</div></div>';
+    main.innerHTML = '<div class="table-section"><div class="empty">Pick a database above, or click “+ New database”</div></div>';
     return;
   }
   if (!state.table){
     main.innerHTML = `<div class="table-section"><div class="empty">${state.tables.length
       ? 'Pick a table above'
-      : 'No tables yet — click “＋ New table”, or write CREATE TABLE in the SQL box'}</div></div>`;
+      : 'No tables yet — click “+ New table”, or write CREATE TABLE in the SQL box'}</div></div>`;
     return;
   }
   if (!state.loaded){
@@ -461,7 +461,7 @@ function render(){
     </div>
 
     <div class="section-title">Structure
-      <button class="btn btn-secondary btn-small" id="addcol">＋ Add column</button>
+      <button class="btn btn-secondary btn-small" id="addcol">+ Add column</button>
     </div>
     <div class="grid-wrap"><table>
       <thead><tr><th>Field</th><th>Type</th><th>Null</th><th>Key</th><th>Default</th><th>Extra</th><th>actions</th></tr></thead>
@@ -594,7 +594,7 @@ $('#newtable').onclick = async () => {
   try {
     await api(`/api/db/${state.db}/query`, {method:'POST', body: JSON.stringify(
       {sql: `CREATE TABLE "${name}" (id INTEGER PRIMARY KEY AUTOINCREMENT) STRICT`})});
-    msg(`✓ created table ${name} (STRICT, with an autoincrement id); add fields with “＋ Add column”`, true);
+    msg(`✓ created table ${name} (STRICT, with an autoincrement id); add fields with “+ Add column”`, true);
     await loadTables(name);
     await loadRows();  // open the table just created
   } catch(e){ msg(friendly(e.message)); }

{s3rds-0.3.2 → s3rds-0.3.4}/s3rds/server/lambda_function.py

@@ -1,6 +1,6 @@
 """s3rds server: a serverless database (SQL over HTTP, SQLite on S3).
 
-GET  /                                      index.html (web console)
+GET  /                                      index.html (web console; CONSOLE=0 -> 404, API only)
 GET  /api/databases                         list databases
 POST /api/databases {name}                  create a database
 GET  /api/db/{db}/tables                    list tables
@@ -17,7 +17,9 @@ applied before BEGIN on every request (the server keeps no session).
 Read / write is decided by the endpoint, never by guessing the SQL:
   write endpoint (default)   /query goes through run(): SQLite decides whether data changed, only then S3 is written
   read-only endpoint READONLY=1   everything opens mode=ro; a write is refused by SQLite -> 403
-Auth: HTTP Basic, the same meaning as RDS user / password.
+Auth: HTTP Basic, the same meaning as RDS user / password. No DB_USER / DB_PASSWORD -> every request 503, unless
+ALLOW_NO_AUTH=1 (local experiments only), which answers without auth and says so in x-s3rds-warning: no-auth.
+ATTACH / DETACH / VACUUM INTO -> 403: a request works on its own database file only.
 Every JSON reply carries ms (server time); data calls also carry s3 (cache-hit / download / +upload).
 """
 import base64
@@ -27,14 +29,16 @@ import os
 import re
 import time
 
-from .s3_sqlite import (SESSION_PRAGMAS, DatabaseExists, DatabaseNotFound, SqliteS3, WriteConflict,
+from .s3_sqlite import (SESSION_PRAGMAS, DatabaseExists, DatabaseNotFound, NotAllowed, SqliteS3, WriteConflict,
                        create_database, list_databases, sqlite3)
 
 BUCKET = os.environ["DB_BUCKET"]
 PREFIX = os.environ.get("DB_PREFIX", "")
 DB_USER = os.environ.get("DB_USER", "")
 DB_PASSWORD = os.environ.get("DB_PASSWORD", "")
+ALLOW_NO_AUTH = os.environ.get("ALLOW_NO_AUTH") == "1"  # no credentials configured: refuse (503) unless this is set
 READONLY = os.environ.get("READONLY") == "1"
+CONSOLE = os.environ.get("CONSOLE", "1") == "1"  # the web console at GET /; unset = on
 
 with open(os.path.join(os.path.dirname(__file__), "index.html"), encoding="utf-8") as f:
     INDEX_HTML = f.read()
@@ -117,11 +121,15 @@ def _int(qs, key, default, lo, hi):
     return max(lo, min(value, hi))
 
 
+def _no_credentials():
+    return not DB_USER or not DB_PASSWORD
+
+
 def _authed(event):
-    """HTTP Basic, constant-time compare. No DB_USER configured = no auth (do not do that)."""
-    if not DB_USER:
-        return True
-    auth = (event.get("headers") or {}).get("authorization", "")
+    """HTTP Basic, constant-time compare. The handler answers 503 before this when no credentials are configured."""
+    if _no_credentials():
+        return ALLOW_NO_AUTH
+    auth =(event.get("headers") or {}).get("authorization", "")
     if not auth.lower().startswith("basic "):
         return False
     try:
@@ -379,12 +387,16 @@ def lambda_handler(event, context):
     path = event.get("rawPath", "/")
 
     if method == "GET" and path in ("/", "/index.html"):
+        if not CONSOLE:
+            return _json(404, {"error": "the web console is turned off (console = false); the API is under /api/"})
         return {
             "statusCode": 200,
             "headers": {"content-type": "text/html; charset=utf-8"},
             "body": INDEX_HTML,
         }
 
+    if _no_credentials() and not ALLOW_NO_AUTH:
+        return _json(503, {"error": "server has no credentials configured (DB_USER / DB_PASSWORD)"})
     if not _authed(event):
         return _json(401, {"error": "bad credentials"})
 
@@ -399,7 +411,7 @@ def lambda_handler(event, context):
                 break
     except BadRequest as e:
         status, data = 400, {"error": str(e)}
-    except Forbidden as e:
+    except (Forbidden, NotAllowed) as e:
         status, data = 403, {"error": str(e)}
     except DatabaseNotFound as e:
         status, data = 404, {"error": f"database not found: {e}"}
@@ -416,4 +428,7 @@ def lambda_handler(event, context):
         status, data = 500, {"error": f"{type(e).__name__}: {e}"}
 
     data.setdefault("ms", round((time.perf_counter() - t0) * 1000, 1))
-    return _json(status, data)
+    resp = _json(status, data)
+    if _no_credentials():  # here only with ALLOW_NO_AUTH=1
+        resp["headers"]["x-s3rds-warning"] = "no-auth"
+    return resp

{s3rds-0.3.2 → s3rds-0.3.4}/s3rds/server/s3_sqlite.py

@@ -4,6 +4,7 @@ read(fn):  opens the local cache mode=ro, SQLite itself refuses writes; never up
 run(fn):   after fn, SQLite's authorizer says whether data really changed; only then the whole file
            goes back with If-Match (CAS); on 412 re-download, replay, retry; out of retries -> WriteConflict.
            Rule: failing is allowed, duplicating a write or overwriting someone else's is not.
+Every connection: ATTACH / DETACH (and so VACUUM INTO) refused -> NotAllowed; one request touches one file.
 Cache:     /tmp keyed by ETag; downloads go through a temp file + os.replace, never a half file.
 One key = one database; the lock is the file, so different databases never conflict.
 
@@ -64,6 +65,45 @@ class WriteConflict(Exception):
     pass
 
 
+class NotAllowed(Exception):
+    """A statement the authorizer refused: it would reach past this request's one database file."""
+
+
+# ATTACH opens another file read/write even on a mode=ro connection: another database's /tmp cache (its path is
+# sha1(bucket/key), so it can be guessed) could be changed and later uploaded. VACUUM INTO attaches too, so it is
+# refused with it and cannot write files into /tmp either. Plain VACUUM attaches a temporary database as well and is
+# refused the same way. On the read/write path SQLite stops any VACUUM before the authorizer is even asked (every
+# request runs inside a transaction: "cannot VACUUM from within a transaction"); that error is reported as the same
+# refusal, so both endpoints answer alike.
+_DENIED_ACTIONS = {sqlite3.SQLITE_ATTACH, sqlite3.SQLITE_DETACH}
+_VACUUM_IN_TX = "cannot VACUUM from within a transaction"  # SQLite's own message
+NOT_ALLOWED = "ATTACH / DETACH / VACUUM INTO are not allowed: a request works on its own database only"
+
+
+class _Authorizer:
+    """SQLite's authorizer for every connection: ATTACH / DETACH denied; on_allowed(action, arg1, arg2) sees the rest.
+    SQLite reports a denial as a plain DatabaseError ("not authorized"); denied says it was ours -> NotAllowed."""
+
+    def __init__(self, on_allowed=None):
+        self.on_allowed = on_allowed
+        self.denied = False
+
+    def __call__(self, action, arg1, arg2, _dbname, _source):  # signature fixed by sqlite3
+        if action in _DENIED_ACTIONS:
+            self.denied = True
+            return sqlite3.SQLITE_DENY
+        if self.on_allowed:
+            self.on_allowed(action, arg1, arg2)
+        return sqlite3.SQLITE_OK
+
+    def translate(self, e):
+        """The exception to raise for e: NotAllowed when the authorizer refused (or SQLite refused a VACUUM inside
+        the request's transaction), else e itself."""
+        if isinstance(e, sqlite3.DatabaseError) and (self.denied or _VACUUM_IN_TX in str(e)):
+            return NotAllowed(NOT_ALLOWED)
+        return e
+
+
 def _local_path(bucket, key):
     digest = hashlib.sha1(f"{bucket}/{key}".encode()).hexdigest()
     return f"/tmp/{digest}.sqlite"
@@ -208,9 +248,16 @@ class SqliteS3:
         self._ensure_fresh()
         conn = sqlite3.connect(f"file:{self.local}?mode=ro", uri=True, detect_types=detect_types)
         conn.row_factory = sqlite3.Row
+        auth = _Authorizer()
         try:
             _apply_pragmas(conn, pragmas)
+            conn.set_authorizer(auth)
             return fn(conn)
+        except sqlite3.DatabaseError as e:
+            err = auth.translate(e)
+            if err is e:
+                raise
+            raise err from None
         finally:
             conn.close()
 
@@ -276,7 +323,7 @@ class SqliteS3:
         """
         dirty = False
 
-        def authorizer(action, arg1, arg2, _dbname, _source):  # signature fixed by sqlite3
+        def note_write(action, arg1, arg2):
             nonlocal dirty
             if action == sqlite3.SQLITE_PRAGMA:
                 # only PRAGMA x = v is a write; the file fingerprint still catches anything that changed the file
@@ -284,7 +331,8 @@ class SqliteS3:
                     dirty = True
             elif action not in _READ_ACTIONS:
                 dirty = True
-            return sqlite3.SQLITE_OK
+
+        authorizer = _Authorizer(note_write)
 
         # isolation_level=None: no implicit transactions from the sqlite3 module; we BEGIN/COMMIT ourselves
         conn = sqlite3.connect(self.local, isolation_level=None, detect_types=detect_types)
@@ -303,13 +351,16 @@ class SqliteS3:
                     raise sqlite3.OperationalError("COMMIT / END inside a transaction trial; use the commit request")
                 if conn.in_transaction:  # fn may have committed itself
                     conn.execute("COMMIT" if commit else "ROLLBACK")
-            except BaseException:
+            except BaseException as e:
                 try:
                     if conn.in_transaction:
                         conn.execute("ROLLBACK")
                 except sqlite3.Error:
                     self._invalidate()  # even ROLLBACK failed: the local state cannot be trusted
-                raise
+                err = authorizer.translate(e)
+                if err is e:
+                    raise
+                raise err from None
         finally:
             conn.close()
         return result, dirty

{s3rds-0.3.2 → s3rds-0.3.4}/s3rds/sqlite/__init__.py

@@ -49,7 +49,7 @@ import socket
 import urllib.parse
 import warnings
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"
 
 apilevel = "2.0"
 threadsafety = 1

{s3rds-0.3.2 → s3rds-0.3.4}/s3rds/sqlite/base.py

@@ -239,7 +239,7 @@ class DatabaseWrapper(base.DatabaseWrapper):
         # no register_functions(conn): Python functions would have to run on the server (DatabaseOperations above)
         conn.execute("PRAGMA foreign_keys = ON")
         conn.execute("PRAGMA legacy_alter_table = OFF")
-        for init_command in self.init_commands:
+        for init_command in getattr(self, "init_commands", ()):  # OPTIONS init_command: Django 5.1+ only
             if init_command := init_command.strip():
                 conn.execute(init_command)
         return conn

{s3rds-0.3.2 → s3rds-0.3.4}/s3rds.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3rds
-Version: 0.3.2
+Version: 0.3.4
 Summary: A truly serverless RDS on your own AWS account: Lambda URL endpoint, SQLite on S3, ≈ $0 when idle. Drivers named after the standard clients: s3rds.sqlite, s3rds.pymysql, s3rds.psycopg2; SQLAlchemy via sqlite+s3rds://, Django via ENGINE s3rds.sqlite.
 Author: Frank Zhang
 License: MIT
@@ -16,20 +16,28 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.1
 Classifier: Topic :: Database
 Classifier: Topic :: Database :: Front-Ends
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: sqlglot<31,>=30.24
 Provides-Extra: mysql
+Requires-Dist: sqlglot<31,>=30.24; extra == "mysql"
+Provides-Extra: postgres
+Requires-Dist: sqlglot<31,>=30.24; extra == "postgres"
 Provides-Extra: server
 Requires-Dist: sqlean.py==3.50.4.5; extra == "server"
 Provides-Extra: sqlalchemy
 Requires-Dist: SQLAlchemy<2.1,>=2.0; extra == "sqlalchemy"
 Provides-Extra: django
-Requires-Dist: Django<6.2,>=6.1; extra == "django"
+Requires-Dist: Django<6.2,>=4.2; extra == "django"
 
 # s3rds
 
@@ -59,11 +67,13 @@ while nobody uses it. Deploy it once with Terraform from the
 **Python drivers for [s3rds](https://github.com/cloudformer/s3rds) — a truly serverless RDS:
 a Lambda URL as your database endpoint, SQLite on S3, ≈ $0 when idle.**
 
-One install, one dependency (sqlglot, used only by `s3rds.pymysql` and `s3rds.psycopg2`). Each driver is a submodule **named after the standard
-client it mirrors**, so moving to a real database is a one-line import change and nothing else:
+No dependencies for the native paths; the translating drivers take an extra. Each driver is a submodule **named after
+the standard client it mirrors**, so moving to a real database is a one-line import change and nothing else:
 
 ```bash
-pip install s3rds    # s3rds.sqlite, s3rds.pymysql, s3rds.psycopg2, sqlite+s3rds:// for SQLAlchemy, ENGINE s3rds.sqlite for Django
+pip install s3rds                # s3rds.sqlite, sqlite+s3rds:// for SQLAlchemy, ENGINE s3rds.sqlite for Django
+pip install "s3rds[mysql]"       # + s3rds.pymysql   (sqlglot: MySQL -> SQLite)
+pip install "s3rds[postgres]"    # + s3rds.psycopg2  (sqlglot: PostgreSQL -> SQLite)
 ```
 
 ```python
@@ -88,13 +98,15 @@ conn.transaction([                                 # all-or-nothing, single S3 w
 ])
 ```
 
-| Submodule | SQL dialect | Mirrors | Status |
-|---|---|---|---|
-| `s3rds.sqlite` | SQLite (no translation) | pymysql-shaped API | available |
-| `s3rds.pymysql` | MySQL, translated on the client | pymysql | available |
-| `s3rds.psycopg2` | PostgreSQL, translated on the client | psycopg2 (`extras`, `errors`, `extensions`) | available |
-| `sqlite+s3rds://` | SQLite, written by SQLAlchemy | SQLAlchemy Core / ORM | available — the URL is the only change |
-| `ENGINE: "s3rds.sqlite"` | SQLite, written by Django | Django's SQLite backend | available — the database settings are the only change |
+| Submodule | Kind | SQL dialect | Mirrors | Install |
+|---|---|---|---|---|
+| `s3rds.sqlite` | native | SQLite (no translation) | pymysql-shaped API | `s3rds` |
+| `sqlite+s3rds://` | native | SQLite, written by SQLAlchemy | SQLAlchemy 2.0 Core / ORM | `s3rds` (+ SQLAlchemy) |
+| `ENGINE: "s3rds.sqlite"` | native | SQLite, written by Django | Django 4.2, 5.2, 6.1 | `s3rds` (+ Django) |
+| `s3rds.pymysql` | translated | MySQL, translated on the client | pymysql | `"s3rds[mysql]"` |
+| `s3rds.psycopg2` | translated | PostgreSQL, translated on the client | psycopg2 (`extras`, `errors`, `extensions`) | `"s3rds[postgres]"` |
+
+Native is the most reliable: the SQL is SQLite's to begin with. For a new project, prefer SQLAlchemy or Django.
 
 **SQLAlchemy** (Core and ORM): only the URL changes — SQLAlchemy's own SQLite dialect writes the SQL,
 `s3rds.sqlite` replaces the standard library's `sqlite3` underneath.
@@ -144,11 +156,11 @@ What the report was verified with; the full report: [REPORT.md](https://github.c
 
 | | Version | Fixed by |
 |---|---|---|
-| Python (client) | 3.9 – 3.13: regression suite on 3.9.6, full comparison on 3.13.7 | `requires-python = ">=3.9"` |
+| Python (client) | 3.9, 3.10, 3.11, 3.12, 3.13, each in CI | `requires-python = ">=3.9"` |
 | Server runtime | AWS Lambda `python3.12` | `terraform/main.tf` |
 | SQLite (server engine) | 3.50.4, shipped in the Lambda zip (the runtime's own is 3.40.0) | extra `pip install "s3rds[server]"` = `sqlean.py==3.50.4.5` |
-| sqlglot (MySQL translation) | 30.24 | dependency `sqlglot>=30.24,<31` |
+| sqlglot (MySQL / PostgreSQL translation) | 30.24 | extras `"s3rds[mysql]"` / `"s3rds[postgres]"` = `sqlglot>=30.24,<31` |
 | SQLAlchemy | 2.0, tested on 2.0.55 | extra `pip install "s3rds[sqlalchemy]"` = `SQLAlchemy>=2.0,<2.1` |
-| Django | 6.1, tested on 6.1.2 (Python ≥ 3.12) | extra `pip install "s3rds[django]"` = `Django>=6.1,<6.2` |
+| Django | 4.2 (Python 3.9, 3.10), 5.2 (3.11, 3.12), 6.1 (3.12, 3.13), each in CI | extra `pip install "s3rds[django]"` = `Django>=4.2,<6.2` |
 | MySQL (reference) | 8.0.46 in Docker | `tests/compat/docker-compose.yml`: `mysql:8.0.46` |
 

{s3rds-0.3.2 → s3rds-0.3.4}/s3rds.egg-info/requires.txt

@@ -1,9 +1,12 @@
-sqlglot<31,>=30.24
 
 [django]
-Django<6.2,>=6.1
+Django<6.2,>=4.2
 
 [mysql]
+sqlglot<31,>=30.24
+
+[postgres]
+sqlglot<31,>=30.24
 
 [server]
 sqlean.py==3.50.4.5