sqlphilosophy 0.1.1__tar.gz → 0.1.3__tar.gz

sqlphilosophy-0.1.3/MANIFEST.in

@@ -0,0 +1 @@
+prune tests

{sqlphilosophy-0.1.1/src/sqlphilosophy.egg-info → sqlphilosophy-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlphilosophy
-Version: 0.1.1
+Version: 0.1.3
 Summary: Portable SQLAlchemy repository kit: sync and async CRUD, statement builders, sort/pagination, and SQL helpers.
 Author-email: Josh Martin <denverprogrammer@gmail.com>
 License-Expression: MIT

sqlphilosophy-0.1.3/src/sqlphilosophy/VERSION

@@ -0,0 +1 @@
+0.1.3

{sqlphilosophy-0.1.1 → sqlphilosophy-0.1.3/src/sqlphilosophy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlphilosophy
-Version: 0.1.1
+Version: 0.1.3
 Summary: Portable SQLAlchemy repository kit: sync and async CRUD, statement builders, sort/pagination, and SQL helpers.
 Author-email: Josh Martin <denverprogrammer@gmail.com>
 License-Expression: MIT

{sqlphilosophy-0.1.1 → sqlphilosophy-0.1.3}/src/sqlphilosophy.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 LICENSE
+MANIFEST.in
 README.md
 pyproject.toml
 src/sqlphilosophy/VERSION
@@ -24,20 +25,4 @@ src/sqlphilosophy/audit/model.py
 src/sqlphilosophy/sync/__init__.py
 src/sqlphilosophy/sync/protocols.py
 src/sqlphilosophy/sync/query.py
-src/sqlphilosophy/sync/repository.py
-tests/test_async_last_mile.py
-tests/test_async_query.py
-tests/test_async_repository.py
-tests/test_audit.py
-tests/test_batch7a_behavior.py
-tests/test_close_coverage.py
-tests/test_coverage_gaps.py
-tests/test_final_coverage.py
-tests/test_import_contract.py
-tests/test_last_mile.py
-tests/test_package_boundaries.py
-tests/test_sorting.py
-tests/test_sql_helpers.py
-tests/test_sql_row_edges.py
-tests/test_sync_query.py
-tests/test_sync_repository.py
+src/sqlphilosophy/sync/repository.py

sqlphilosophy-0.1.1/src/sqlphilosophy/VERSION

@@ -1 +0,0 @@
-0.1.1

sqlphilosophy-0.1.1/tests/test_async_last_mile.py

@@ -1,98 +0,0 @@
-"""Async last-mile coverage."""
-
-from __future__ import annotations
-import pytest
-
-from conftest import Child
-from conftest import Parent
-from conftest import Tag
-from conftest import UpdatableTag
-from conftest import Widget
-from sqlalchemy import literal_column
-from sqlalchemy import select
-from sqlphilosophy.aio.query import AsyncSqlAlchemyStatementBuilder
-from sqlphilosophy.aio.repository import AsyncBaseRepository
-from sqlphilosophy.sorting import ListQuery
-
-
-@pytest.mark.asyncio
-async def test_async_query_remaining(async_session) -> None:
-    parent = Parent()
-    async_session.add(parent)
-    await async_session.flush()
-    async_session.add(Child(parent_id=parent.id))
-    await async_session.flush()
-    b = AsyncSqlAlchemyStatementBuilder(async_session, Parent)
-    b.select_table()
-    b.select_columns(Parent.id)
-    b.select_from(Parent)
-    b.distinct(Parent.id)
-    b.group_by(Parent.id)
-    b.correlate(Parent)
-    b.correlate_except(Child)
-    b.as_lateral("p")
-    b.as_cte("p")
-    b.with_params({"x": 1})
-    with pytest.raises(ValueError, match="limit must be >= 0"):
-        b.limit(-1)
-    with pytest.raises(ValueError, match="offset must be >= 0"):
-        b.offset(-1)
-    await b.count()
-    await b.scalar()
-    await b.mappings().all()
-    await b.mappings().first()
-    await b.mappings().one()
-    await b.scalars().all()
-    await b.scalars().first()
-    b.build_select()
-
-
-@pytest.mark.asyncio
-async def test_async_query_filter_and_count(async_session) -> None:
-    await AsyncBaseRepository(Widget, async_session).create(name="f")
-    b = AsyncSqlAlchemyStatementBuilder(async_session, Widget)
-    b.filter_by(name="f")
-    await b.count()
-    empty = AsyncSqlAlchemyStatementBuilder(async_session, Widget)
-    empty._stmt = select(literal_column("1"))
-    await empty.count()
-    await empty.scalar()
-    await empty.count_distinct(Widget.id)
-    await empty.fetch_page(ListQuery(offset=0, limit=0))
-    with pytest.raises(ValueError, match="limit must be >= 0"):
-        await empty.fetch_page(ListQuery(offset=0, limit=-1))
-    await (
-        AsyncSqlAlchemyStatementBuilder(async_session, Widget)
-        .select_entity()
-        .where(Widget.name == "f")
-        .count_distinct(Widget.id)
-    )
-    empty.build_select()
-
-
-@pytest.mark.asyncio
-async def test_async_repository_remaining(async_session) -> None:
-    repo = AsyncBaseRepository(Widget, async_session)
-    row = await repo.create(name="left")
-    await repo.create(name="delete-params")
-    await repo.delete_where(criteria=[Widget.name == "delete-params"], params={"p": 1})
-    await repo.get_with_join(Tag, Widget.id == Tag.id, join_on=Widget.id == Tag.id)
-    assert await repo.update_partial(99999, {"name": "n"}, frozenset({"name"})) == 0
-    assert await repo.update_partial(row.id, {"name": "n"}, frozenset()) == 0
-    assert await repo.update_where(criteria=[Widget.id == row.id], values={}) == 0
-    import uuid
-
-    await repo.get_or_create(name=f"unique-{uuid.uuid4()}")
-    upd_repo = AsyncBaseRepository(UpdatableTag, async_session)
-    upd = await upd_repo.create(label="u")
-    await upd_repo.update_partial(
-        upd.id, {"label": "u2"}, frozenset({"label"}), touch_updated_on=True
-    )
-    with pytest.raises(ValueError, match="page must be >= 1"):
-        await repo.filter(page=0)
-    assert await repo.delete_many([]) == 0
-    await repo.batched_purge_ids(criteria=[Widget.name == "missing"], batch_size=5)
-    with pytest.raises(ValueError, match="limit must be >= 1"):
-        await repo.get_all(limit=0)
-    with pytest.raises(ValueError, match="page must be >= 1"):
-        await repo.get_all(page=0)

sqlphilosophy-0.1.1/tests/test_async_query.py

@@ -1,74 +0,0 @@
-"""Async AsyncSqlAlchemyStatementBuilder behavior."""
-
-from __future__ import annotations
-import pytest
-
-from conftest import Widget
-from sqlphilosophy.aio.query import AsyncSqlAlchemyStatementBuilder
-from sqlphilosophy.aio.repository import AsyncBaseRepository
-from sqlphilosophy.sorting import ListQuery
-from sqlphilosophy.sorting import SortConfig
-from sqlphilosophy.sorting import SortSpec
-
-
-@pytest.mark.asyncio
-async def test_async_query_builder(async_session) -> None:
-    repo = AsyncBaseRepository(Widget, async_session)
-    await repo.create(name="z")
-    await repo.create(name="a")
-    builder = (
-        AsyncSqlAlchemyStatementBuilder(async_session, Widget)
-        .select_entity()
-        .where(Widget.active.is_(True))
-        .order_by(Widget.name)
-        .limit(10)
-        .offset(0)
-    )
-    scalars = await builder.scalars().all()
-    assert len(scalars) == 2
-    assert await builder.scalars().first() is not None
-    assert await builder.select_columns(Widget.id).limit(1).scalar() is not None
-    mappings = await builder.select_entity().mappings().all()
-    assert mappings
-    assert await builder.count() == 2
-    assert await builder.count_distinct(Widget.id) == 2
-
-
-@pytest.mark.asyncio
-async def test_async_mappings_terminals(async_session) -> None:
-    await AsyncBaseRepository(Widget, async_session).create(name="m")
-    b = AsyncSqlAlchemyStatementBuilder(async_session, Widget).select_columns(
-        Widget.id, Widget.name
-    )
-    assert await b.mappings().all()
-    assert await b.mappings().first() is not None
-    assert (await b.mappings().one())["name"] == "m"
-
-
-@pytest.mark.asyncio
-async def test_async_fetch_page(async_session) -> None:
-    repo = AsyncBaseRepository(Widget, async_session)
-    for i in range(4):
-        await repo.create(name=f"n{i}")
-    sort = SortConfig(
-        default=SortSpec("name", "asc"),
-        columns={"name": {"asc": Widget.name, "desc": Widget.name.desc()}},
-    )
-    rows, total = await (
-        AsyncSqlAlchemyStatementBuilder(async_session, Widget)
-        .select_columns(Widget.id, Widget.name)
-        .fetch_page(ListQuery(offset=0, limit=2), sort=sort)
-    )
-    assert total == 4
-    assert len(rows) == 2
-
-
-@pytest.mark.asyncio
-async def test_async_limit_offset_validation(async_session) -> None:
-    b = AsyncSqlAlchemyStatementBuilder(async_session, Widget)
-    with pytest.raises(ValueError, match="limit must be >= 0"):
-        b.limit(-1)
-    with pytest.raises(ValueError, match="offset must be >= 0"):
-        b.offset(-1)
-    with pytest.raises(ValueError, match="limit must be >= 0"):
-        await b.fetch_page(ListQuery(offset=0, limit=-1), sort=None)

sqlphilosophy-0.1.1/tests/test_async_repository.py

@@ -1,123 +0,0 @@
-"""Async AsyncBaseRepository behavior."""
-
-from __future__ import annotations
-from unittest.mock import MagicMock
-import pytest
-
-from conftest import Widget
-from conftest import WidgetTag
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlphilosophy.aio.protocols import AsyncRepositoryFactory
-from sqlphilosophy.aio.query import AsyncSqlAlchemyStatementBuilder
-from sqlphilosophy.aio.repository import AsyncBaseRepository
-
-
-class _OtherAsyncRepo(AsyncBaseRepository[Widget]):
-    def __init__(self, session: AsyncSession, factory: AsyncRepositoryFactory) -> None:
-        super().__init__(Widget, session, factory)
-
-
-class _FakeAsyncFactory(AsyncRepositoryFactory):
-    def __init__(self, session: AsyncSession) -> None:
-        self._session = session
-        self.created: list[type] = []
-
-    @property
-    def session(self) -> AsyncSession:
-        return self._session
-
-    def create_statement(self, model: type) -> AsyncSqlAlchemyStatementBuilder:
-        self.created.append(model)
-        return AsyncSqlAlchemyStatementBuilder(self._session, model)
-
-    def get_repository(self, repo_class: type):
-        return repo_class(self._session, self)
-
-
-@pytest.mark.asyncio
-async def test_async_create_get(async_session: AsyncSession) -> None:
-    repo = AsyncBaseRepository(Widget, async_session)
-    created = await repo.create(name="async")
-    assert created.id is not None
-    assert await repo.get_by_id(created.id) is created
-    assert (await repo.get(created.id)).name == "async"
-
-
-@pytest.mark.asyncio
-async def test_async_get_many_filter_count(async_session: AsyncSession) -> None:
-    repo = AsyncBaseRepository(Widget, async_session)
-    a = await repo.create(name="a", active=True)
-    await repo.create(name="b", active=False)
-    assert len(await repo.get_many([a.id])) == 1
-    assert await repo.get_many([]) == []
-    assert await repo.count(active=True) == 1
-    assert len(await repo.filter(active=True)) == 1
-
-
-@pytest.mark.asyncio
-async def test_async_delete_many(async_session: AsyncSession) -> None:
-    repo = AsyncBaseRepository(Widget, async_session)
-    row = await repo.create(name="del")
-    assert await repo.remove(row.id) is True
-    one = await repo.create(name="x")
-    two = await repo.create(name="y")
-    assert await repo.delete_many([one.id, two.id]) == 2
-
-
-@pytest.mark.asyncio
-async def test_async_statement_without_factory(async_session: AsyncSession) -> None:
-    repo = AsyncBaseRepository(Widget, async_session)
-    builder = repo.statement()
-    assert isinstance(builder, AsyncSqlAlchemyStatementBuilder)
-
-
-@pytest.mark.asyncio
-async def test_async_for_repo_without_factory_raises(async_session: AsyncSession) -> None:
-    repo = AsyncBaseRepository(Widget, async_session)
-    with pytest.raises(RuntimeError, match="AsyncRepositoryFactory"):
-        repo.for_repo(_OtherAsyncRepo)
-
-
-@pytest.mark.asyncio
-async def test_async_for_repo_with_factory(async_session: AsyncSession) -> None:
-    factory = _FakeAsyncFactory(async_session)
-    repo = AsyncBaseRepository(Widget, async_session, factory)
-    other = repo.for_repo(_OtherAsyncRepo)
-    assert isinstance(other, _OtherAsyncRepo)
-
-
-def test_async_composite_pk_rejected() -> None:
-    with pytest.raises(TypeError, match="single-column primary key"):
-        AsyncBaseRepository(WidgetTag, MagicMock())
-
-
-@pytest.mark.asyncio
-async def test_async_extended_helpers(async_session: AsyncSession) -> None:
-    repo = AsyncBaseRepository(Widget, async_session)
-    row = await repo.create(name="ext")
-    assert await repo.exists(row.id)
-    assert await repo.exists_where(name="ext")
-    obj, created = await repo.get_or_create(name="new-async")
-    assert created is True
-    again, created2 = await repo.get_or_create(name="new-async")
-    assert created2 is False
-    assert again.id == obj.id
-    updated = await repo.update_partial(row.id, {"name": "changed"}, frozenset({"name"}))
-    assert updated == 1
-    deleted = await repo.delete_where(criteria=[Widget.name == "changed"])
-    assert deleted == 1
-    names = await repo.list_table_names()
-    assert "widget" in names
-    assert await repo.has_table("widget")
-
-
-async def test_list_table_names_without_inspector(
-    async_session, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    repo = AsyncBaseRepository(Widget, async_session)
-
-    def _no_inspect(_conn: object) -> None:
-        return None
-
-    monkeypatch.setattr("sqlphilosophy.aio.repository.sa_inspect", _no_inspect)
-    assert await repo.list_table_names() == frozenset()

sqlphilosophy-0.1.1/tests/test_audit.py

@@ -1,99 +0,0 @@
-"""Audit context, listeners, and models."""
-
-from __future__ import annotations
-from datetime import datetime
-import pytest
-
-from conftest import SoftWidget
-from conftest import Widget
-from sqlalchemy.orm import Session
-from sqlphilosophy.audit.context import audit_context
-from sqlphilosophy.audit.context import AuditContext
-from sqlphilosophy.audit.context import get_audit_actor_id
-from sqlphilosophy.audit.context import get_audit_context
-from sqlphilosophy.audit.context import set_audit_context
-from sqlphilosophy.audit.fields import AuditColumns
-from sqlphilosophy.audit.fields import is_audit_model
-from sqlphilosophy.audit.listener import configure_audit_listeners
-from sqlphilosophy.audit.listener import get_audit_listener
-from sqlphilosophy.audit.listener import soft_delete
-
-
-def test_audit_context_nested_and_reset() -> None:
-    assert get_audit_actor_id() is None
-    with audit_context(10):
-        assert get_audit_actor_id() == 10
-        with audit_context(20):
-            assert get_audit_actor_id() == 20
-        assert get_audit_actor_id() == 10
-    assert get_audit_actor_id() is None
-
-
-def test_audit_context_resets_on_exception() -> None:
-    with pytest.raises(RuntimeError):
-        with audit_context(5):
-            raise RuntimeError("boom")
-    assert get_audit_actor_id() is None
-
-
-def test_set_audit_context() -> None:
-    set_audit_context(AuditContext(actor_id=7))
-    assert get_audit_context() == AuditContext(actor_id=7)
-    set_audit_context(None)
-    assert get_audit_context() is None
-
-
-def test_timestamp_model_stamps_on_insert(sync_session: Session) -> None:
-    with audit_context(42):
-        row = Widget(name="audited")
-        sync_session.add(row)
-        sync_session.flush()
-    assert isinstance(row.created_on, datetime)
-    assert isinstance(row.updated_on, datetime)
-    assert row.created_by_id == 42
-    assert row.updated_by_id == 42
-
-
-def test_timestamp_model_stamps_on_update(sync_session: Session) -> None:
-    row = Widget(name="before")
-    sync_session.add(row)
-    sync_session.flush()
-    before = row.updated_on
-    with audit_context(99):
-        row.name = "after"
-        sync_session.flush()
-    assert row.updated_on >= before
-    assert row.updated_by_id == 99
-
-
-def test_soft_delete(sync_session: Session) -> None:
-    row = SoftWidget(name="soft")
-    sync_session.add(row)
-    sync_session.flush()
-    with audit_context(3):
-        soft_delete(row)
-    assert row.deleted_on is not None
-    assert row.deleted_by_id == 3
-
-
-def test_audit_columns_and_is_audit_model() -> None:
-    cols = AuditColumns.for_model(Widget)
-    assert cols.created == "created_on"
-    assert is_audit_model(Widget(name="x")) is True
-    assert is_audit_model(object()) is False
-
-
-def test_configure_audit_listeners_idempotent() -> None:
-    configure_audit_listeners()
-    listener = get_audit_listener()
-    listener.stamp_on_insert(Widget(name="direct"))
-    assert listener.now().tzinfo is not None
-
-
-def test_listener_set_helpers() -> None:
-    listener = get_audit_listener()
-    target = Widget(name="t")
-    listener._set_if_empty(target, "created_on", listener.now())
-    listener._set(target, "updated_by_id", 1)
-    listener._set_if_empty(target, "missing_attr", 1)
-    listener._set(object(), "anything", 1)

sqlphilosophy-0.1.1/tests/test_batch7a_behavior.py

@@ -1,155 +0,0 @@
-"""Batch 7A behavioral tests: transaction ownership, destructive helpers, async parity."""
-
-from __future__ import annotations
-
-import pytest
-from sqlalchemy import create_engine
-from sqlalchemy.ext.asyncio import async_sessionmaker
-from sqlalchemy.ext.asyncio import create_async_engine
-from sqlalchemy.orm import sessionmaker
-
-from conftest import Base
-from conftest import Widget
-from sqlphilosophy.aio.query import AsyncSqlAlchemyStatementBuilder
-from sqlphilosophy.sorting import ListQuery
-from sqlphilosophy.sorting import SortConfig
-from sqlphilosophy.sorting import SortSpec
-from sqlphilosophy.sync.query import SqlAlchemyStatementBuilder
-from sqlphilosophy.sync.repository import BaseRepository
-
-
-def test_sync_and_aio_subpackages_have_no_reexports() -> None:
-    import sqlphilosophy.aio as aio_pkg
-    import sqlphilosophy.sync as sync_pkg
-
-    assert sync_pkg.__all__ == []
-    assert aio_pkg.__all__ == []
-    for attr in ("BaseRepository", "SqlAlchemyStatementBuilder"):
-        assert not hasattr(sync_pkg, attr)
-    for attr in ("AsyncBaseRepository", "AsyncSqlAlchemyStatementBuilder"):
-        assert not hasattr(aio_pkg, attr)
-
-
-def test_create_flushes_without_commit_until_caller_commits() -> None:
-    engine = create_engine("sqlite+pysqlite:///:memory:")
-    Base.metadata.create_all(engine)
-    session = sessionmaker(bind=engine)()
-    try:
-        repo = BaseRepository(Widget, session)
-        row = repo.create(name="pending")
-        row_id = row.id
-        session.close()
-
-        verify = sessionmaker(bind=engine)()
-        try:
-            assert verify.get(Widget, row_id) is None
-        finally:
-            verify.close()
-    finally:
-        engine.dispose()
-
-
-def test_create_visible_after_explicit_commit() -> None:
-    engine = create_engine("sqlite+pysqlite:///:memory:")
-    Base.metadata.create_all(engine)
-    session = sessionmaker(bind=engine)()
-    try:
-        repo = BaseRepository(Widget, session)
-        row = repo.create(name="committed")
-        row_id = row.id
-        session.commit()
-        session.close()
-
-        verify = sessionmaker(bind=engine)()
-        try:
-            assert verify.get(Widget, row_id) is not None
-        finally:
-            verify.close()
-    finally:
-        engine.dispose()
-
-
-def test_delete_all_does_not_commit(sync_session, monkeypatch) -> None:
-    repo = BaseRepository(Widget, sync_session)
-    repo.create(name="stay")
-    sync_session.commit()
-
-    commits: list[bool] = []
-    original_commit = sync_session.commit
-
-    def track_commit() -> None:
-        commits.append(True)
-        return original_commit()
-
-    monkeypatch.setattr(sync_session, "commit", track_commit)
-    deleted = repo.delete_all()
-    assert deleted >= 1
-    assert commits == []
-
-
-def test_batched_purge_ids_commits_each_batch(sync_session, monkeypatch) -> None:
-    repo = BaseRepository(Widget, sync_session)
-    repo.create(name="purge-a")
-    repo.create(name="purge-b")
-    sync_session.commit()
-
-    commits: list[bool] = []
-    original_commit = sync_session.commit
-
-    def track_commit() -> None:
-        commits.append(True)
-        return original_commit()
-
-    monkeypatch.setattr(sync_session, "commit", track_commit)
-    total = repo.batched_purge_ids(criteria=[Widget.name.like("purge-%")], batch_size=1)
-    assert total == 2
-    assert len(commits) >= 1
-
-
-def test_apply_sort_rejects_disallowed_order_by_in_fetch_page(sync_session) -> None:
-    repo = BaseRepository(Widget, sync_session)
-    repo.create(name="alpha")
-    repo.create(name="beta")
-    sync_session.commit()
-
-    sort = SortConfig(
-        default=SortSpec("name", "asc"),
-        columns={"name": {"asc": Widget.name, "desc": Widget.name.desc()}},
-    )
-    rows, total = (
-        SqlAlchemyStatementBuilder(sync_session, Widget)
-        .select_entity()
-        .apply_sort(sort, {"evil_column": "asc"})
-        .fetch_page(ListQuery(offset=0, limit=10))
-    )
-    names = [row["name"] for row in rows]
-    assert total == 2
-    assert names == ["alpha", "beta"]
-
-
-@pytest.mark.asyncio
-async def test_async_apply_sort_parity_with_sync() -> None:
-    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-    maker = async_sessionmaker(engine, expire_on_commit=False)
-
-    async with maker() as session:
-        session.add(Widget(name="alpha"))
-        session.add(Widget(name="beta"))
-        await session.commit()
-
-        sort = SortConfig(
-            default=SortSpec("name", "asc"),
-            columns={"name": {"asc": Widget.name, "desc": Widget.name.desc()}},
-        )
-        rows, total = await (
-            AsyncSqlAlchemyStatementBuilder(session, Widget)
-            .select_entity()
-            .apply_sort(sort, {"name": "desc"})
-            .fetch_page(ListQuery(offset=0, limit=10))
-        )
-        assert total == 2
-        assert [row["name"] for row in rows] == ["beta", "alpha"]
-
-    await engine.dispose()