sqlalchemy-dqlite 0.1.0__py3-none-any.whl

sqlalchemy_dqlite-0.1.0.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: sqlalchemy-dqlite
+Version: 0.1.0
+Summary: SQLAlchemy 2.0 dialect for dqlite distributed SQLite
+Project-URL: Homepage, https://github.com/antoineleclair/sqlalchemy-dqlite
+Project-URL: Repository, https://github.com/antoineleclair/sqlalchemy-dqlite
+Project-URL: Issues, https://github.com/antoineleclair/sqlalchemy-dqlite/issues
+Author-email: Antoine Leclair <antoineleclair@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.md
+Keywords: database,distributed,dqlite,orm,sqlalchemy,sqlite
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Topic :: Database :: Front-Ends
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: dqlite-dbapi>=0.1.0
+Requires-Dist: sqlalchemy>=2.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sqlalchemy-dqlite
+
+SQLAlchemy 2.0 dialect for [dqlite](https://dqlite.io/).
+
+## Installation
+
+```bash
+pip install sqlalchemy-dqlite
+```
+
+## Usage
+
+```python
+from sqlalchemy import create_engine, text
+
+# Sync
+engine = create_engine("dqlite://localhost:9001/mydb")
+with engine.connect() as conn:
+    result = conn.execute(text("SELECT 1"))
+    print(result.fetchone())
+
+# Async
+from sqlalchemy.ext.asyncio import create_async_engine
+
+async_engine = create_async_engine("dqlite+aio://localhost:9001/mydb")
+async with async_engine.connect() as conn:
+    result = await conn.execute(text("SELECT 1"))
+    print(result.fetchone())
+```
+
+## URL Format
+
+```
+dqlite://host:port/database
+dqlite+aio://host:port/database
+```
+
+## Development
+
+See [DEVELOPMENT.md](DEVELOPMENT.md) for setup and contribution guidelines.
+
+## License
+
+MIT

sqlalchemy_dqlite-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+sqlalchemydqlite/__init__.py,sha256=U6HJs9l-kJxJ8cOTvguwccxTow_glWxInRkw47SLGL0,142
+sqlalchemydqlite/aio.py,sha256=A1vVGpqndeaFE5i-GOt5K5M5Vl431ap2dRp4lMnM3p0,1446
+sqlalchemydqlite/base.py,sha256=1dCYwqhn5e1gA4UwqlTZUsqFDHf_L99DyGNpIPbv8Lg,3769
+sqlalchemydqlite/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlalchemydqlite/requirements.py,sha256=1Yp5-WoHg--Lpg6NJtSgErnoRyEmfS5_s1EJrYpSdLw,1188
+sqlalchemy_dqlite-0.1.0.dist-info/METADATA,sha256=2EMJM3dXgNruBpnCr2XJe0NbQlJ2scE7urj3lOYwtf0,2166
+sqlalchemy_dqlite-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+sqlalchemy_dqlite-0.1.0.dist-info/entry_points.txt,sha256=y_yQjMEFbOdy-Hh7af9IOlIUOiOcHYSEFDOtDqlgJbE,114
+sqlalchemy_dqlite-0.1.0.dist-info/licenses/LICENSE.md,sha256=25ur0qy0m17OgHzc1Ve3NeLumyjGGgVBrN-JL3znfDg,1090
+sqlalchemy_dqlite-0.1.0.dist-info/RECORD,,

sqlalchemy_dqlite-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sqlalchemy_dqlite-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[sqlalchemy.dialects]
+dqlite = sqlalchemydqlite:DqliteDialect
+dqlite.aio = sqlalchemydqlite.aio:DqliteDialect_aio

sqlalchemy_dqlite-0.1.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Antoine Leclair and Greg Sadetsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqlalchemydqlite/__init__.py

@@ -0,0 +1,7 @@
+"""SQLAlchemy 2.0 dialect for dqlite."""
+
+from sqlalchemydqlite.base import DqliteDialect
+
+__all__ = ["DqliteDialect"]
+
+__version__ = "0.1.0"

sqlalchemydqlite/aio.py

@@ -0,0 +1,57 @@
+"""Async dqlite dialect for SQLAlchemy."""
+
+from typing import Any
+
+from sqlalchemy import pool
+from sqlalchemy.dialects.sqlite.base import SQLiteDialect
+from sqlalchemy.engine import URL
+from sqlalchemy.pool import AsyncAdaptedQueuePool
+
+
+class DqliteDialect_aio(SQLiteDialect):  # noqa: N801
+    """Async SQLAlchemy dialect for dqlite.
+
+    Use with SQLAlchemy's async engine:
+        create_async_engine("dqlite+aio://host:port/database")
+    """
+
+    name = "dqlite"
+    driver = "dqlitedbapi_aio"
+    is_async = True
+
+    # dqlite uses qmark parameter style
+    paramstyle = "qmark"
+
+    @classmethod
+    def get_pool_class(cls, url: URL) -> type[pool.Pool]:
+        return AsyncAdaptedQueuePool
+
+    @classmethod
+    def import_dbapi(cls) -> Any:
+        from dqlitedbapi import aio
+
+        return aio
+
+    def create_connect_args(self, url: URL) -> tuple[list[Any], dict[str, Any]]:
+        """Create connection arguments from URL.
+
+        URL format: dqlite+aio://host:port/database
+        """
+        host = url.host or "localhost"
+        port = url.port or 9001
+        database = url.database or "default"
+
+        address = f"{host}:{port}"
+
+        return [], {
+            "address": address,
+            "database": database,
+        }
+
+    def get_driver_connection(self, connection: Any) -> Any:
+        """Return the driver-level connection."""
+        return connection
+
+
+# Register the dialect
+dialect = DqliteDialect_aio

sqlalchemydqlite/base.py

@@ -0,0 +1,122 @@
+"""Base dqlite dialect for SQLAlchemy."""
+
+from typing import Any
+
+from sqlalchemy import pool
+from sqlalchemy.dialects.sqlite.base import SQLiteDialect
+from sqlalchemy.engine import URL
+from sqlalchemy.engine.interfaces import DBAPIConnection, IsolationLevel
+
+
+class DqliteDialect(SQLiteDialect):
+    """SQLAlchemy dialect for dqlite.
+
+    Inherits from SQLite dialect since dqlite is compatible with SQLite.
+    """
+
+    name = "dqlite"
+    driver = "dqlitedbapi"
+
+    # dqlite uses qmark parameter style
+    paramstyle = "qmark"
+
+    # Enable SQLAlchemy statement caching
+    supports_statement_cache = True
+
+    # Default to NullPool since dqlite handles connection pooling internally
+    @classmethod
+    def get_pool_class(cls, url: URL) -> type[pool.Pool]:
+        return pool.NullPool
+
+    @classmethod
+    def import_dbapi(cls) -> Any:
+        import dqlitedbapi
+
+        return dqlitedbapi
+
+    def create_connect_args(self, url: URL) -> tuple[list[Any], dict[str, Any]]:
+        """Create connection arguments from URL.
+
+        URL format: dqlite://host:port/database
+        """
+        host = url.host or "localhost"
+        port = url.port or 9001
+        database = url.database or "default"
+
+        address = f"{host}:{port}"
+
+        return [], {
+            "address": address,
+            "database": database,
+        }
+
+    def get_isolation_level(self, dbapi_connection: DBAPIConnection) -> IsolationLevel:
+        """Return the isolation level.
+
+        dqlite doesn't support PRAGMA read_uncommitted, so we return
+        SERIALIZABLE as the default isolation level.
+        """
+        return "SERIALIZABLE"
+
+    def set_isolation_level(self, dbapi_connection: DBAPIConnection, level: str | None) -> None:
+        """Set isolation level.
+
+        dqlite doesn't support changing isolation levels via PRAGMA,
+        so this is a no-op. dqlite uses SERIALIZABLE isolation by default.
+        """
+        pass
+
+    def do_rollback(self, dbapi_connection: DBAPIConnection) -> None:
+        """Rollback the current transaction.
+
+        dqlite throws an error if we try to rollback when no transaction
+        is active, so we catch and ignore that specific error.
+        """
+        try:
+            dbapi_connection.rollback()
+        except Exception as e:
+            # Ignore "no transaction is active" errors
+            if "no transaction is active" not in str(e):
+                raise
+
+    def do_commit(self, dbapi_connection: DBAPIConnection) -> None:
+        """Commit the current transaction.
+
+        dqlite throws an error if we try to commit when no transaction
+        is active, so we catch and ignore that specific error.
+        """
+        try:
+            dbapi_connection.commit()
+        except Exception as e:
+            # Ignore "no transaction is active" errors
+            if "no transaction is active" not in str(e):
+                raise
+
+    def do_ping(self, dbapi_connection: Any) -> bool:
+        """Check if the connection is still alive."""
+        try:
+            cursor = dbapi_connection.cursor()
+            cursor.execute("SELECT 1")
+            cursor.close()
+            return True
+        except Exception:
+            return False
+
+    def _get_server_version_info(self, connection: Any) -> tuple[int, ...]:
+        """Return the server version as a tuple.
+
+        dqlite uses SQLite internally, so we return SQLite version.
+        """
+        cursor = connection.connection.dbapi_connection.cursor()
+        cursor.execute("SELECT sqlite_version()")
+        row = cursor.fetchone()
+        cursor.close()
+
+        if row:
+            version_str = row[0]
+            return tuple(int(x) for x in version_str.split("."))
+        return (3, 0, 0)
+
+
+# Register the dialect
+dialect = DqliteDialect

sqlalchemydqlite/requirements.py

@@ -0,0 +1,45 @@
+"""SQLAlchemy test suite requirements for dqlite dialect."""
+
+from sqlalchemy.testing.requirements import SuiteRequirements
+
+
+class Requirements(SuiteRequirements):
+    """Test suite requirements for dqlite dialect.
+
+    Override requirements that dqlite doesn't support.
+    """
+
+    @property
+    def datetime_literals(self) -> bool:
+        """dqlite/SQLite doesn't have native datetime literals."""
+        return False
+
+    @property
+    def time_microseconds(self) -> bool:
+        """SQLite stores time as text without microseconds."""
+        return False
+
+    @property
+    def datetime_historic(self) -> bool:
+        """SQLite date range limitation."""
+        return False
+
+    @property
+    def unicode_ddl(self) -> bool:
+        """SQLite supports unicode in DDL."""
+        return True
+
+    @property
+    def savepoints(self) -> bool:
+        """dqlite supports savepoints."""
+        return True
+
+    @property
+    def two_phase_transactions(self) -> bool:
+        """dqlite doesn't support two-phase transactions."""
+        return False
+
+    @property
+    def temp_table_reflection(self) -> bool:
+        """SQLite supports temp table reflection."""
+        return True