parad 2.2.2__tar.gz → 2.2.3__tar.gz

{parad-2.2.2 → parad-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parad
-Version: 2.2.2
+Version: 2.2.3
 Summary: Drop-in encrypted database with cloud sync — connect() and go
 Author-email: nexuss0781 <nexuss0781@gmail.com>
 Project-URL: Homepage, https://github.com/nexuss0781/Paradox-DB
@@ -21,6 +21,8 @@ Requires-Dist: httpx>=0.25
 Requires-Dist: cryptography>=41.0
 Requires-Dist: pydantic>=2.0
 Requires-Dist: python-dotenv>=1.0
+Provides-Extra: sqlalchemy
+Requires-Dist: SQLAlchemy>=2.0; extra == "sqlalchemy"
 
 # parad
 
@@ -93,7 +95,7 @@ parad shell
 
 | Command | Description |
 |---|---|
-| `parad init <name>` | Create encrypted DB + register with gateway |
+| `parad init <name>` | Create encrypted DB + register with gateway; emit canonical DATABASE_URL |
 | `parad push` | Push database to Telegram cloud |
 | `parad pull [version]` | Pull latest or specific version |
 | `parad sync` | Push then pull |
@@ -108,12 +110,42 @@ parad shell
 | `parad shell` | Interactive SQL REPL |
 | `parad config show/set` | Manage config |
 
+## Canonical DATABASE_URL
+
+After `parad init` successfully provisions the project and database, Parad persists the complete connection URL in `config.json` as `database_url` and prints a redacted form:
+
+```bash
+parad init mydb --project myproject
+```
+
+Use `--print-database-url` only when intentionally copying the complete secret-bearing URL into a secret manager:
+
+```bash
+parad init mydb --project myproject --print-database-url
+```
+
+Applications can use the same single value:
+
+```python
+import os
+from parad import connect
+
+db = connect(url=os.environ["DATABASE_URL"])
+```
+
+An explicit `url`, `name`, or `db_path` argument takes precedence over an ambient `DATABASE_URL`. Existing connection strings and config-based workflows remain supported.
+
+## SQLAlchemy
+
+Install the optional integration with `pip install "parad[sqlalchemy]"`, then use the same canonical URL with `create_engine("parad://...")`. The ORM, Core, DB-API, and encrypted lifecycle examples are documented in [`docs/SQLALCHEMY.md`](docs/SQLALCHEMY.md).
+
 ## Configuration
 
 Config lives at `~/.paradox/config.json`:
 
 ```json
 {
+  "database_url": "parad://<api-key>@local/project/mydb?gateway=https%3A%2F%2F...&passphrase=...",
   "database_path": "~/.paradox/data.db",
   "sync": {
     "gateway_url": "https://paradox-db.onrender.com/v1",

{parad-2.2.2 → parad-2.2.3}/README.md

@@ -69,7 +69,7 @@ parad shell
 
 | Command | Description |
 |---|---|
-| `parad init <name>` | Create encrypted DB + register with gateway |
+| `parad init <name>` | Create encrypted DB + register with gateway; emit canonical DATABASE_URL |
 | `parad push` | Push database to Telegram cloud |
 | `parad pull [version]` | Pull latest or specific version |
 | `parad sync` | Push then pull |
@@ -84,12 +84,42 @@ parad shell
 | `parad shell` | Interactive SQL REPL |
 | `parad config show/set` | Manage config |
 
+## Canonical DATABASE_URL
+
+After `parad init` successfully provisions the project and database, Parad persists the complete connection URL in `config.json` as `database_url` and prints a redacted form:
+
+```bash
+parad init mydb --project myproject
+```
+
+Use `--print-database-url` only when intentionally copying the complete secret-bearing URL into a secret manager:
+
+```bash
+parad init mydb --project myproject --print-database-url
+```
+
+Applications can use the same single value:
+
+```python
+import os
+from parad import connect
+
+db = connect(url=os.environ["DATABASE_URL"])
+```
+
+An explicit `url`, `name`, or `db_path` argument takes precedence over an ambient `DATABASE_URL`. Existing connection strings and config-based workflows remain supported.
+
+## SQLAlchemy
+
+Install the optional integration with `pip install "parad[sqlalchemy]"`, then use the same canonical URL with `create_engine("parad://...")`. The ORM, Core, DB-API, and encrypted lifecycle examples are documented in [`docs/SQLALCHEMY.md`](docs/SQLALCHEMY.md).
+
 ## Configuration
 
 Config lives at `~/.paradox/config.json`:
 
 ```json
 {
+  "database_url": "parad://<api-key>@local/project/mydb?gateway=https%3A%2F%2F...&passphrase=...",
   "database_path": "~/.paradox/data.db",
   "sync": {
     "gateway_url": "https://paradox-db.onrender.com/v1",

{parad-2.2.2 → parad-2.2.3}/parad/__init__.py

@@ -1,8 +1,8 @@
 """parad — Encrypted local-first SQLite with cloud sync."""
 
-from parad.connection import connect, ParadConnection, parse_url, generate_url, db_state_key, generate_passphrase
+from parad.connection import connect, ParadConnection, parse_url, generate_url, redact_url, db_state_key, generate_passphrase
 from parad.engine import Engine
 from parad.config import load_config, get_passphrase, get_connection_url
 
-__version__ = "2.2.2"
-__all__ = ["connect", "ParadConnection", "parse_url", "generate_url", "db_state_key", "generate_passphrase", "Engine", "load_config"]
+__version__ = "2.2.3"
+__all__ = ["connect", "ParadConnection", "parse_url", "generate_url", "redact_url", "db_state_key", "generate_passphrase", "Engine", "load_config"]

{parad-2.2.2 → parad-2.2.3}/parad/commands/init.py

@@ -3,7 +3,7 @@
 import click
 from pathlib import Path
 from parad.config import load_config, save_config, config_dir, gateway_db_name, set_config_value
-from parad.connection import db_state_key
+from parad.connection import db_state_key, generate_url, redact_url
 from parad.engine import Engine
 from parad.gateway import GatewayClient, GatewayError
 from parad.state import set_remote_version, set_last_local_hash
@@ -93,7 +93,8 @@ def _find_or_create_database(gw, project_id: str, db_name: str) -> str:
 @click.option("--gateway", envvar="PARADOX_GATEWAY_URL", default=None)
 @click.option("--project", default=None, help="Project name to use (creates if not found)")
 @click.option("--watch", "do_watch", is_flag=True, help="Start auto-sync daemon after init")
-def init(name: str, passphrase: str, gateway: str | None, project: str | None, do_watch: bool):
+@click.option("--print-database-url", is_flag=True, help="Print the full secret-bearing DATABASE_URL")
+def init(name: str, passphrase: str, gateway: str | None, project: str | None, do_watch: bool, print_database_url: bool):
     """Create a new encrypted database and push to gateway.
 
     Handles everything in one step: auth, project/database setup, local DB creation, and push.
@@ -145,12 +146,21 @@ def init(name: str, passphrase: str, gateway: str | None, project: str | None, d
     except GatewayError as e:
         click.echo(f"⚠ Push failed: {e}")
 
-    # Step 6: Save config
+    # Step 6: Save config and publish the canonical URL only after creation succeeds.
+    canonical_url = generate_url(
+        name,
+        passphrase,
+        config.sync.gateway_url,
+        project_name,
+        token=config.sync.api_key,
+    )
+    config.database_url = canonical_url
     save_config(config)
 
     click.echo(f"\n✓ Database ready: {db_path}")
     click.echo(f"  Project:  {project_name} ({project_id})")
     click.echo(f"  Database: {name} ({database_id})")
+    click.echo(f"  DATABASE_URL: {canonical_url if print_database_url else redact_url(canonical_url)}")
 
     # Step 7: Optionally start daemon
     if do_watch:

{parad-2.2.2 → parad-2.2.3}/parad/config.py

@@ -19,6 +19,7 @@ def config_dir() -> Path:
     return Path(os.environ.get("PARADOX_HOME", "~/.paradox")).expanduser()
 
 DEFAULT_CONFIG = {
+    "database_url": "",
     "database_path": "~/.paradox/data.db",
     "encryption": {
         "cipher": "aes-256-cbc",
@@ -73,6 +74,7 @@ def load_config() -> Config:
     - PARADOX_GATEWAY    → sync.gateway_url
     - PARADOX_DATABASE   → database_path
     - PARADOX_API_KEY    → sync.api_key
+    - DATABASE_URL       → canonical Parad connection URL
 
     .env files are loaded automatically if python-dotenv is installed.
     """
@@ -95,6 +97,8 @@ def load_config() -> Config:
         merged["database_path"] = os.environ["PARADOX_DATABASE"]
     if "PARADOX_API_KEY" in os.environ:
         merged["sync"]["api_key"] = os.environ["PARADOX_API_KEY"]
+    if "DATABASE_URL" in os.environ:
+        merged["database_url"] = os.environ["DATABASE_URL"]
 
     return Config(**merged)
 
@@ -142,9 +146,9 @@ def get_passphrase() -> str:
 
 
 def get_connection_url(name: str) -> str:
-    """Get a connection URL for a database.
-    
-    Returns: parad://local/{name}?passphrase={passphrase}
-    """
+    """Get the canonical connection URL, with a legacy local fallback."""
+    config = load_config()
+    if config.database_url and gateway_db_name(config.database_path) == name:
+        return config.database_url
     passphrase = get_passphrase()
     return f"parad://local/{name}?passphrase={passphrase}"

{parad-2.2.2 → parad-2.2.3}/parad/connection.py

@@ -106,6 +106,20 @@ def generate_url(
     return url
 
 
+def redact_url(url: str) -> str:
+    """Remove API-key, password, token, and passphrase material for display."""
+    parsed = urlparse(url)
+    userinfo = "<redacted>@" if parsed.username else ""
+    path = parsed.path
+    query = []
+    for key, values in parse_qs(parsed.query, keep_blank_values=True).items():
+        if key not in {"token", "passphrase"}:
+            for value in values:
+                query.append(f"{quote(key, safe='')}={quote(value, safe=':/')}")
+    suffix = f"?{'&'.join(query)}" if query else ""
+    return f"parad://{userinfo}{parsed.hostname or ''}{path}{suffix}"
+
+
 def db_state_key(name: str, project: str | None = None) -> str:
     """State-file key for a database.
 
@@ -474,7 +488,7 @@ class ParadConnection:
         self._project_id = project_id
         self._storage_channel = storage_channel
         self._log_channel = log_channel
-        self._db_name = gateway_db_name(self._db_path) if self._gateway_url else ""
+        self._db_name = gateway_db_name(self._db_path)
         self._db_key = db_state_key(self._db_name, project)
 
         self._engine = Engine(self._db_path, self._passphrase)
@@ -516,6 +530,17 @@ class ParadConnection:
     def is_connected(self) -> bool:
         return self._engine._conn is not None
 
+    @property
+    def database_url(self) -> str:
+        """Canonical connection URL for this resolved database."""
+        return generate_url(
+            self._db_name,
+            self._passphrase,
+            self._gateway_url,
+            self._project,
+            token=self._api_key,
+        )
+
     # ── SQL interface ───────────────────────────────────────────
 
     def execute(self, sql: str, params: tuple | list | None = None) -> list[dict]:
@@ -751,10 +776,11 @@ def connect(
       Useful for web servers on ephemeral filesystems (Render, Heroku, etc.).
     """
     cfg = load_config()
+    configured_url = url or ((not name and not db_path) and (os.environ.get("DATABASE_URL") or cfg.database_url or "") or "")
     parsed_url: dict = {}
 
-    if url:
-        parsed_url = parse_url(url)
+    if configured_url:
+        parsed_url = parse_url(configured_url)
 
     url_name = parsed_url.get("name") or ""
     url_project = parsed_url.get("project") or None
@@ -882,4 +908,10 @@ def connect(
         log_channel=log_channel or os.environ.get("PARADOX_LOG_CHANNEL", ""),
     )
 
+    try:
+        cfg.database_url = conn.database_url
+        save_config(cfg)
+    except Exception:
+        pass
+
     return conn

parad-2.2.3/parad/dbapi.py

@@ -0,0 +1,217 @@
+"""PEP 249 DB-API adapter for Parad's encrypted SQLite engine."""
+
+from __future__ import annotations
+
+import sqlite3
+import threading
+from typing import Any, Iterable, Sequence
+
+from .connection import ParadConnection, connect as parad_connect
+
+apilevel = "2.0"
+threadsafety = 1
+paramstyle = "qmark"
+
+Warning = sqlite3.Warning
+Error = sqlite3.Error
+InterfaceError = sqlite3.InterfaceError
+DatabaseError = sqlite3.DatabaseError
+DataError = sqlite3.DataError
+OperationalError = sqlite3.OperationalError
+IntegrityError = sqlite3.IntegrityError
+InternalError = sqlite3.InternalError
+ProgrammingError = sqlite3.ProgrammingError
+NotSupportedError = sqlite3.NotSupportedError
+
+Binary = sqlite3.Binary
+Date = sqlite3.Date
+Time = sqlite3.Time
+Timestamp = sqlite3.Timestamp
+DateFromTicks = sqlite3.DateFromTicks
+TimeFromTicks = sqlite3.TimeFromTicks
+TimestampFromTicks = sqlite3.TimestampFromTicks
+sqlite_version = sqlite3.sqlite_version
+sqlite_version_info = sqlite3.sqlite_version_info
+
+
+class Cursor:
+    """PEP 249 cursor backed by Parad's live SQLite connection."""
+
+    arraysize = 1
+
+    def __init__(self, connection: "Connection"):
+        self.connection = connection
+        self._cursor: sqlite3.Cursor | None = None
+        self._closed = False
+
+    def _require_open(self) -> sqlite3.Cursor:
+        if self._closed or self.connection.closed:
+            raise InterfaceError("cursor is closed")
+        if self._cursor is None:
+            self._cursor = self.connection._raw.cursor()
+        return self._cursor
+
+    @property
+    def description(self):
+        return self._cursor.description if self._cursor is not None else None
+
+    @property
+    def rowcount(self) -> int:
+        if self._cursor is None:
+            return -1
+        return self._cursor.rowcount
+
+    @property
+    def lastrowid(self):
+        if self._cursor is None:
+            return None
+        return self._cursor.lastrowid
+
+    def execute(self, operation: str, parameters: Sequence[Any] | None = None):
+        cursor = self._require_open()
+        self.connection._lock.acquire()
+        try:
+            cursor.execute(operation, tuple(parameters or ()))
+        except Exception:
+            self.connection._lock.release()
+            raise
+        self.connection._lock.release()
+        return self
+
+    def executemany(self, operation: str, seq_of_parameters: Iterable[Sequence[Any]]):
+        cursor = self._require_open()
+        self.connection._lock.acquire()
+        try:
+            cursor.executemany(operation, [tuple(params) for params in seq_of_parameters])
+        except Exception:
+            self.connection._lock.release()
+            raise
+        self.connection._lock.release()
+        return self
+
+    def executescript(self, script: str):
+        cursor = self._require_open()
+        self.connection._lock.acquire()
+        try:
+            cursor.executescript(script)
+        except Exception:
+            self.connection._lock.release()
+            raise
+        self.connection._lock.release()
+        return self
+
+    def fetchone(self):
+        return self._require_open().fetchone()
+
+    def fetchmany(self, size: int | None = None):
+        return self._require_open().fetchmany(self.arraysize if size is None else size)
+
+    def fetchall(self):
+        return self._require_open().fetchall()
+
+    def setinputsizes(self, sizes):
+        return None
+
+    def setoutputsize(self, size, column=None):
+        return None
+
+    def close(self):
+        if not self._closed and self._cursor is not None:
+            self._cursor.close()
+        self._closed = True
+
+    def __iter__(self):
+        return iter(self._require_open())
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+
+class Connection:
+    """PEP 249 connection backed by a ParadConnection."""
+
+    def __init__(self, database_url: str, **kwargs: Any):
+        self._parad = parad_connect(url=database_url, auto_sync=kwargs.pop("auto_sync", False))
+        self._raw = self._parad.engine._conn
+        if self._raw is None:
+            raise InterfaceError("Parad database engine is not open")
+        self._lock = threading.RLock()
+        self.closed = False
+
+    @property
+    def parad(self) -> ParadConnection:
+        return self._parad
+
+    def cursor(self) -> Cursor:
+        if self.closed:
+            raise InterfaceError("connection is closed")
+        return Cursor(self)
+
+    def commit(self):
+        if self.closed:
+            raise InterfaceError("connection is closed")
+        with self._lock:
+            self._raw.commit()
+
+    def rollback(self):
+        if self.closed:
+            raise InterfaceError("connection is closed")
+        with self._lock:
+            self._raw.rollback()
+
+    def close(self):
+        if not self.closed:
+            with self._lock:
+                self._parad.close()
+            self.closed = True
+
+    def execute(self, operation: str, parameters: Sequence[Any] | None = None):
+        cursor = self.cursor()
+        cursor.execute(operation, parameters)
+        return cursor
+
+    def executemany(self, operation: str, seq_of_parameters: Iterable[Sequence[Any]]):
+        cursor = self.cursor()
+        cursor.executemany(operation, seq_of_parameters)
+        return cursor
+
+    def executescript(self, script: str):
+        cursor = self.cursor()
+        cursor.executescript(script)
+        return cursor
+
+    def create_function(self, *args, **kwargs):
+        if self.closed:
+            raise InterfaceError("connection is closed")
+        return self._raw.create_function(*args, **kwargs)
+
+    def set_authorizer(self, *args, **kwargs):
+        if self.closed:
+            raise InterfaceError("connection is closed")
+        return self._raw.set_authorizer(*args, **kwargs)
+
+    def interrupt(self):
+        if not self.closed:
+            return self._raw.interrupt()
+
+    def __enter__(self):
+        if self.closed:
+            raise InterfaceError("connection is closed")
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if exc_type is None:
+            self.commit()
+        else:
+            self.rollback()
+        self.close()
+
+
+def connect(database: str | None = None, **kwargs: Any) -> Connection:
+    """Return a DB-API connection for a canonical Parad URL."""
+    if not database:
+        raise ProgrammingError("Parad DB-API requires a DATABASE_URL or database URL")
+    return Connection(database, **kwargs)

parad-2.2.3/parad/sqlalchemy.py

@@ -0,0 +1,30 @@
+"""SQLAlchemy dialect for Parad's encrypted SQLite database."""
+
+from __future__ import annotations
+
+from sqlalchemy.dialects.sqlite.base import SQLiteDialect
+
+from . import dbapi
+
+
+class ParadDialect(SQLiteDialect):
+    """SQLite dialect whose DB-API connections are backed by Parad."""
+
+    name = "parad"
+    driver = "sqlite"
+    supports_statement_cache = False
+
+    @classmethod
+    def import_dbapi(cls):
+        return dbapi
+
+    def create_connect_args(self, url):
+        # Preserve the complete canonical URL, including its API token,
+        # gateway, project, database, and passphrase query parameters.
+        return [url.render_as_string(hide_password=False)], {"auto_sync": False}
+
+    def get_driver_name(self):
+        return "sqlite"
+
+
+dialect = ParadDialect

{parad-2.2.2 → parad-2.2.3}/parad/types.py

@@ -34,6 +34,7 @@ class LoggingConfig(BaseModel):
 
 
 class Config(BaseModel):
+    database_url: str = ""
     database_path: str = "~/.paradox/data.db"
     project_id: str = ""
     project_name: str = ""

{parad-2.2.2 → parad-2.2.3}/parad.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parad
-Version: 2.2.2
+Version: 2.2.3
 Summary: Drop-in encrypted database with cloud sync — connect() and go
 Author-email: nexuss0781 <nexuss0781@gmail.com>
 Project-URL: Homepage, https://github.com/nexuss0781/Paradox-DB
@@ -21,6 +21,8 @@ Requires-Dist: httpx>=0.25
 Requires-Dist: cryptography>=41.0
 Requires-Dist: pydantic>=2.0
 Requires-Dist: python-dotenv>=1.0
+Provides-Extra: sqlalchemy
+Requires-Dist: SQLAlchemy>=2.0; extra == "sqlalchemy"
 
 # parad
 
@@ -93,7 +95,7 @@ parad shell
 
 | Command | Description |
 |---|---|
-| `parad init <name>` | Create encrypted DB + register with gateway |
+| `parad init <name>` | Create encrypted DB + register with gateway; emit canonical DATABASE_URL |
 | `parad push` | Push database to Telegram cloud |
 | `parad pull [version]` | Pull latest or specific version |
 | `parad sync` | Push then pull |
@@ -108,12 +110,42 @@ parad shell
 | `parad shell` | Interactive SQL REPL |
 | `parad config show/set` | Manage config |
 
+## Canonical DATABASE_URL
+
+After `parad init` successfully provisions the project and database, Parad persists the complete connection URL in `config.json` as `database_url` and prints a redacted form:
+
+```bash
+parad init mydb --project myproject
+```
+
+Use `--print-database-url` only when intentionally copying the complete secret-bearing URL into a secret manager:
+
+```bash
+parad init mydb --project myproject --print-database-url
+```
+
+Applications can use the same single value:
+
+```python
+import os
+from parad import connect
+
+db = connect(url=os.environ["DATABASE_URL"])
+```
+
+An explicit `url`, `name`, or `db_path` argument takes precedence over an ambient `DATABASE_URL`. Existing connection strings and config-based workflows remain supported.
+
+## SQLAlchemy
+
+Install the optional integration with `pip install "parad[sqlalchemy]"`, then use the same canonical URL with `create_engine("parad://...")`. The ORM, Core, DB-API, and encrypted lifecycle examples are documented in [`docs/SQLALCHEMY.md`](docs/SQLALCHEMY.md).
+
 ## Configuration
 
 Config lives at `~/.paradox/config.json`:
 
 ```json
 {
+  "database_url": "parad://<api-key>@local/project/mydb?gateway=https%3A%2F%2F...&passphrase=...",
   "database_path": "~/.paradox/data.db",
   "sync": {
     "gateway_url": "https://paradox-db.onrender.com/v1",

{parad-2.2.2 → parad-2.2.3}/parad.egg-info/SOURCES.txt

@@ -6,8 +6,10 @@ parad/cli.py
 parad/config.py
 parad/connection.py
 parad/crypto.py
+parad/dbapi.py
 parad/engine.py
 parad/gateway.py
+parad/sqlalchemy.py
 parad/state.py
 parad/types.py
 parad/watcher.py
@@ -34,5 +36,6 @@ parad/commands/watch.py
 tests/test_connection.py
 tests/test_crypto.py
 tests/test_engine.py
+tests/test_sqlalchemy.py
 tests/test_state.py
 tests/test_workflow.py

parad-2.2.3/parad.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+parad = parad.cli:main
+
+[sqlalchemy.dialects]
+parad = parad.sqlalchemy:ParadDialect

{parad-2.2.2 → parad-2.2.3}/parad.egg-info/requires.txt

@@ -3,3 +3,6 @@ httpx>=0.25
 cryptography>=41.0
 pydantic>=2.0
 python-dotenv>=1.0
+
+[sqlalchemy]
+SQLAlchemy>=2.0

{parad-2.2.2 → parad-2.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "parad"
-version = "2.2.2"
+version = "2.2.3"
 description = "Drop-in encrypted database with cloud sync — connect() and go"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -29,6 +29,12 @@ dependencies = [
     "python-dotenv>=1.0",
 ]
 
+[project.optional-dependencies]
+sqlalchemy = ["SQLAlchemy>=2.0"]
+
+[project.entry-points."sqlalchemy.dialects"]
+parad = "parad.sqlalchemy:ParadDialect"
+
 [project.urls]
 Homepage = "https://github.com/nexuss0781/Paradox-DB"
 Repository = "https://github.com/nexuss0781/Paradox-DB"

parad-2.2.3/tests/test_sqlalchemy.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from sqlalchemy import Boolean, Integer, String, create_engine, select
+from sqlalchemy.dialects import registry
+from sqlalchemy.orm import DeclarativeBase, Mapped, Session, mapped_column
+
+from parad.dbapi import connect as dbapi_connect
+
+registry.register("parad", "parad.sqlalchemy", "ParadDialect")
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    name: Mapped[str] = mapped_column(String, nullable=False)
+    active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+
+
+def test_dbapi_cursor_and_transaction():
+    conn = dbapi_connect("parad://local/dbapi_test?passphrase=test-passphrase")
+    try:
+        cursor = conn.cursor()
+        cursor.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT NOT NULL)")
+        cursor.execute("INSERT INTO users (name) VALUES (?)", ("Alice",))
+        conn.commit()
+        cursor.execute("SELECT name FROM users")
+        assert cursor.fetchone()[0] == "Alice"
+        assert cursor.description[0][0] == "name"
+    finally:
+        conn.close()
+
+
+def test_sqlalchemy_orm_crud_and_transaction():
+    engine = create_engine("parad://local/sqlalchemy_test?passphrase=test-passphrase")
+    try:
+        Base.metadata.create_all(engine)
+        with Session(engine) as session:
+            session.add(User(name="Alice", active=True))
+            session.commit()
+            assert session.scalar(select(User.name)) == "Alice"
+            session.commit()
+
+            with session.begin():
+                session.add(User(name="Bob", active=False))
+
+            names = session.scalars(select(User.name).order_by(User.id)).all()
+            assert names == ["Alice", "Bob"]
+    finally:
+        engine.dispose()
+
+
+def test_sqlalchemy_reopens_encrypted_database():
+    url = "parad://local/sqlalchemy_reopen?passphrase=test-passphrase"
+    first = create_engine(url)
+    Base.metadata.create_all(first)
+    with first.begin() as conn:
+        conn.execute(User.__table__.insert().values(name="Persisted", active=True))
+    first.dispose()
+
+    second = create_engine(url)
+    try:
+        with Session(second) as session:
+            assert session.scalar(select(User.name)) == "Persisted"
+    finally:
+        second.dispose()

parad-2.2.2/parad.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-parad = parad.cli:main