initial commit

Author: levydsa

.envrc

@@ -0,0 +1 @@
+has nix && use flake

.github/workflows/test.yml

@@ -0,0 +1,31 @@
+name: Test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12"]
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+        
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install .[dev]
+        
+    - name: Run tests
+      run: |
+        pytest --cov=libsql_sqlalchemy tests/ 

.gitignore

@@ -0,0 +1,12 @@
+.direnv
+
+*.egg-info/
+*.egg
+__pycache__/
+*.py[cod]
+*$py.class
+dist/
+build/
+.pytest_cache/
+.coverage
+htmlcov/

.python-version

@@ -0,0 +1 @@
+3.12

README.md

@@ -0,0 +1,35 @@
+{
+  description = "A very basic flake";
+
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
+    flake-utils = {
+      url = "github:numtide/flake-utils";
+    };
+  };
+
+  outputs = { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = import nixpkgs { inherit system; };
+      in
+      {
+        formatter = pkgs.nixpkgs-fmt;
+        devShells.default = with pkgs; mkShell {
+          buildInputs = [
+            ruff
+            uv
+            poetry
+            python312
+            python312Packages.pip
+            python312Packages.virtualenv
+            python312Packages.pytest
+            python312Packages.pyperf
+          ];
+          shellHook = ''
+            virtualenv .venv
+            source .venv/bin/activate
+          '';
+        };
+      });
+}

flake.lock

@@ -0,0 +1,117 @@
+import os
+import urllib.parse
+
+from sqlalchemy import util
+from sqlalchemy.dialects import registry as _registry
+from sqlalchemy.dialects.sqlite.pysqlite import SQLiteDialect_pysqlite
+
+from libsql_experimental import Connection
+
+__version__ = "0.1.0-pre"
+
+_registry.register("sqlite.libsql", "libsql_sqlalchemy", "SQLiteDialect_libsql")
+
+
+def _build_connection_url(url, query, secure):
+    # sorting of keys is for unit test support
+    query_str = urllib.parse.urlencode(sorted(query.items()))
+
+    if not url.host:
+        if query_str:
+            return f"{url.database}?{query_str}"
+        return url.database
+    elif secure:  # yes, pop to remove
+        scheme = "https"
+    else:
+        scheme = "http"
+
+    if url.username and url.password:
+        netloc = f"{url.username}:{url.password}@{url.host}"
+    elif url.username:
+        netloc = f"{url.username}@{url.host}"
+    else:
+        netloc = url.host
+
+    if url.port:
+        netloc += f":{url.port}"
+
+    return urllib.parse.urlunsplit(
+        (
+            scheme,
+            netloc,
+            url.database or "",
+            query_str,
+            "",  # fragment
+        )
+    )
+
+
+class SQLiteDialect_libsql(SQLiteDialect_pysqlite):
+    driver = "libsql"
+    # need to be set explicitly
+    supports_statement_cache = SQLiteDialect_pysqlite.supports_statement_cache
+
+    @classmethod
+    def import_dbapi(cls):
+        import libsql_experimental as libsql
+
+        return libsql
+
+    def on_connect(self):
+        import libsql_experimental as libsql
+
+        sqlite3_connect = super().on_connect()
+
+        def connect(conn):
+            # LibSQL: there is no support for create_function()
+            if isinstance(conn, Connection):
+                return
+            return sqlite3_connect(conn)
+
+        return connect
+
+    def create_connect_args(self, url):
+        pysqlite_args = (
+            ("uri", bool),
+            ("timeout", float),
+            ("isolation_level", str),
+            ("detect_types", int),
+            ("check_same_thread", bool),
+            ("cached_statements", int),
+            ("secure", bool),  # LibSQL extra, selects between ws and wss
+        )
+        opts = url.query
+        libsql_opts = {}
+        for key, type_ in pysqlite_args:
+            util.coerce_kw_type(opts, key, type_, dest=libsql_opts)
+
+        if url.host:
+            libsql_opts["uri"] = True
+
+        if libsql_opts.get("uri", False):
+            uri_opts = dict(opts)
+            # here, we are actually separating the parameters that go to
+            # sqlite3/pysqlite vs. those that go the SQLite URI.  What if
+            # two names conflict?  again, this seems to be not the case right
+            # now, and in the case that new names are added to
+            # either side which overlap, again the sqlite3/pysqlite parameters
+            # can be passed through connect_args instead of in the URL.
+            # If SQLite native URIs add a parameter like "timeout" that
+            # we already have listed here for the python driver, then we need
+            # to adjust for that here.
+            for key, type_ in pysqlite_args:
+                uri_opts.pop(key, None)
+
+            secure = libsql_opts.pop("secure", False)
+            connect_url = _build_connection_url(url, uri_opts, secure)
+        else:
+            connect_url = url.database or ":memory:"
+            if connect_url != ":memory:":
+                connect_url = os.path.abspath(connect_url)
+
+        libsql_opts.setdefault("check_same_thread", not self._is_url_file_db(url))
+
+        return ([connect_url], libsql_opts)
+
+
+dialect = SQLiteDialect_libsql

flake.nix

@@ -0,0 +1,19 @@
+[project]
+name = "libsql-sqlalchemy"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "libsql-experimental>=0.0.47",
+    "sqlalchemy>=2.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+    "pytest-cov>=4.1.0",
+]
+
+[project.entry-points."sqlalchemy.dialects"]
+"sqlite.libsql" = "libsql_sqlalchemy:SQLiteDialect_libsql"

libsql_sqlalchemy/__init__.py

@@ -0,0 +1,75 @@
+import pytest
+from sqlalchemy import create_engine, Column, Integer, String, text
+from sqlalchemy.orm import declarative_base, sessionmaker
+
+Base = declarative_base()
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+    email = Column(String)
+
+
+@pytest.fixture
+def engine():
+    return create_engine("sqlite+libsql://")
+
+
+@pytest.fixture
+def session(engine):
+    Base.metadata.create_all(engine)
+    Session = sessionmaker(bind=engine)
+    session = Session()
+    yield session
+    session.close()
+    Base.metadata.drop_all(engine)
+
+
+def test_connection(engine):
+    with engine.connect() as conn:
+        result = conn.execute(text("SELECT 1"))
+        assert result.scalar() == 1
+
+
+def test_create_table(session):
+    with session.connection() as conn:
+        result = conn.execute(
+            text("SELECT name FROM sqlite_master WHERE type='table' AND name='users'")
+        )
+        assert result.scalar() == "users"
+
+
+def test_insert_and_query(session):
+    user = User(name="Test User", email="[email protected]")
+    session.add(user)
+    session.commit()
+
+    queried_user = session.query(User).first()
+    assert queried_user.name == "Test User"
+    assert queried_user.email == "[email protected]"
+
+
+def test_update(session):
+    user = User(name="Test User", email="[email protected]")
+    session.add(user)
+    session.commit()
+
+    user.name = "Updated User"
+    session.commit()
+
+    updated_user = session.query(User).first()
+    assert updated_user.name == "Updated User"
+
+
+def test_delete(session):
+    user = User(name="Test User", email="[email protected]")
+    session.add(user)
+    session.commit()
+
+    session.delete(user)
+    session.commit()
+
+    assert session.query(User).count() == 0