sqlphilosophy 0.2.1__tar.gz → 0.3.3__tar.gz

{sqlphilosophy-0.2.1/src/sqlphilosophy.egg-info → sqlphilosophy-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlphilosophy
-Version: 0.2.1
+Version: 0.3.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
@@ -40,6 +40,8 @@ Dynamic: license-file
 
 # sqlphilosophy
 
+Current source and planned customer-subdomain impact: [current-state summary](docs/current-state-summary.md).
+
 Portable SQLAlchemy repository kit: sync and async CRUD, fluent statement builders, sort/pagination, Core SQL helpers, and optional audit listeners.
 
 | | |
@@ -68,6 +70,8 @@ Portable SQLAlchemy repository kit: sync and async CRUD, fluent statement builde
 - **Repository pattern** for a single mapped model (`BaseRepository`, `AsyncBaseRepository`).
 - **Fluent query builders** with pagination/sort (`StatementQueryBuilder`, `ListQuery`, `SortConfig`).
 - **SQL helpers** for row mapping, partial updates, and developer-defined fragments via **`sqlphilosophy.trusted_sql`**.
+- **Opt-in strict row decoders** via `sqlphilosophy.strict` for non-coercing
+  scalars, timestamps, enums, collections, UUIDs, and recursive JSON.
 - **Optional audit listeners** and timestamp mixins.
 
 ## What this package does not do
@@ -132,6 +136,7 @@ with SessionLocal() as session:
 | `sqlphilosophy` | `__version__` only |
 | `sqlphilosophy.types` | Portable typing aliases |
 | `sqlphilosophy.sql` | Row mapping, partial updates, Core helpers (re-exports `trusted_sql`) |
+| `sqlphilosophy.strict` | Opt-in non-coercing row decoders and strict JSON validation |
 | `sqlphilosophy.trusted_sql` | Developer-trusted SQL fragments — see [SECURITY.md](./SECURITY.md) |
 | `sqlphilosophy.sorting` | `ListQuery`, `SortConfig`, `SortSpec` |
 | `sqlphilosophy.sync` / `sqlphilosophy.aio` | Repositories, query builders, factory protocols |
@@ -177,3 +182,11 @@ See [RELEASING.md](./RELEASING.md) for GitHub + PyPI trusted publishing. See [CH
 ## License
 
 MIT — see [LICENSE](./LICENSE).
+
+## Expression lookups and scope overrides (0.3.1)
+
+Both repository bases provide `find_entity(criteria=..., lock=False)`, `find_row(criteria=..., columns=..., lock=False)` and `count_scoped(criteria=...)`. Criteria must not be empty; projected lookups also require columns. Entity lookups return a mapped object, projected lookups return RowMapping, and absence returns None. These methods never commit.
+
+Override `apply_scope(statement)` for additional predicates on these helpers. It runs after projection initialization, because `select_columns`/`select_entity` reset the builder's SELECT. This hook does not implicitly scope existing CRUD helpers or arbitrary builder calls: keep ownership checks in named application repository methods. Existing `first`, `get_by_id`, `count` and statement APIs remain available and unchanged.
+
+The 0.3.1 artifact is a local candidate until separately published. Dependent candidate packages use a vendored wheel during validation; publish sqlPhilosophy first before replacing their local sources with registry-only dependencies.

{sqlphilosophy-0.2.1 → sqlphilosophy-0.3.3}/README.md

@@ -1,5 +1,7 @@
 # sqlphilosophy
 
+Current source and planned customer-subdomain impact: [current-state summary](docs/current-state-summary.md).
+
 Portable SQLAlchemy repository kit: sync and async CRUD, fluent statement builders, sort/pagination, Core SQL helpers, and optional audit listeners.
 
 | | |
@@ -28,6 +30,8 @@ Portable SQLAlchemy repository kit: sync and async CRUD, fluent statement builde
 - **Repository pattern** for a single mapped model (`BaseRepository`, `AsyncBaseRepository`).
 - **Fluent query builders** with pagination/sort (`StatementQueryBuilder`, `ListQuery`, `SortConfig`).
 - **SQL helpers** for row mapping, partial updates, and developer-defined fragments via **`sqlphilosophy.trusted_sql`**.
+- **Opt-in strict row decoders** via `sqlphilosophy.strict` for non-coercing
+  scalars, timestamps, enums, collections, UUIDs, and recursive JSON.
 - **Optional audit listeners** and timestamp mixins.
 
 ## What this package does not do
@@ -92,6 +96,7 @@ with SessionLocal() as session:
 | `sqlphilosophy` | `__version__` only |
 | `sqlphilosophy.types` | Portable typing aliases |
 | `sqlphilosophy.sql` | Row mapping, partial updates, Core helpers (re-exports `trusted_sql`) |
+| `sqlphilosophy.strict` | Opt-in non-coercing row decoders and strict JSON validation |
 | `sqlphilosophy.trusted_sql` | Developer-trusted SQL fragments — see [SECURITY.md](./SECURITY.md) |
 | `sqlphilosophy.sorting` | `ListQuery`, `SortConfig`, `SortSpec` |
 | `sqlphilosophy.sync` / `sqlphilosophy.aio` | Repositories, query builders, factory protocols |
@@ -137,3 +142,11 @@ See [RELEASING.md](./RELEASING.md) for GitHub + PyPI trusted publishing. See [CH
 ## License
 
 MIT — see [LICENSE](./LICENSE).
+
+## Expression lookups and scope overrides (0.3.1)
+
+Both repository bases provide `find_entity(criteria=..., lock=False)`, `find_row(criteria=..., columns=..., lock=False)` and `count_scoped(criteria=...)`. Criteria must not be empty; projected lookups also require columns. Entity lookups return a mapped object, projected lookups return RowMapping, and absence returns None. These methods never commit.
+
+Override `apply_scope(statement)` for additional predicates on these helpers. It runs after projection initialization, because `select_columns`/`select_entity` reset the builder's SELECT. This hook does not implicitly scope existing CRUD helpers or arbitrary builder calls: keep ownership checks in named application repository methods. Existing `first`, `get_by_id`, `count` and statement APIs remain available and unchanged.
+
+The 0.3.1 artifact is a local candidate until separately published. Dependent candidate packages use a vendored wheel during validation; publish sqlPhilosophy first before replacing their local sources with registry-only dependencies.

{sqlphilosophy-0.2.1 → sqlphilosophy-0.3.3}/pyproject.toml

@@ -81,7 +81,6 @@ exclude_also = [
 
 [tool.mypy]
 python_version = "3.12"
-plugins = ["sqlalchemy.ext.mypy.plugin"]
 warn_unused_ignores = true
 
 [tool.ruff]

sqlphilosophy-0.3.3/src/sqlphilosophy/VERSION

@@ -0,0 +1 @@
+0.3.3

{sqlphilosophy-0.2.1 → sqlphilosophy-0.3.3}/src/sqlphilosophy/_repository_shared.py

@@ -8,6 +8,7 @@ from typing import Any, Literal, cast
 
 from sqlalchemy import func
 from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.sql import SQLColumnExpression
 
 from sqlphilosophy.audit.model import AuditMixin
 from sqlphilosophy.types import PrimaryKey, RowMapping, RowValue, SqlFilter
@@ -112,3 +113,13 @@ def criteria_delete_allowed(criteria: Sequence[SqlFilter]) -> bool:
 def bulk_update_allowed(values: RowMapping) -> bool:
     """True when ``update_where`` has values to apply."""
     return bool(values)
+
+
+def require_lookup_inputs(
+    criteria: Sequence[SqlFilter], columns: Sequence[SQLColumnExpression[object]] | None = None
+) -> None:
+    """Reject accidental unscoped or empty-projection expression lookups."""
+    if not criteria:
+        raise ValueError("lookup criteria must not be empty")
+    if columns is not None and not columns:
+        raise ValueError("lookup projection must not be empty")

{sqlphilosophy-0.2.1 → sqlphilosophy-0.3.3}/src/sqlphilosophy/aio/repository.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import Any, cast
+from typing import Any, SupportsInt, cast
 
 from servicephilosophy import ServiceRepository
 from sqlalchemy import delete, func, select, update
@@ -11,6 +11,7 @@ from sqlalchemy import inspect as sa_inspect
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import DeclarativeBase
 from sqlalchemy.orm.interfaces import LoaderOption
+from sqlalchemy.sql import SQLColumnExpression
 
 from sqlphilosophy._repository_shared import (
     bulk_update_allowed,
@@ -19,6 +20,7 @@ from sqlphilosophy._repository_shared import (
     lookup_not_found_message,
     plan_partial_update,
     require_batch_size,
+    require_lookup_inputs,
     require_mappings_page_limits,
     require_page_and_limit,
     require_single_column_primary_key,
@@ -55,6 +57,11 @@ class AsyncBaseRepository[T: DeclarativeBase, U: AsyncRepositoryFactory](Service
         self._session = session
         self._pk_column = require_single_column_primary_key(model, self.inspect_model(model))
 
+    @property
+    def session(self) -> AsyncSession:
+        """Caller-owned session; exposed for composition ownership checks."""
+        return self._session
+
     @classmethod
     def inspect_model(cls, model: type[DeclarativeBase]) -> Any:
         """Return SQLAlchemy ORM mapper inspection for ``model``."""
@@ -101,7 +108,7 @@ class AsyncBaseRepository[T: DeclarativeBase, U: AsyncRepositoryFactory](Service
     async def scalar_count(self, stmt: SqlSelect, params: SqlBindParams | None = None) -> int:
         """Execute a scalar count/select statement and return ``int``."""
         result = await self._session.execute(stmt, params or {})
-        return int(result.scalar_one())
+        return int(cast("SupportsInt", result.scalar_one()))
 
     async def iter_mappings(self, stmt: SqlSelect, params: SqlBindParams | None = None):
         """Yield each result row as a plain ``dict``."""
@@ -308,20 +315,20 @@ class AsyncBaseRepository[T: DeclarativeBase, U: AsyncRepositoryFactory](Service
         *,
         criteria: Sequence[SqlFilter],
         values: RowMapping,
-        params: SqlBindParams | None = None,
+        params: RowMapping | None = None,
     ) -> int:
         """Bulk UPDATE rows matching ``criteria``; returns affected row count."""
         if not bulk_update_allowed(values):
             return 0
         stmt = update(self.model).where(*criteria).values(**values)
-        result = await self._session.execute(stmt, params or {})
+        result = await self._session.execute(stmt, dict(params) if params is not None else {})
         return cursor_rowcount(result)
 
     async def delete_where(
         self,
         *,
         criteria: Sequence[SqlFilter],
-        params: SqlBindParams | None = None,
+        params: RowMapping | None = None,
     ) -> int:
         """Delete rows matching ``criteria`` via PK lookup + ``delete_many``."""
         if not criteria_delete_allowed(criteria):
@@ -329,7 +336,7 @@ class AsyncBaseRepository[T: DeclarativeBase, U: AsyncRepositoryFactory](Service
         pk_key = self._pk_column.key
         builder = self.statement().select_columns(self._pk_column).where(*criteria)
         if params:
-            builder = builder.with_params(params)
+            builder = builder.with_params(dict(params))
         rows = await builder.mappings().all()
         ids = extract_primary_keys(rows, pk_key)
         return await self.delete_many(ids)
@@ -374,6 +381,34 @@ class AsyncBaseRepository[T: DeclarativeBase, U: AsyncRepositoryFactory](Service
             await self._session.commit()
         return total
 
+    def apply_scope(self, statement: AsyncStatementQueryBuilder[T]) -> AsyncStatementQueryBuilder[T]:
+        """Host override hook, invoked after projection initialization."""
+        return statement
+
+    async def find_entity(self, *, criteria: Sequence[SqlFilter], lock: bool = False) -> T | None:
+        require_lookup_inputs(criteria)
+        query = self.apply_scope(self.statement()).where(*criteria)
+        if lock:
+            query = query.with_for_update()
+        return await query.scalars().first()
+
+    async def find_row(
+        self,
+        *,
+        criteria: Sequence[SqlFilter],
+        columns: Sequence[SQLColumnExpression[object]],
+        lock: bool = False,
+    ) -> RowMapping | None:
+        require_lookup_inputs(criteria, columns)
+        query = self.apply_scope(self.statement().select_columns(*columns)).where(*criteria)
+        if lock:
+            query = query.with_for_update()
+        return await query.mappings().first()
+
+    async def count_scoped(self, *, criteria: Sequence[SqlFilter]) -> int:
+        require_lookup_inputs(criteria)
+        return await self.apply_scope(self.statement().select_entity()).where(*criteria).count()
+
     def statement(self) -> AsyncStatementQueryBuilder[T]:
         """Return a fluent statement builder for reads on this model (default read path)."""
         factory = self.maybe_factory

sqlphilosophy-0.3.3/src/sqlphilosophy/strict.py

@@ -0,0 +1,142 @@
+"""Opt-in, non-coercing row decoders for repository boundaries."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from datetime import date, datetime
+from enum import Enum
+from math import isfinite
+from typing import TypeGuard
+from uuid import UUID
+
+from sqlphilosophy.types import JSONValue
+
+__all__ = [
+    "is_strict_json_value",
+    "strict_row_bool",
+    "strict_row_date",
+    "strict_row_datetime",
+    "strict_row_enum",
+    "strict_row_float",
+    "strict_row_int",
+    "strict_row_json",
+    "strict_row_json_object",
+    "strict_row_optional",
+    "strict_row_str",
+    "strict_row_str_list",
+    "strict_row_uuid",
+]
+
+Row = Mapping[str, object]
+
+
+def _required(row: Row, key: str) -> object:
+    return row[key]
+
+
+def _type_error(key: str, expected: str, value: object) -> TypeError:
+    return TypeError(f"expected strict {expected} for {key!r}, got {type(value).__name__}")
+
+
+def strict_row_int(row: Row, key: str) -> int:
+    value = _required(row, key)
+    if type(value) is not int:
+        raise _type_error(key, "int", value)
+    return value
+
+
+def strict_row_str(row: Row, key: str) -> str:
+    value = _required(row, key)
+    if type(value) is not str:
+        raise _type_error(key, "str", value)
+    return value
+
+
+def strict_row_bool(row: Row, key: str) -> bool:
+    value = _required(row, key)
+    if type(value) is not bool:
+        raise _type_error(key, "bool", value)
+    return value
+
+
+def strict_row_float(row: Row, key: str) -> float:
+    value = _required(row, key)
+    if type(value) is not float or not isfinite(value):
+        raise _type_error(key, "finite float", value)
+    return value
+
+
+def strict_row_datetime(row: Row, key: str) -> datetime:
+    value = _required(row, key)
+    if type(value) is not datetime:
+        raise _type_error(key, "datetime", value)
+    return value
+
+
+def strict_row_date(row: Row, key: str) -> date:
+    value = _required(row, key)
+    if type(value) is not date:
+        raise _type_error(key, "date", value)
+    return value
+
+
+def strict_row_uuid(row: Row, key: str) -> UUID:
+    value = _required(row, key)
+    if not isinstance(value, UUID):
+        raise _type_error(key, "UUID", value)
+    return value
+
+
+def strict_row_enum[EnumT: Enum](row: Row, key: str, enum_type: type[EnumT]) -> EnumT:
+    value = _required(row, key)
+    if isinstance(value, enum_type):
+        return value
+    if type(value) is str:
+        try:
+            return enum_type(value)
+        except ValueError as error:
+            raise _type_error(key, enum_type.__name__, value) from error
+    raise _type_error(key, enum_type.__name__, value)
+
+
+def strict_row_str_list(row: Row, key: str) -> list[str]:
+    value = _required(row, key)
+    if type(value) is not list or not all(type(item) is str for item in value):
+        raise _type_error(key, "list[str]", value)
+    return value
+
+
+def is_strict_json_value(value: object) -> TypeGuard[JSONValue]:
+    if value is None or type(value) in (bool, int, str):
+        return True
+    if type(value) is float:
+        return isfinite(value)
+    if type(value) is list:
+        return all(is_strict_json_value(item) for item in value)
+    if type(value) is dict:
+        return all(type(key) is str and is_strict_json_value(item) for key, item in value.items())
+    return False
+
+
+def strict_row_json(row: Row, key: str) -> JSONValue:
+    value = _required(row, key)
+    if not is_strict_json_value(value):
+        raise _type_error(key, "JSON value", value)
+    return value
+
+
+def strict_row_json_object(row: Row, key: str) -> dict[str, JSONValue]:
+    value = strict_row_json(row, key)
+    if type(value) is not dict:
+        raise _type_error(key, "JSON object", value)
+    return value
+
+
+def strict_row_optional[ValueT](
+    row: Row,
+    key: str,
+    decoder: Callable[[Row, str], ValueT],
+) -> ValueT | None:
+    if key not in row or row[key] is None:
+        return None
+    return decoder(row, key)

{sqlphilosophy-0.2.1 → sqlphilosophy-0.3.3}/src/sqlphilosophy/sync/repository.py

@@ -3,13 +3,14 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import Any, cast
+from typing import Any, SupportsInt, cast
 
 from servicephilosophy import ServiceRepository
 from sqlalchemy import delete, func, select, update
 from sqlalchemy import inspect as sa_inspect
 from sqlalchemy.orm import DeclarativeBase, Session
 from sqlalchemy.orm.interfaces import LoaderOption
+from sqlalchemy.sql import SQLColumnExpression
 
 from sqlphilosophy._repository_shared import (
     bulk_update_allowed,
@@ -17,6 +18,7 @@ from sqlphilosophy._repository_shared import (
     extract_primary_keys,
     lookup_not_found_message,
     require_batch_size,
+    require_lookup_inputs,
     require_page_and_limit,
     require_single_column_primary_key,
 )
@@ -52,6 +54,11 @@ class BaseRepository[T: DeclarativeBase, U: RepositoryFactory](ServiceRepository
         self._session = session
         self._pk_column = require_single_column_primary_key(model, self.inspect_model(model))
 
+    @property
+    def session(self) -> Session:
+        """Caller-owned session; exposed for composition ownership checks."""
+        return self._session
+
     @classmethod
     def inspect_model(cls, model: type[DeclarativeBase]) -> Any:
         """Return SQLAlchemy ORM mapper inspection for ``model``."""
@@ -87,7 +94,7 @@ class BaseRepository[T: DeclarativeBase, U: RepositoryFactory](ServiceRepository
 
     def scalar_count(self, stmt: SqlSelect, params: SqlBindParams | None = None) -> int:
         """Execute a scalar count/select statement and return ``int``."""
-        return int(self._session.execute(stmt, params or {}).scalar_one())
+        return int(cast("SupportsInt", self._session.execute(stmt, params or {}).scalar_one()))
 
     def iter_mappings(self, stmt: SqlSelect, params: SqlBindParams | None = None):
         """Yield each result row as a plain ``dict``."""
@@ -274,20 +281,20 @@ class BaseRepository[T: DeclarativeBase, U: RepositoryFactory](ServiceRepository
         *,
         criteria: Sequence[SqlFilter],
         values: RowMapping,
-        params: SqlBindParams | None = None,
+        params: RowMapping | None = None,
     ) -> int:
         """Bulk UPDATE rows matching ``criteria``; returns affected row count."""
         if not bulk_update_allowed(values):
             return 0
         stmt = update(self.model).where(*criteria).values(**values)
-        result = self._session.execute(stmt, params or {})
+        result = self._session.execute(stmt, dict(params) if params is not None else {})
         return cursor_rowcount(result)
 
     def delete_where(
         self,
         *,
         criteria: Sequence[SqlFilter],
-        params: SqlBindParams | None = None,
+        params: RowMapping | None = None,
     ) -> int:
         """Delete rows matching ``criteria`` via PK lookup + ``delete_many``."""
         if not criteria_delete_allowed(criteria):
@@ -295,7 +302,7 @@ class BaseRepository[T: DeclarativeBase, U: RepositoryFactory](ServiceRepository
         pk_key = self._pk_column.key
         builder = self.statement().select_columns(self._pk_column).where(*criteria)
         if params:
-            builder = builder.with_params(params)
+            builder = builder.with_params(dict(params))
         rows = builder.mappings().all()
         ids = extract_primary_keys(rows, pk_key)
         return self.delete_many(ids)
@@ -334,6 +341,34 @@ class BaseRepository[T: DeclarativeBase, U: RepositoryFactory](ServiceRepository
             self._session.commit()
         return total
 
+    def apply_scope(self, statement: StatementQueryBuilder[T]) -> StatementQueryBuilder[T]:
+        """Host override hook, invoked after projection initialization."""
+        return statement
+
+    def find_entity(self, *, criteria: Sequence[SqlFilter], lock: bool = False) -> T | None:
+        require_lookup_inputs(criteria)
+        query = self.apply_scope(self.statement()).where(*criteria)
+        if lock:
+            query = query.with_for_update()
+        return query.scalars().first()
+
+    def find_row(
+        self,
+        *,
+        criteria: Sequence[SqlFilter],
+        columns: Sequence[SQLColumnExpression[object]],
+        lock: bool = False,
+    ) -> RowMapping | None:
+        require_lookup_inputs(criteria, columns)
+        query = self.apply_scope(self.statement().select_columns(*columns)).where(*criteria)
+        if lock:
+            query = query.with_for_update()
+        return query.mappings().first()
+
+    def count_scoped(self, *, criteria: Sequence[SqlFilter]) -> int:
+        require_lookup_inputs(criteria)
+        return self.apply_scope(self.statement().select_entity()).where(*criteria).count()
+
     def statement(self) -> StatementQueryBuilder[T]:
         """Return a fluent statement builder for reads on this model (default read path)."""
         factory = self.maybe_factory

{sqlphilosophy-0.2.1 → sqlphilosophy-0.3.3/src/sqlphilosophy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlphilosophy
-Version: 0.2.1
+Version: 0.3.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
@@ -40,6 +40,8 @@ Dynamic: license-file
 
 # sqlphilosophy
 
+Current source and planned customer-subdomain impact: [current-state summary](docs/current-state-summary.md).
+
 Portable SQLAlchemy repository kit: sync and async CRUD, fluent statement builders, sort/pagination, Core SQL helpers, and optional audit listeners.
 
 | | |
@@ -68,6 +70,8 @@ Portable SQLAlchemy repository kit: sync and async CRUD, fluent statement builde
 - **Repository pattern** for a single mapped model (`BaseRepository`, `AsyncBaseRepository`).
 - **Fluent query builders** with pagination/sort (`StatementQueryBuilder`, `ListQuery`, `SortConfig`).
 - **SQL helpers** for row mapping, partial updates, and developer-defined fragments via **`sqlphilosophy.trusted_sql`**.
+- **Opt-in strict row decoders** via `sqlphilosophy.strict` for non-coercing
+  scalars, timestamps, enums, collections, UUIDs, and recursive JSON.
 - **Optional audit listeners** and timestamp mixins.
 
 ## What this package does not do
@@ -132,6 +136,7 @@ with SessionLocal() as session:
 | `sqlphilosophy` | `__version__` only |
 | `sqlphilosophy.types` | Portable typing aliases |
 | `sqlphilosophy.sql` | Row mapping, partial updates, Core helpers (re-exports `trusted_sql`) |
+| `sqlphilosophy.strict` | Opt-in non-coercing row decoders and strict JSON validation |
 | `sqlphilosophy.trusted_sql` | Developer-trusted SQL fragments — see [SECURITY.md](./SECURITY.md) |
 | `sqlphilosophy.sorting` | `ListQuery`, `SortConfig`, `SortSpec` |
 | `sqlphilosophy.sync` / `sqlphilosophy.aio` | Repositories, query builders, factory protocols |
@@ -177,3 +182,11 @@ See [RELEASING.md](./RELEASING.md) for GitHub + PyPI trusted publishing. See [CH
 ## License
 
 MIT — see [LICENSE](./LICENSE).
+
+## Expression lookups and scope overrides (0.3.1)
+
+Both repository bases provide `find_entity(criteria=..., lock=False)`, `find_row(criteria=..., columns=..., lock=False)` and `count_scoped(criteria=...)`. Criteria must not be empty; projected lookups also require columns. Entity lookups return a mapped object, projected lookups return RowMapping, and absence returns None. These methods never commit.
+
+Override `apply_scope(statement)` for additional predicates on these helpers. It runs after projection initialization, because `select_columns`/`select_entity` reset the builder's SELECT. This hook does not implicitly scope existing CRUD helpers or arbitrary builder calls: keep ownership checks in named application repository methods. Existing `first`, `get_by_id`, `count` and statement APIs remain available and unchanged.
+
+The 0.3.1 artifact is a local candidate until separately published. Dependent candidate packages use a vendored wheel during validation; publish sqlPhilosophy first before replacing their local sources with registry-only dependencies.

{sqlphilosophy-0.2.1 → sqlphilosophy-0.3.3}/src/sqlphilosophy.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/sqlphilosophy/_repository_shared.py
 src/sqlphilosophy/py.typed
 src/sqlphilosophy/sorting.py
 src/sqlphilosophy/sql.py
+src/sqlphilosophy/strict.py
 src/sqlphilosophy/trusted_sql.py
 src/sqlphilosophy/types.py
 src/sqlphilosophy.egg-info/PKG-INFO

sqlphilosophy-0.2.1/src/sqlphilosophy/VERSION

@@ -1 +0,0 @@
-0.2.1