sqlphilosophy 0.1.0__py3-none-any.whl

sqlphilosophy/sync/repository.py

@@ -0,0 +1,360 @@
+"""Generic session-bound repository for ORM CRUD."""
+
+from __future__ import annotations
+from collections.abc import Sequence
+from typing import Any
+from sqlalchemy import delete
+from sqlalchemy import func
+from sqlalchemy import inspect as sa_inspect
+from sqlalchemy import select
+from sqlalchemy import update
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.orm import Session
+from sqlalchemy.orm.interfaces import LoaderOption
+from sqlphilosophy.sorting import ListQuery
+from sqlphilosophy.sorting import SortConfig
+from sqlphilosophy.sql import apply_mappings_page
+from sqlphilosophy.sql import delete_by_ids_model
+from sqlphilosophy.sql import partial_update_model
+from sqlphilosophy.sql import rows_mapping
+from sqlphilosophy.sync.protocols import RepositoryFactory
+from sqlphilosophy.sync.query import SqlAlchemyStatementBuilder
+from sqlphilosophy.sync.query import StatementQueryBuilder
+from sqlphilosophy.types import IdList
+from sqlphilosophy.types import PrimaryKey
+from sqlphilosophy.types import RowMapping
+from sqlphilosophy.types import SqlBindParams
+from sqlphilosophy.types import SqlSelect
+
+LoadRelations = Sequence[LoaderOption]
+
+
+class BaseRepository[T: DeclarativeBase]:
+    """Session-scoped CRUD helpers for a single mapped model."""
+
+    def __init__(
+        self,
+        model: type[T],
+        session: Session,
+        factory: RepositoryFactory | None = None,
+    ) -> None:
+        self.model = model
+        self.session = session
+        self._factory = factory
+        pk_cols = self.inspect_model(model).primary_key
+        if len(pk_cols) != 1:
+            raise TypeError(f"{model.__name__} must have a single-column primary key")
+        self._pk_column = pk_cols[0]
+
+    @classmethod
+    def inspect_model(cls, model: type[DeclarativeBase]) -> Any:
+        """Return SQLAlchemy ORM mapper inspection for ``model``."""
+        return sa_inspect(model)
+
+    def inspect(self) -> Any:
+        """Return SQLAlchemy ORM mapper inspection for this repository's model."""
+        return self.inspect_model(self.model)
+
+    def list_table_names(self) -> frozenset[str]:
+        """Return visible table names on the session connection."""
+        return frozenset(sa_inspect(self.session.connection()).get_table_names())
+
+    def has_table(self, table_name: str) -> bool:
+        """True when ``table_name`` exists on the session connection."""
+        return table_name in self.list_table_names()
+
+    def _apply_load_relations(self, stmt: Any, load_relations: LoadRelations | None) -> Any:
+        if load_relations:
+            return stmt.options(*load_relations)
+        return stmt
+
+    def _scalar_result(self, stmt: Any, *, unique: bool = False) -> Any:
+        if unique:
+            return self.session.scalars(stmt).unique()
+        return self.session.scalars(stmt)
+
+    def fetch_statement_mappings(
+        self, stmt: Any, params: RowMapping | None = None
+    ) -> list[RowMapping]:
+        """Execute ``stmt`` and return all rows as mappings."""
+        mapped = self.session.execute(stmt, params or {}).mappings()
+        rows = mapped.all() if hasattr(mapped, "all") else mapped
+        return rows_mapping(rows)
+
+    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())
+
+    def iter_mappings(self, stmt: SqlSelect, params: SqlBindParams | None = None):
+        """Yield each result row as a plain ``dict``."""
+        for row in self.session.execute(stmt, params or {}).mappings():
+            yield dict(row)
+
+    def fetch_mapping_first(
+        self, stmt: SqlSelect, params: SqlBindParams | None = None
+    ) -> RowMapping | None:
+        """Execute ``stmt`` and return the first row as a mapping, or ``None``."""
+        row = self.session.execute(stmt, params or {}).mappings().first()
+        return dict(row) if row is not None else None
+
+    def fetch_mapping_one(self, stmt: SqlSelect, params: SqlBindParams | None = None) -> RowMapping:
+        """Execute ``stmt`` and return exactly one row as a mapping."""
+        return dict(self.session.execute(stmt, params or {}).mappings().one())
+
+    def fetch_mappings_page(
+        self,
+        stmt: Any,
+        *,
+        limit: int,
+        offset: int,
+        params: RowMapping | None = None,
+    ) -> list[RowMapping]:
+        """Execute ``stmt`` with limit/offset; return normalized row mappings."""
+        return apply_mappings_page(
+            self.session,
+            stmt,
+            limit=limit,
+            offset=offset,
+            params=params,
+        )
+
+    def fetch_sorted_mappings(
+        self,
+        stmt: Any,
+        *,
+        list_query: ListQuery,
+        params: RowMapping | None = None,
+        sort: SortConfig | None = None,
+    ) -> list[RowMapping]:
+        """Apply optional sort, then return one page of row mappings."""
+        if sort is not None:
+            stmt = stmt.order_by(*sort.order_clauses(list_query.order_by))
+        return self.fetch_mappings_page(
+            stmt,
+            limit=list_query.limit,
+            offset=list_query.offset,
+            params=params,
+        )
+
+    def get_by_id(
+        self, obj_id: PrimaryKey, load_relations: LoadRelations | None = None
+    ) -> T | None:
+        """Fetch a single record by primary key with optional eager loading."""
+        stmt = select(self.model).where(self._pk_column == obj_id)
+        stmt = self._apply_load_relations(stmt, load_relations)
+        return self.session.scalar(stmt)
+
+    def exists(self, obj_id: PrimaryKey) -> bool:
+        """True when a row exists for the primary key."""
+        return self.get_by_id(obj_id) is not None
+
+    def exists_where(self, **filters: object) -> bool:
+        """True when at least one row matches optional equality filters."""
+        return self.count(**filters) > 0
+
+    def count(self, **filters: object) -> int:
+        """Count rows matching optional equality filters."""
+        stmt = select(func.count()).select_from(self.model)
+        if filters:
+            stmt = stmt.filter_by(**filters)
+        return int(self.session.scalar(stmt) or 0)
+
+    def first(self, load_relations: LoadRelations | None = None, **filters: object) -> T | None:
+        """Return the first row matching filters, with optional eager loading."""
+        stmt = select(self.model).filter_by(**filters).limit(1)
+        stmt = self._apply_load_relations(stmt, load_relations)
+        return self.session.scalar(stmt)
+
+    def get(self, obj_id: PrimaryKey, load_relations: LoadRelations | None = None) -> T:
+        """Fetch a single record by primary key; raise if missing."""
+        obj = self.get_by_id(obj_id, load_relations=load_relations)
+        if obj is None:
+            raise LookupError(f"{self.model.__name__} matching id={obj_id!r} not found")
+        return obj
+
+    def get_many(
+        self, ids: Sequence[PrimaryKey], load_relations: LoadRelations | None = None
+    ) -> Sequence[T]:
+        """Fetch multiple records by primary key."""
+        if not ids:
+            return []
+        stmt = select(self.model).where(self._pk_column.in_(ids))
+        stmt = self._apply_load_relations(stmt, load_relations)
+        return self._scalar_result(stmt, unique=load_relations is not None).all()
+
+    def filter(
+        self,
+        *,
+        page: int = 1,
+        limit: int | None = None,
+        load_relations: LoadRelations | None = None,
+        **filters: object,
+    ) -> Sequence[T]:
+        """Return rows matching optional equality filters, optionally paginated."""
+        if page < 1:
+            raise ValueError("page must be >= 1")
+        if limit is not None and limit < 1:
+            raise ValueError("limit must be >= 1")
+        stmt = select(self.model).filter_by(**filters).order_by(self._pk_column)
+        if limit is not None:
+            stmt = stmt.limit(limit).offset((page - 1) * limit)
+        stmt = self._apply_load_relations(stmt, load_relations)
+        return self._scalar_result(stmt, unique=load_relations is not None).all()
+
+    def get_all(
+        self,
+        *,
+        page: int = 1,
+        limit: int | None = None,
+        load_relations: LoadRelations | None = None,
+    ) -> Sequence[T]:
+        """Fetch records for this model type, optionally paginated by ``page`` and ``limit``."""
+        if page < 1:
+            raise ValueError("page must be >= 1")
+        if limit is not None and limit < 1:
+            raise ValueError("limit must be >= 1")
+        statement = select(self.model).order_by(self._pk_column)
+        if limit is not None:
+            statement = statement.limit(limit).offset((page - 1) * limit)
+        statement = self._apply_load_relations(statement, load_relations)
+        return self._scalar_result(statement, unique=load_relations is not None).all()
+
+    def get_with_join(
+        self,
+        target_model: type[Any],
+        *filter_expressions: Any,
+        join_on: Any = None,
+    ) -> Sequence[tuple[T, Any]]:
+        """Explicit INNER JOIN returning ``(base_row, target_row)`` tuples."""
+        stmt = select(self.model, target_model)
+        if join_on is not None:
+            stmt = stmt.join(target_model, join_on)
+        else:
+            stmt = stmt.join(target_model)  # pragma: no cover
+        if filter_expressions:
+            stmt = stmt.where(*filter_expressions)
+        return self.session.execute(stmt).all()
+
+    def create(self, **fields: object) -> T:
+        """Construct, stage, and flush a new instance."""
+        return self.add(self.model(**fields))
+
+    def get_or_create(
+        self,
+        *,
+        defaults: RowMapping | None = None,
+        **lookup: object,
+    ) -> tuple[T, bool]:
+        """Return ``(instance, created)`` for equality ``lookup`` filters."""
+        existing = self.first(**lookup)
+        if existing is not None:
+            return existing, False
+        payload: RowMapping = {**(defaults or {}), **lookup}
+        return self.create(**payload), True
+
+    def add(self, obj: T) -> T:
+        """Stage a new instance; caller commits in the orchestration layer."""
+        self.session.add(obj)
+        self.session.flush()
+        return obj
+
+    def update_partial(
+        self,
+        obj_id: PrimaryKey,
+        fields: RowMapping,
+        writable: frozenset[str],
+        *,
+        touch_updated_on: bool = False,
+    ) -> int:
+        """Apply a partial update; returns affected row count (0 if none)."""
+        return partial_update_model(
+            self.session,
+            self.model,
+            obj_id,
+            fields,
+            writable,
+            touch_updated_on=touch_updated_on,
+        )
+
+    def update_where(
+        self,
+        *,
+        criteria: Sequence[object],
+        values: RowMapping,
+        params: SqlBindParams | None = None,
+    ) -> int:
+        """Bulk UPDATE rows matching ``criteria``; returns affected row count."""
+        if not values:
+            return 0
+        stmt = update(self.model).where(*criteria).values(**values)
+        result = self.session.execute(stmt, params or {})
+        return int(result.rowcount or 0)
+
+    def delete_where(
+        self,
+        *,
+        criteria: Sequence[object],
+        params: SqlBindParams | None = None,
+    ) -> int:
+        """Delete rows matching ``criteria`` via PK lookup + ``delete_many``."""
+        if not criteria:
+            return 0
+        pk_key = self._pk_column.key
+        builder = self.statement().select_columns(self._pk_column).where(*criteria)
+        if params:
+            builder = builder.with_params(params)
+        rows = builder.mappings().all()
+        ids = [row[pk_key] for row in rows]
+        return self.delete_many(ids)
+
+    def remove(self, obj_id: PrimaryKey) -> bool:
+        """Delete a record by primary key."""
+        statement = delete(self.model).where(self._pk_column == obj_id)
+        result = self.session.execute(statement)
+        return bool(result.rowcount)
+
+    def delete_many(self, ids: IdList) -> int:
+        """Delete multiple records by primary key."""
+        return delete_by_ids_model(self.session, self.model, list(ids))
+
+    def delete_all(self) -> int:
+        """Delete every row for this model. Dev/ops only — prefer ``delete_where`` in app code."""
+        result = self.session.execute(delete(self.model))
+        return int(result.rowcount or 0)
+
+    def batched_purge_ids(
+        self,
+        *,
+        criteria: list[object],
+        batch_size: int,
+    ) -> int:
+        """Delete rows matching ``criteria`` in ``batch_size`` chunks, committing each batch."""
+        pk_key = self._pk_column.key
+        total = 0
+        while True:
+            rows = (
+                self.statement()
+                .select_columns(self._pk_column)
+                .where(*criteria)
+                .limit(batch_size)
+                .mappings()
+                .all()
+            )
+            ids = [row[pk_key] for row in rows]
+            if not ids:
+                break
+            total += self.delete_many(ids)
+            self.session.commit()
+        return total
+
+    def statement(self) -> StatementQueryBuilder[T]:
+        """Return a fluent statement builder for reads on this model (default read path)."""
+        if self._factory is not None:
+            return self._factory.create_statement(self.model)
+        return SqlAlchemyStatementBuilder(self.session, self.model)
+
+    def for_repo[R](self, repo_class: type[R]) -> R:
+        """Return a typed entity repository sharing this session and factory."""
+        if self._factory is None:
+            raise RuntimeError("for_repo() requires a RepositoryFactory")
+        return self._factory.get_repository(repo_class)

sqlphilosophy/types.py

@@ -0,0 +1,61 @@
+"""Portable SQLAlchemy repository typing aliases (PyPI-safe, no app imports)."""
+
+from __future__ import annotations
+from collections.abc import Mapping
+from datetime import date
+from datetime import datetime
+from uuid import UUID
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.sql import ColumnElement
+from sqlalchemy.sql import Select
+from sqlalchemy.sql.selectable import FromClause
+from sqlalchemy.sql.selectable import LateralFromClause
+from sqlalchemy.sql.selectable import ScalarSelect
+from sqlalchemy.sql.selectable import TableClause
+
+__all__ = [
+    "ApiObject",
+    "ApiScalar",
+    "IdList",
+    "JSONObject",
+    "JSONScalar",
+    "JSONValue",
+    "OrmModel",
+    "PrimaryKey",
+    "RowMapping",
+    "RowValue",
+    "SqlBindParams",
+    "SqlFilter",
+    "SqlFilters",
+    "SqlFromClause",
+    "SqlLateral",
+    "SqlOrderColumn",
+    "SqlScalarSubquery",
+    "SqlSelect",
+    "SqlTable",
+]
+
+type JSONScalar = str | int | float | bool | None
+type JSONValue = JSONScalar | list[JSONValue] | dict[str, JSONValue]
+type JSONObject = dict[str, JSONValue]
+
+type ApiScalar = JSONScalar | datetime | date | UUID
+type RowValue = JSONScalar | datetime | date | UUID | bytes | dict[str, RowValue] | list[RowValue]
+type ApiObject = dict[str, RowValue]
+
+type PrimaryKey = int | str | UUID
+type IdList = list[PrimaryKey]
+
+type SqlBindParams = dict[str, RowValue]
+type SqlFilter = ColumnElement[bool]
+type SqlFilters = list[SqlFilter]
+type SqlOrderColumn = ColumnElement[object]
+type SqlSelect = Select[tuple[object, ...]]
+type SqlFromClause = FromClause
+type SqlLateral = LateralFromClause
+type SqlScalarSubquery = ScalarSelect[object]
+type SqlTable = TableClause
+
+type RowMapping = Mapping[str, RowValue]
+
+type OrmModel = type[DeclarativeBase]

sqlphilosophy-0.1.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: sqlphilosophy
+Version: 0.1.0
+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
+Project-URL: Homepage, https://github.com/SignalSafeSoftware/sqlphilosophy
+Project-URL: Repository, https://github.com/SignalSafeSoftware/sqlphilosophy
+Project-URL: Documentation, https://github.com/SignalSafeSoftware/sqlphilosophy#readme
+Project-URL: Issues, https://github.com/SignalSafeSoftware/sqlphilosophy/issues
+Project-URL: Changelog, https://github.com/SignalSafeSoftware/sqlphilosophy/blob/main/CHANGELOG.md
+Keywords: sqlalchemy,repository-pattern,repository,orm,database,pagination,audit,async
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Typing :: Typed
+Requires-Python: <4.0,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy<3,>=2.0
+Provides-Extra: async
+Requires-Dist: greenlet>=3.0; extra == "async"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: aiosqlite>=0.20; extra == "dev"
+Requires-Dist: greenlet>=3.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=6.1; extra == "dev"
+Dynamic: license-file
+
+# sqlphilosophy
+
+Portable SQLAlchemy repository kit for typed CRUD, fluent statement building, sort/pagination, and Core SQL helpers — with explicit sync and async session APIs.
+
+| | |
+|---|---|
+| **PyPI** | [`sqlphilosophy`](https://pypi.org/project/sqlphilosophy/) |
+| **GitHub** | [SignalSafeSoftware/sqlphilosophy](https://github.com/SignalSafeSoftware/sqlphilosophy) |
+| **Import** | `sqlphilosophy` (no root reexports — use explicit submodules below) |
+
+Developed in the [DeliveryPlus](https://github.com/SignalSafeSoftware/DeliveryPlus) monorepo under `libs/sqlphilosophy`; this tree is the publishable package source.
+
+## Install
+
+```bash
+pip install sqlphilosophy
+```
+
+Async ORM (`AsyncSession`) also needs greenlet:
+
+```bash
+pip install sqlphilosophy[async]
+```
+
+Requires Python 3.12+ and SQLAlchemy 2.x.
+
+## Package layout
+
+| Module | Contents |
+|--------|----------|
+| `sqlphilosophy.types` | Portable typing aliases (`RowMapping`, `PrimaryKey`, `SqlFilter`, …) |
+| `sqlphilosophy.sql` | Row mapping helpers, partial updates, Core table helpers, filter builders |
+| `sqlphilosophy.sorting` | `ListQuery`, `SortConfig`, `SortSpec`, pagination/sort resolution |
+| `sqlphilosophy.sync` | Sync `BaseRepository`, `StatementQueryBuilder`, `RepositoryFactory` protocol |
+| `sqlphilosophy.aio` | Async `AsyncBaseRepository`, `AsyncStatementQueryBuilder`, `AsyncRepositoryFactory` |
+| `sqlphilosophy.audit` | Optional SQLAlchemy audit listeners and timestamp mixins |
+
+## Sync usage
+
+```python
+from sqlalchemy.orm import Session
+
+from sqlphilosophy.sorting import ListQuery, SortConfig, SortSpec
+from sqlphilosophy.sql import partial_update_model, row_int
+from sqlphilosophy.sync.protocols import RepositoryFactory
+from sqlphilosophy.sync.repository import BaseRepository
+from sqlphilosophy.sync.query import SqlAlchemyStatementBuilder
+
+# Without a factory — statement() returns SqlAlchemyStatementBuilder directly
+repo = BaseRepository(User, session)
+rows = repo.statement().where(User.active.is_(True)).mappings().all()
+
+# With a factory — statement() and for_repo() delegate to the factory
+repo = BaseRepository(User, session, factory)
+page = repo.statement().fetch_page(ListQuery.from_page(page=1, size=20))
+other = repo.for_repo(OrderRepository)
+```
+
+## Async usage
+
+```python
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from sqlphilosophy.aio.repository import AsyncBaseRepository
+
+repo = AsyncBaseRepository(User, session)
+rows = await repo.statement().where(User.active.is_(True)).mappings().all()
+```
+
+## Audit mixins
+
+```python
+from sqlphilosophy.audit.context import audit_context
+from sqlphilosophy.audit.listener import configure_audit_listeners
+from sqlphilosophy.audit.model import TimestampModel
+
+configure_audit_listeners()
+
+with audit_context(actor_id=42):
+    session.add(MyModel(name="example"))
+    session.flush()
+```
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest
+python -m build
+python -m twine check dist/*
+```
+
+## Releasing
+
+See [RELEASING.md](./RELEASING.md) for GitHub + PyPI trusted publishing.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

sqlphilosophy-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+sqlphilosophy/VERSION,sha256=6d2FB_S_DG9CRY5BrqgzrQvT9hJycjNe7pv01YVB7Wc,6
+sqlphilosophy/__init__.py,sha256=ZyxzTD4IOajt6DKQLYTFAd5FqMZiqARHTqmVatJ8L8I,117
+sqlphilosophy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlphilosophy/sorting.py,sha256=B6FTNj7g08g3MWnoiKpOjKp_b3OLDd4fdVhB48taI3o,3174
+sqlphilosophy/sql.py,sha256=sSxwdR9nybMDdFsCxzMLoDi1bBQtZt-hpUqCSlE3ePw,16605
+sqlphilosophy/types.py,sha256=2ED-HLlymXVUmhjq8sm6Z6MBTxeaELY6f-I2K7mChi0,1754
+sqlphilosophy/aio/__init__.py,sha256=kM_nFV5Gw44MDuBecpXTiYdb0i65wqVC108NA3neQ6s,60
+sqlphilosophy/aio/protocols.py,sha256=4EvHfbahHJO300kUysBKtzl--0_tINliYX0imYGKBo4,901
+sqlphilosophy/aio/query.py,sha256=AkI-SjoGstYB7iVdQYz2We3hdJgnG4l2F0TJvNzF3So,12997
+sqlphilosophy/aio/repository.py,sha256=GbSTFp2EzvHjTrhSml3YL8A-K6Y6Fw4DmnjTXb-lQYM,15664
+sqlphilosophy/audit/__init__.py,sha256=AwN_xJNLVtsc7n_p3Lk485QoVyco4l9pz-K37TOcMnw,70
+sqlphilosophy/audit/context.py,sha256=ckLNvf5g_YqnFui2aDhxXs521DKjLIu1d1GrH3n0h8s,919
+sqlphilosophy/audit/fields.py,sha256=QVf0uC632rFFKzBv1pHoZRLXfq_l7pBfRLWF98zFDyo,625
+sqlphilosophy/audit/listener.py,sha256=0PiCzVXiQKUISZhH2Lhs7KTIb_BD7B1_fs6vGWnnbus,3546
+sqlphilosophy/audit/model.py,sha256=8S9kZdasUzGgV0gUnHnDcEhy4cXTt0NKykghPpETOBk,1839
+sqlphilosophy/sync/__init__.py,sha256=AIxiTARXneNQjb1yEcX_2fI_pCkDMEyVmFPkcVfCig4,59
+sqlphilosophy/sync/protocols.py,sha256=Y8PJmGdeW12H-kfleyA7OvfKnWXypn_KieDalKx6PaE,864
+sqlphilosophy/sync/query.py,sha256=FuuPiLXJfIUyuGqO0D14Adrinqb5sx5f8lw1KN98nuI,12725
+sqlphilosophy/sync/repository.py,sha256=jq8atAGyeuVa1H9bTE6QZODBT6Lj4E-8MeNPrNpYs9w,13792
+sqlphilosophy-0.1.0.dist-info/licenses/LICENSE,sha256=gLXN1zYlPx8WFJGVkSSGrmNEL07Dl7HznSumDZelvio,1063
+sqlphilosophy-0.1.0.dist-info/METADATA,sha256=xq4AhOFxq3yFAmcqnBlcnGk_wUCv1qchZWT8iiAcqTc,4726
+sqlphilosophy-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sqlphilosophy-0.1.0.dist-info/top_level.txt,sha256=sT2j0APcke3yvJP5eQ6PM0kZcePIG-Vf-GR_94aWTcI,14
+sqlphilosophy-0.1.0.dist-info/RECORD,,

sqlphilosophy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sqlphilosophy-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Josh Martin
+
+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.

sqlphilosophy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sqlphilosophy