sqlalchemy-boltons 1.0.0__tar.gz

sqlalchemy_boltons-1.0.0/AUTHORS.md

@@ -0,0 +1,9 @@
+# Credits
+
+## Development Lead
+
+- Eduard Christian Dumitrescu <eduard.c.dumitrescu@gmail.com>
+
+## Contributors
+
+None yet. Why not be the first?

sqlalchemy_boltons-1.0.0/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [Unreleased]
+
+## [1.0.0] - 2025-02-22
+
+### Added
+
+- New module `sqlalchemy_boltons.sqlite` to customize transaction, foreign key enforcement, and journal mode settings.
+
+## [0.0.0] - 1970-01-01
+
+### Added
+
+- This is an example entry.
+- See below for the other types of changes.
+
+### Changed
+
+- Change in functionality.
+
+### Deprecated
+
+- Feature that will be removed soon.
+
+### Removed
+
+- Feature that is now removed.
+
+### Fixed
+
+- Bug that was fixed.
+
+### Security
+
+- Security vulnerability notice.

sqlalchemy_boltons-1.0.0/MANIFEST.in

@@ -0,0 +1,15 @@
+include AUTHORS.md
+include CHANGELOG.md
+include LICENSE
+include README.md
+
+recursive-include tests *
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co]
+
+recursive-include doc *.rst conf.py Makefile make.bat *.jpg *.png *.gif
+recursive-exclude doc/_build *
+recursive-include doc/_templates *
+recursive-include doc/_static *
+
+recursive-exclude * .gitkeep

sqlalchemy_boltons-1.0.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.1
+Name: sqlalchemy_boltons
+Version: 1.0.0
+Summary: Utilities that should've been inside SQLAlchemy but aren't
+Author-email: Eduard Christian Dumitrescu <eduard.c.dumitrescu@gmail.com>
+Maintainer-email: Eduard Christian Dumitrescu <eduard.c.dumitrescu@gmail.com>
+License: MIT
+Project-URL: Homepage, https://hydra.ecd.space/deaduard/sqlalchemy_boltons/
+Project-URL: Changelog, https://hydra.ecd.space/deaduard/sqlalchemy_boltons/file?name=CHANGELOG.md&ci=trunk
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS.md
+
+# sqlalchemy_boltons
+
+SQLAlchemy is great. However, it doesn't have everything built-in. Some important things are missing, and need to be
+"bolted on".
+
+(Name inspired from [boltons](https://pypi.org/project/boltons/). Not affiliated.)
+
+## sqlite
+
+SQLAlchemy doesn't automatically fix pysqlite's broken transaction handling. Instead, it provides a recipe for doing so
+inside the [documentation](https://docs.sqlalchemy.org/en/20/dialects/sqlite.html#serializable-isolation-savepoints-transactional-ddl).
+This module implements a fix for that broken behaviour.
+
+You can customize, on a per-engine or per-connection basis:
+
+- The type of transaction to be started, such as BEGIN or
+  [BEGIN IMMEDIATE](https://www.sqlite.org/lang_transaction.html) (or
+  [BEGIN CONCURRENT](https://www.sqlite.org/cgi/src/doc/begin-concurrent/doc/begin_concurrent.md) someday maybe).
+- The [foreign-key enforcement setting](https://www.sqlite.org/foreignkeys.html). Can be `True`, `False`, or `"defer"`.
+- The [journal mode](https://www.sqlite.org/pragma.html#pragma_journal_mode) such as DELETE or WAL.
+
+```python
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy_boltons.sqlite import create_engine_sqlite
+
+engine = create_engine_sqlite("file.db", journal_mode="WAL", timeout=0.5, create_engine_args={"echo": True})
+
+# use standard "BEGIN" and use deferred enforcement of foreign keys
+engine = engine.execution_options(x_sqlite_begin_mode=None, x_sqlite_foreign_keys="defer")
+
+# make a separate engine for write transactions using "BEGIN IMMEDIATE" for eager locking
+engine_w = engine.execution_options(x_sqlite_begin_mode="IMMEDIATE")
+
+Session = sessionmaker(engine)
+SessionW = sessionmaker(engine_w)
+
+with Session() as session:
+    session.execute(select(...))
+
+# this locks the database eagerly
+with SessionW() as session:
+    session.execute(update(...))
+```

sqlalchemy_boltons-1.0.0/README.md

@@ -0,0 +1,43 @@
+# sqlalchemy_boltons
+
+SQLAlchemy is great. However, it doesn't have everything built-in. Some important things are missing, and need to be
+"bolted on".
+
+(Name inspired from [boltons](https://pypi.org/project/boltons/). Not affiliated.)
+
+## sqlite
+
+SQLAlchemy doesn't automatically fix pysqlite's broken transaction handling. Instead, it provides a recipe for doing so
+inside the [documentation](https://docs.sqlalchemy.org/en/20/dialects/sqlite.html#serializable-isolation-savepoints-transactional-ddl).
+This module implements a fix for that broken behaviour.
+
+You can customize, on a per-engine or per-connection basis:
+
+- The type of transaction to be started, such as BEGIN or
+  [BEGIN IMMEDIATE](https://www.sqlite.org/lang_transaction.html) (or
+  [BEGIN CONCURRENT](https://www.sqlite.org/cgi/src/doc/begin-concurrent/doc/begin_concurrent.md) someday maybe).
+- The [foreign-key enforcement setting](https://www.sqlite.org/foreignkeys.html). Can be `True`, `False`, or `"defer"`.
+- The [journal mode](https://www.sqlite.org/pragma.html#pragma_journal_mode) such as DELETE or WAL.
+
+```python
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy_boltons.sqlite import create_engine_sqlite
+
+engine = create_engine_sqlite("file.db", journal_mode="WAL", timeout=0.5, create_engine_args={"echo": True})
+
+# use standard "BEGIN" and use deferred enforcement of foreign keys
+engine = engine.execution_options(x_sqlite_begin_mode=None, x_sqlite_foreign_keys="defer")
+
+# make a separate engine for write transactions using "BEGIN IMMEDIATE" for eager locking
+engine_w = engine.execution_options(x_sqlite_begin_mode="IMMEDIATE")
+
+Session = sessionmaker(engine)
+SessionW = sessionmaker(engine_w)
+
+with Session() as session:
+    session.execute(select(...))
+
+# this locks the database eagerly
+with SessionW() as session:
+    session.execute(update(...))
+```

sqlalchemy_boltons-1.0.0/doc/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

sqlalchemy_boltons-1.0.0/doc/conf.py

@@ -0,0 +1,55 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+import datetime as _datetime
+from importlib.metadata import version as _get_version
+
+
+project = "sqlalchemy_boltons"
+project_import_name = "sqlalchemy_boltons"
+project_dist_name = "sqlalchemy_boltons"
+author = "Eduard Christian Dumitrescu"
+copyright = "2025, " + author
+
+
+try:
+    version = _get_version(project_dist_name)
+except Exception:
+    version = "UNKNOWN"
+release = version + "~" + _datetime.date.today().strftime("%Y-%m-%d")
+
+language = "en"
+
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.todo",
+    # "sphinx.ext.imgmath",
+    "sphinx.ext.viewcode",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.autosummary",
+]
+
+source_suffix = ".rst"
+master_doc = "index"
+
+templates_path = ["_templates"]
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+
+todo_include_todos = True
+pygments_style = "sphinx"
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "classic"
+html_static_path = ["_static"]
+htmlhelp_basename = project_dist_name + "doc"

sqlalchemy_boltons-1.0.0/doc/index.rst

@@ -0,0 +1,20 @@
+.. documentation master file, created by
+   sphinx-quickstart on Mon Dec 30 17:43:13 2024.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to sqlalchemy_boltons's documentation!
+==============================================
+
+.. toctree::
+   :maxdepth: 3
+   :caption: Contents:
+
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`

sqlalchemy_boltons-1.0.0/doc/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

sqlalchemy_boltons-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[tool.black]
+line-length = 120
+
+[project]
+name = "sqlalchemy_boltons"
+version = "1.0.0"
+description = "Utilities that should've been inside SQLAlchemy but aren't"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "Eduard Christian Dumitrescu", email = "eduard.c.dumitrescu@gmail.com" },
+]
+maintainers = [
+    { name = "Eduard Christian Dumitrescu", email = "eduard.c.dumitrescu@gmail.com" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3"
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://hydra.ecd.space/deaduard/sqlalchemy_boltons/"
+Changelog = "https://hydra.ecd.space/deaduard/sqlalchemy_boltons/file?name=CHANGELOG.md&ci=trunk"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.package-data]
+"*" = ["*.*"]

sqlalchemy_boltons-1.0.0/setup.cfg

@@ -0,0 +1,14 @@
+[flake8]
+ignore = E203,E302,E305,E704,E741,W,C901,MC0001
+max-line-length = 120
+max-complexity = 99
+
+[pycodestyle]
+inherit = false
+ignore = E203,E302,E305,E704,E741,W,C901,MC0001
+max-line-length = 120
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

sqlalchemy_boltons-1.0.0/setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup
+
+setup(name="sqlalchemy_boltons", version="0.0.0.1")

sqlalchemy_boltons-1.0.0/src/sqlalchemy_boltons/sqlite.py

@@ -0,0 +1,224 @@
+import dataclasses as dc
+import functools
+from pathlib import Path
+import typing as ty
+from urllib import parse as _up
+
+import sqlalchemy as sa
+from sqlalchemy import pool as sap
+
+__all__ = [
+    "create_engine_sqlite",
+    "SQLAlchemySqliteTransactionFix",
+    "sqlite_file_uri",
+    "sqlite_journal_mode",
+    "MissingExecutionOptionError",
+]
+
+
+class MissingExecutionOptionError(ValueError):
+    pass
+
+
+@functools.lru_cache(maxsize=64)
+def make_journal_mode_statement(mode: str | None) -> str:
+    if mode:
+        if not mode.isalnum():
+            raise ValueError(f"invalid mode {mode!r}")
+        return f"PRAGMA journal_mode={mode}"
+    else:
+        return "PRAGMA journal_mode"
+
+
+@functools.lru_cache(maxsize=64)
+def make_begin_statement(mode: str | None) -> str:
+    if mode and not mode.isalpha():
+        raise ValueError(f"invalid mode {mode!r}")
+    return f"BEGIN {mode}" if mode else "BEGIN"
+
+
+@functools.lru_cache(maxsize=64)
+def make_foreign_keys_settings(foreign_keys: bool | str) -> tuple[str, str | None]:
+    if foreign_keys is True:
+        return "PRAGMA foreign_keys=1", None
+    elif foreign_keys is False:
+        return "PRAGMA foreign_keys=0", None
+    elif foreign_keys == "defer":
+        return "PRAGMA foreign_keys=1", "PRAGMA defer_foreign_keys=1"
+    else:
+        raise ValueError("invalid value {foreign_keys!r} for x_sqlite_foreign_keys")
+
+
+class SQLAlchemySqliteTransactionFix:
+    """
+    This class exists because sqlalchemy doesn't automatically fix pysqlite's stupid default behaviour. Additionally,
+    we implement support for foreign keys.
+
+    https://docs.sqlalchemy.org/en/20/dialects/sqlite.html#serializable-isolation-savepoints-transactional-ddl
+    """
+
+    def register(self, engine):
+        sa.event.listen(engine, "connect", self.event_connect)
+        sa.event.listen(engine, "begin", self.event_begin)
+
+    def make_journal_mode_statement(self, mode: str | None):
+        return make_journal_mode_statement(mode)
+
+    def make_begin_statement(self, mode: str | None):
+        return make_begin_statement(mode)
+
+    def make_foreign_keys_settings(self, foreign_keys: bool | str) -> tuple[str, str | None]:
+        return make_foreign_keys_settings(foreign_keys)
+
+    def event_connect(self, dbapi_connection, connection_record):
+        # disable pysqlite's emitting of the BEGIN statement entirely.
+        # also stops it from emitting COMMIT before any DDL.
+        dbapi_connection.isolation_level = None
+
+    def event_begin(self, conn):
+        execution_options = conn.get_execution_options()
+
+        try:
+            opt_begin = execution_options["x_sqlite_begin_mode"]
+            opt_fk = execution_options["x_sqlite_foreign_keys"]
+        except KeyError as exc:
+            raise MissingExecutionOptionError(
+                "You must configure your engine (or connection) execution options. "
+                "For example:\n\n"
+                "    engine = create_engine_sqlite(...)\n"
+                '    engine = engine.execution_options(x_sqlite_foreign_keys="defer")\n'
+                "    engine_ro = engine.execution_options(x_sqlite_begin_mode=None)\n"
+                '    engine_rw = engine.execution_options(x_sqlite_begin_mode="IMMEDIATE")'
+            ) from exc
+        begin = self.make_begin_statement(opt_begin)
+        before, after = self.make_foreign_keys_settings(opt_fk)
+
+        if mode := execution_options.get("x_sqlite_journal_mode"):
+            conn.exec_driver_sql(self.make_journal_mode_statement(mode)).close()
+
+        conn.exec_driver_sql(before).close()
+        conn.exec_driver_sql(begin).close()
+        if after:
+            conn.exec_driver_sql(after).close()
+
+
+@dc.dataclass
+class Memory:
+    """
+    We keep a reference to an open connection because SQLite will free up the database otherwise.
+
+    Note that you still can't get concurrent readers and writers because you cannot currently set WAL mode on an
+    in-memory database. See https://sqlite.org/forum/info/6700ab1f9f6e8a00
+    """
+
+    uri: str = dc.field(init=False)
+    connection_reference = None
+
+    def __post_init__(self):
+        self.uri = f"file:/sqlalchemy_boltons_memdb_{id(self)}"
+
+    def as_uri(self):
+        return self.uri
+
+
+def sqlite_file_uri(path: Path | str | Memory, parameters: ty.Sequence[tuple[str | bytes, str | bytes]] = ()) -> str:
+    if isinstance(path, str):
+        path = Path(path)
+    if isinstance(path, Path) and not path.is_absolute():
+        path = path.absolute()
+
+    qs = _up.urlencode(parameters, quote_via=_up.quote)
+    qm = "?" if qs else ""
+    return f"{path.as_uri()}{qm}{qs}"
+
+
+def sqlite_journal_mode(connection, mode: str | None = None) -> str:
+    [[value]] = connection.exec_driver_sql(make_journal_mode_statement(mode))
+    return value
+
+
+def create_engine_sqlite(
+    path: Path | str | Memory,
+    *,
+    timeout: float | int | None,
+    parameters: ty.Iterable[tuple[str | bytes, str | bytes]] = (),
+    journal_mode: str | None = None,
+    check_same_thread: bool | None = False,
+    create_engine_args: dict | None = None,
+    create_engine: ty.Callable | None = None,
+    transaction_fix: SQLAlchemySqliteTransactionFix | bool = True,
+) -> sa.Engine:
+    """
+    Create a sqlite engine.
+
+    Parameters
+    ----------
+    path: Path | str | Memory
+        Path to the db file, or a :class:`Memory` object. The same memory object can be shared across multiple engines.
+    timeout: float
+        How long will SQLite wait if the database is locked? See
+        https://docs.python.org/3/library/sqlite3.html#sqlite3.connect
+    parameters: ty.Sequence, optional
+        SQLite URI query parameters as described in https://www.sqlite.org/uri.html
+    journal_mode: str, optional
+        If provided, set the journal mode to this string before every transaction. This option simply sets the
+        ``x_sqlite_journal_mode`` engine execution option.
+    check_same_thread: bool, optional
+        Defaults to False. See https://docs.python.org/3/library/sqlite3.html#sqlite3.connect
+    create_engine_args: dict, optional
+        Keyword arguments to be passed to :func:`sa.create_engine`.
+    create_engine: callable, optional
+        If provided, this will be used instead of :func:`sa.create_engine`. You can use this to further customize
+        the engine creation.
+    transaction_fix: SQLAlchemySqliteTransactionFix | bool, optional
+        See :class:`SQLAlchemySqliteTransactionFix`. If True, then instantiate one. If False, then do not apply the fix.
+        (default: True)
+    """
+
+    parameters = list(parameters)
+    if isinstance(path, Memory):
+        parameters += (("vfs", "memdb"),)
+    parameters.append(("uri", "true"))
+
+    uri = sqlite_file_uri(path, parameters)
+
+    if create_engine_args is None:
+        create_engine_args = {}  # pragma: no cover
+
+    # always default to QueuePool
+    if (k := "poolclass") not in create_engine_args:
+        create_engine_args[k] = sap.QueuePool
+
+    if (v := create_engine_args.get(k := "connect_args")) is None:
+        create_engine_args[k] = v = {}
+    if timeout is not None:
+        v["timeout"] = timeout
+    if check_same_thread is not None:
+        v["check_same_thread"] = check_same_thread
+
+    # do not pass through poolclass=None
+    if create_engine_args.get((k := "poolclass"), True) is None:
+        create_engine_args.pop(k, None)  # pragma: no cover
+
+    if create_engine is None:
+        create_engine = sa.create_engine
+
+    engine = create_engine("sqlite:///" + uri, **create_engine_args)
+
+    if transaction_fix is True:
+        transaction_fix = SQLAlchemySqliteTransactionFix()
+
+    if transaction_fix:
+        transaction_fix.register(engine)
+
+    engine = engine.execution_options(x_sqlite_journal_mode=journal_mode)
+
+    if isinstance(path, Memory):
+        (conn := engine.raw_connection()).detach()
+
+        # force the connection to actually happen
+        conn.execute("SELECT 0 WHERE 0").close()
+
+        path.connection_reference = conn
+
+    return engine

sqlalchemy_boltons-1.0.0/src/sqlalchemy_boltons.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.1
+Name: sqlalchemy-boltons
+Version: 1.0.0
+Summary: Utilities that should've been inside SQLAlchemy but aren't
+Author-email: Eduard Christian Dumitrescu <eduard.c.dumitrescu@gmail.com>
+Maintainer-email: Eduard Christian Dumitrescu <eduard.c.dumitrescu@gmail.com>
+License: MIT
+Project-URL: Homepage, https://hydra.ecd.space/deaduard/sqlalchemy_boltons/
+Project-URL: Changelog, https://hydra.ecd.space/deaduard/sqlalchemy_boltons/file?name=CHANGELOG.md&ci=trunk
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS.md
+
+# sqlalchemy_boltons
+
+SQLAlchemy is great. However, it doesn't have everything built-in. Some important things are missing, and need to be
+"bolted on".
+
+(Name inspired from [boltons](https://pypi.org/project/boltons/). Not affiliated.)
+
+## sqlite
+
+SQLAlchemy doesn't automatically fix pysqlite's broken transaction handling. Instead, it provides a recipe for doing so
+inside the [documentation](https://docs.sqlalchemy.org/en/20/dialects/sqlite.html#serializable-isolation-savepoints-transactional-ddl).
+This module implements a fix for that broken behaviour.
+
+You can customize, on a per-engine or per-connection basis:
+
+- The type of transaction to be started, such as BEGIN or
+  [BEGIN IMMEDIATE](https://www.sqlite.org/lang_transaction.html) (or
+  [BEGIN CONCURRENT](https://www.sqlite.org/cgi/src/doc/begin-concurrent/doc/begin_concurrent.md) someday maybe).
+- The [foreign-key enforcement setting](https://www.sqlite.org/foreignkeys.html). Can be `True`, `False`, or `"defer"`.
+- The [journal mode](https://www.sqlite.org/pragma.html#pragma_journal_mode) such as DELETE or WAL.
+
+```python
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy_boltons.sqlite import create_engine_sqlite
+
+engine = create_engine_sqlite("file.db", journal_mode="WAL", timeout=0.5, create_engine_args={"echo": True})
+
+# use standard "BEGIN" and use deferred enforcement of foreign keys
+engine = engine.execution_options(x_sqlite_begin_mode=None, x_sqlite_foreign_keys="defer")
+
+# make a separate engine for write transactions using "BEGIN IMMEDIATE" for eager locking
+engine_w = engine.execution_options(x_sqlite_begin_mode="IMMEDIATE")
+
+Session = sessionmaker(engine)
+SessionW = sessionmaker(engine_w)
+
+with Session() as session:
+    session.execute(select(...))
+
+# this locks the database eagerly
+with SessionW() as session:
+    session.execute(update(...))
+```

sqlalchemy_boltons-1.0.0/src/sqlalchemy_boltons.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+AUTHORS.md
+CHANGELOG.md
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+doc/Makefile
+doc/conf.py
+doc/index.rst
+doc/make.bat
+src/sqlalchemy_boltons/__init__.py
+src/sqlalchemy_boltons/py.typed
+src/sqlalchemy_boltons/sqlite.py
+src/sqlalchemy_boltons.egg-info/PKG-INFO
+src/sqlalchemy_boltons.egg-info/SOURCES.txt
+src/sqlalchemy_boltons.egg-info/dependency_links.txt
+src/sqlalchemy_boltons.egg-info/top_level.txt
+tests/__init__.py
+tests/conftest.py
+tests/test_sqlite.py

sqlalchemy_boltons-1.0.0/src/sqlalchemy_boltons.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sqlalchemy_boltons-1.0.0/src/sqlalchemy_boltons.egg-info/top_level.txt

@@ -0,0 +1 @@
+sqlalchemy_boltons

sqlalchemy_boltons-1.0.0/tests/__init__.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))

sqlalchemy_boltons-1.0.0/tests/test_sqlite.py

@@ -0,0 +1,196 @@
+import contextlib
+import os
+
+import pytest
+import sqlalchemy as sa
+import sqlalchemy.orm as sao
+
+from sqlalchemy_boltons import sqlite as _sq
+
+
+# change this if every this situation changes https://sqlite.org/forum/info/6700ab1f9f6e8a00
+HAS_MEMDB_MVCC = False
+
+Base = sao.declarative_base()
+
+
+class Example(Base):
+    __tablename__ = "ex1"
+
+    id = sa.Column(sa.Integer, primary_key=True)
+
+
+class Example2(Base):
+    __tablename__ = "ex2"
+
+    id = sa.Column(sa.ForeignKey("ex1.id"), primary_key=True)
+
+
+@contextlib.contextmanager
+def temporary_chdir(path):
+    old = os.getcwd()
+    try:
+        os.chdir(str(path))
+        yield
+    finally:
+        os.chdir(old)
+
+
+def test_invalid():
+    with pytest.raises(ValueError):
+        _sq.make_journal_mode_statement("!@#$")
+    with pytest.raises(ValueError):
+        _sq.make_begin_statement("!@#$")
+    with pytest.raises(ValueError):
+        _sq.make_foreign_keys_settings("!@#$")
+
+
+@pytest.fixture(scope="function")
+def simple_sqlite_engine(tmp_path, database_type):
+    if database_type == "file":
+        path = tmp_path / "x.db"
+    elif database_type == "memory":
+        path = _sq.Memory()
+    else:
+        raise AssertionError
+
+    return _sq.create_engine_sqlite(path, journal_mode="WAL", timeout=0.5, create_engine_args={"echo": True})
+
+
+@pytest.mark.parametrize("database_type", ["file", "memory"])
+def test_transaction(simple_sqlite_engine, database_type):
+    has_mvcc: bool = (database_type != "memory") or HAS_MEMDB_MVCC
+
+    engine = simple_sqlite_engine
+    engine = engine.execution_options(x_sqlite_foreign_keys="defer")
+
+    with pytest.raises(Exception, match="You must configure your engine"):
+        with engine.begin():
+            pass
+
+    engine_r = engine.execution_options(x_sqlite_begin_mode=None)
+    engine_w = engine.execution_options(x_sqlite_begin_mode="IMMEDIATE")
+
+    SessionR = sao.sessionmaker(engine_r)
+    SessionW = sao.sessionmaker(engine_w)
+
+    if has_mvcc:
+        with engine_r.begin() as conn:
+            actual_journal_mode = _sq.sqlite_journal_mode(conn)
+        assert actual_journal_mode.upper() == "WAL"
+
+    # read transactions can be concurrent
+    with engine_r.begin() as s:
+        with engine_r.begin() as s2:
+            pass
+
+    # write transactions cannot
+    with engine_w.begin() as s:
+        with pytest.raises(sa.exc.OperationalError):
+            with engine_w.begin() as s2:
+                pass
+
+    # create schema
+    with SessionW() as s:
+        Base.metadata.create_all(s.connection())
+        s.add(Example(id=1))
+        s.flush()
+        s.commit()
+
+    # test basic ACID assumptions
+    with SessionW() as s:
+        s.add(Example(id=2))
+        s.flush()
+
+        assert len(s.execute(sa.select(Example)).all()) == 2
+
+        if has_mvcc:
+            # concurrent connections not supported for memdb yet :(
+            with SessionR() as s2:
+                assert len(s2.execute(sa.select(Example)).all()) == 1
+
+        with pytest.raises(sa.exc.OperationalError):
+            with SessionW() as s2:
+                s2.add(Example(id=2))
+                s2.flush()
+
+        assert len(s.execute(sa.select(Example)).all()) == 2
+        s.commit()
+
+
+@pytest.mark.parametrize("path_type", ["str", "Path"])
+def test_create_engine_path(tmp_path, path_type):
+    path = tmp_path / "x.db"
+
+    if path_type == "str":
+        path_ = str(path)
+    else:
+        path_ = path
+
+    assert not path.exists()
+
+    engine = _sq.create_engine_sqlite(path_, journal_mode="WAL", timeout=0.5, create_engine_args={"echo": True})
+    engine = engine.execution_options(x_sqlite_begin_mode=None, x_sqlite_foreign_keys="defer")
+
+    with sao.Session(bind=engine) as s:
+        Base.metadata.create_all(s.connection())
+        s.commit()
+
+    assert path.exists()
+
+
+def test_relative_path(tmp_path):
+    name = "relative.db"
+    path = tmp_path / name
+    assert not path.exists()
+
+    with temporary_chdir(tmp_path):
+        engine = _sq.create_engine_sqlite(name, journal_mode="WAL", timeout=0.5)
+
+    engine = engine.execution_options(x_sqlite_begin_mode="IMMEDIATE", x_sqlite_foreign_keys="defer")
+    with engine.begin():
+        pass
+
+    assert path.exists()
+
+
+def _test_fk_common(engine, foreign_keys):
+    engine = engine.execution_options(x_sqlite_begin_mode="IMMEDIATE", x_sqlite_foreign_keys=foreign_keys)
+
+    with sao.Session(bind=engine) as s:
+        Base.metadata.create_all(s.connection())
+        s.add(Example(id=1))
+        s.commit()
+
+    return engine
+
+
+@pytest.mark.parametrize("database_type", ["file", "memory"])
+def test_fk_off(simple_sqlite_engine):
+    engine = _test_fk_common(simple_sqlite_engine, False)
+
+    with sao.Session(bind=engine) as s:
+        s.add(Example2(id=2))
+        s.flush()
+        s.commit()
+
+
+@pytest.mark.parametrize("database_type", ["file", "memory"])
+def test_fk_defer(simple_sqlite_engine):
+    engine = _test_fk_common(simple_sqlite_engine, "defer")
+
+    with sao.Session(bind=engine) as s:
+        s.add(Example2(id=2))
+        s.flush()
+        with pytest.raises(sa.exc.IntegrityError):
+            s.commit()
+
+
+@pytest.mark.parametrize("database_type", ["file", "memory"])
+def test_fk_on(simple_sqlite_engine):
+    engine = _test_fk_common(simple_sqlite_engine, True)
+
+    with sao.Session(bind=engine) as s:
+        with pytest.raises(sa.exc.IntegrityError):
+            s.add(Example2(id=2))
+            s.flush()