pythonboot-sqlalchemy 0.1.0__py3-none-any.whl

pythonboot_sqlalchemy/__init__.py

@@ -0,0 +1,13 @@
+"""Public settings and native Session factory names for SQLAlchemy integration."""
+
+from pythonboot_sqlalchemy.pagination import Page, PageQuery, apaginate, paginate
+from pythonboot_sqlalchemy.factories import AsyncSessionFactory, SessionFactory
+from pythonboot_sqlalchemy.properties import (
+    DataSourceProperties, PoolProperties, SessionProperties, SqlAlchemyProperties,
+)
+
+__all__ = [
+    "PageQuery", "Page", "paginate", "apaginate",
+    "AsyncSessionFactory", "SessionFactory", "DataSourceProperties", "PoolProperties",
+    "SessionProperties", "SqlAlchemyProperties",
+]

pythonboot_sqlalchemy/configuration.py

@@ -0,0 +1,77 @@
+"""Register native engines and session factories without implicit commits."""
+
+import logging
+
+from sqlalchemy import Engine, create_engine
+from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
+
+from pythonboot import (
+    auto_configuration, bean, conditional_on_missing_bean, conditional_on_property,
+)
+from pythonboot_sqlalchemy.engine import database_url, engine_options
+from pythonboot_sqlalchemy.factories import AsyncSessionFactory, SessionFactory
+from pythonboot_sqlalchemy.properties import DataSourceProperties, SqlAlchemyProperties
+
+logger = logging.getLogger(__name__)
+
+
+@auto_configuration(order=1900, imports=(DataSourceProperties, SqlAlchemyProperties))
+@conditional_on_property("pythonboot.sqlalchemy.enabled", having_value=True, match_if_missing=True)
+class SqlAlchemyPropertiesAutoConfiguration:
+    """Bind connection and ORM properties before resource auto-configuration."""
+
+
+@auto_configuration(order=2000)
+@conditional_on_property("pythonboot.sqlalchemy.enabled", having_value=True, match_if_missing=True)
+@conditional_on_property("pythonboot.sqlalchemy.mode", having_value="sync")
+class SqlAlchemySyncEngineAutoConfiguration:
+    """Provide an application-owned synchronous engine unless one already exists."""
+
+    @bean(name="sqlAlchemyEngine", destroy_method="dispose")
+    @conditional_on_missing_bean(Engine, "sqlAlchemyEngine")
+    def engine(self, properties: DataSourceProperties, orm: SqlAlchemyProperties) -> Engine:
+        if not orm.enabled or orm.mode != "sync":
+            raise ValueError("SQLAlchemy enabled and mode must be selected in application YAML")
+        logger.info("Creating synchronous SQLAlchemy engine with pool_kind=%s.", properties.pool.kind)
+        return create_engine(database_url(properties), **engine_options(properties, asynchronous=False))
+
+
+@auto_configuration(order=2000)
+@conditional_on_property("pythonboot.sqlalchemy.enabled", having_value=True, match_if_missing=True)
+@conditional_on_property("pythonboot.sqlalchemy.mode", having_value="async", match_if_missing=True)
+class SqlAlchemyAsyncEngineAutoConfiguration:
+    """Provide an application-owned async engine with awaited disposal on shutdown."""
+
+    @bean(name="sqlAlchemyAsyncEngine", destroy_method="dispose")
+    @conditional_on_missing_bean(AsyncEngine, "sqlAlchemyAsyncEngine")
+    def engine(self, properties: DataSourceProperties, orm: SqlAlchemyProperties) -> AsyncEngine:
+        if not orm.enabled or orm.mode != "async":
+            raise ValueError("SQLAlchemy enabled and mode must be selected in application YAML")
+        logger.info("Creating asynchronous SQLAlchemy engine with pool_kind=%s.", properties.pool.kind)
+        return create_async_engine(database_url(properties), **engine_options(properties, asynchronous=True))
+
+
+@auto_configuration(order=2100)
+@conditional_on_property("pythonboot.sqlalchemy.enabled", having_value=True, match_if_missing=True)
+@conditional_on_property("pythonboot.sqlalchemy.mode", having_value="sync")
+class SqlAlchemySyncSessionAutoConfiguration:
+    """Create a native singleton factory; sessions remain explicitly scoped by callers."""
+
+    @bean(name="sqlAlchemySessionFactory")
+    @conditional_on_missing_bean(SessionFactory, "sqlAlchemySessionFactory")
+    def session_factory(self, engine: Engine, properties: SqlAlchemyProperties) -> SessionFactory:
+        logger.info("Creating synchronous SQLAlchemy session factory.")
+        return SessionFactory(bind=engine, **properties.session.model_dump())
+
+
+@auto_configuration(order=2100)
+@conditional_on_property("pythonboot.sqlalchemy.enabled", having_value=True, match_if_missing=True)
+@conditional_on_property("pythonboot.sqlalchemy.mode", having_value="async", match_if_missing=True)
+class SqlAlchemyAsyncSessionAutoConfiguration:
+    """Create a native async factory without sharing sessions across tasks."""
+
+    @bean(name="sqlAlchemyAsyncSessionFactory")
+    @conditional_on_missing_bean(AsyncSessionFactory, "sqlAlchemyAsyncSessionFactory")
+    def session_factory(self, engine: AsyncEngine, properties: SqlAlchemyProperties) -> AsyncSessionFactory:
+        logger.info("Creating asynchronous SQLAlchemy session factory.")
+        return AsyncSessionFactory(bind=engine, **properties.session.model_dump())

pythonboot_sqlalchemy/engine.py

@@ -0,0 +1,43 @@
+"""Build native engine options while preserving dialect and driver selection."""
+
+from typing import Any
+
+from sqlalchemy.pool import AsyncAdaptedQueuePool, NullPool, QueuePool, StaticPool
+
+from pythonboot_sqlalchemy.properties import DataSourceProperties
+
+
+def engine_options(properties: DataSourceProperties, *, asynchronous: bool) -> dict[str, Any]:
+    """Translate declared pool settings without guessing the database driver."""
+    options: dict[str, Any] = {
+        "echo": properties.echo,
+        "hide_parameters": properties.hide_parameters,
+        "connect_args": dict(properties.connect_args),
+        "pool_pre_ping": properties.pool.pre_ping,
+    }
+    if properties.isolation_level is not None:
+        options["isolation_level"] = properties.isolation_level
+    pool = properties.pool
+    if pool.kind == "queue":
+        options["poolclass"] = AsyncAdaptedQueuePool if asynchronous else QueuePool
+    elif pool.kind == "null":
+        options["poolclass"] = NullPool
+    elif pool.kind == "static":
+        options["poolclass"] = StaticPool
+    for name, value in (
+        ("pool_size", pool.size),
+        ("max_overflow", pool.max_overflow),
+        ("pool_timeout", pool.timeout),
+        ("pool_recycle", pool.recycle),
+    ):
+        if value is not None:
+            options[name] = value
+    return options
+
+
+def database_url(properties: DataSourceProperties) -> str:
+    """Require a URL only when the default engine is actually created."""
+    url = properties.url.get_secret_value()
+    if not url.strip():
+        raise ValueError("pythonboot.datasource.url is required for the default SQLAlchemy engine")
+    return url

pythonboot_sqlalchemy/factories.py

@@ -0,0 +1,9 @@
+"""Short names for native session factory classes, compatible with Bean injection."""
+
+from sqlalchemy.ext.asyncio import async_sessionmaker
+from sqlalchemy.orm import sessionmaker
+
+SessionFactory = sessionmaker
+AsyncSessionFactory = async_sessionmaker
+
+__all__ = ["SessionFactory", "AsyncSessionFactory"]

pythonboot_sqlalchemy/pagination.py

@@ -0,0 +1,100 @@
+"""Validated pagination models and native synchronous/asynchronous query helpers."""
+
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar, overload
+
+from pydantic import BaseModel, ConfigDict, Field
+from sqlalchemy import Select, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
+
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+class PageQuery(BaseModel):
+    """One-based pagination request with a default page size of ten."""
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    page: int = Field(default=1, ge=1)
+    pageSize: int = Field(default=10, ge=1)
+
+
+class Page(PageQuery, Generic[T]):
+    """Materialized page containing the matching row count and current rows."""
+
+    model_config = ConfigDict(validate_assignment=True, arbitrary_types_allowed=True)
+
+    total: int = Field(default=0, ge=0)
+    rows: list[T] = Field(default_factory=list)
+
+
+def _queries(statement: Select[Any], query: PageQuery) -> tuple[Select[Any], Select[Any]]:
+    """Count the full selection and apply the requested window without mutating it."""
+    if not isinstance(statement, Select):
+        raise TypeError("Pagination requires a SQLAlchemy Select statement")
+    if len(statement.column_descriptions) != 1:
+        raise ValueError("Pagination requires exactly one selected entity or scalar column")
+    unpaged = statement.limit(None).offset(None).fetch(None)
+    count = select(func.count()).select_from(unpaged.order_by(None).subquery())
+    rows = unpaged.offset((query.page - 1) * query.pageSize).limit(query.pageSize)
+    return count, rows
+
+
+@overload
+def paginate(
+    session: Session, statement: Select[tuple[T]], query: PageQuery | None = None,
+    *, mapper: None = None,
+) -> Page[T]: ...
+
+
+@overload
+def paginate(
+    session: Session, statement: Select[tuple[T]], query: PageQuery | None = None,
+    *, mapper: Callable[[T], R],
+) -> Page[R]: ...
+
+
+def paginate(
+    session: Session, statement: Select[Any], query: PageQuery | None = None,
+    *, mapper: Callable[[Any], Any] | None = None,
+) -> Page[Any]:
+    """Execute count and rows in the caller's Session without committing or closing it."""
+    options = PageQuery.model_validate(query.model_dump() if query is not None else {})
+    count, rows_query = _queries(statement, options)
+    total = session.scalar(count)
+    rows = session.scalars(rows_query).all()
+    return Page(
+        total=total, page=options.page, pageSize=options.pageSize,
+        rows=[mapper(row) for row in rows] if mapper is not None else list(rows),
+    )
+
+
+@overload
+async def apaginate(
+    session: AsyncSession, statement: Select[tuple[T]], query: PageQuery | None = None,
+    *, mapper: None = None,
+) -> Page[T]: ...
+
+
+@overload
+async def apaginate(
+    session: AsyncSession, statement: Select[tuple[T]], query: PageQuery | None = None,
+    *, mapper: Callable[[T], R],
+) -> Page[R]: ...
+
+
+async def apaginate(
+    session: AsyncSession, statement: Select[Any], query: PageQuery | None = None,
+    *, mapper: Callable[[Any], Any] | None = None,
+) -> Page[Any]:
+    """Await count and rows in the caller's AsyncSession without transaction ownership."""
+    options = PageQuery.model_validate(query.model_dump() if query is not None else {})
+    count, rows_query = _queries(statement, options)
+    total = await session.scalar(count)
+    rows = (await session.scalars(rows_query)).all()
+    return Page(
+        total=total, page=options.page, pageSize=options.pageSize,
+        rows=[mapper(row) for row in rows] if mapper is not None else list(rows),
+    )

pythonboot_sqlalchemy/properties.py

@@ -0,0 +1,67 @@
+"""Typed database and ORM settings bound through PythonBoot configuration properties."""
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from pythonboot import configuration_properties
+
+
+class PoolProperties(BaseModel):
+    """Pool options; omitted sizing values retain dialect-specific defaults."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    kind: Literal["default", "queue", "null", "static"] = "default"
+    size: int | None = Field(default=None, ge=1)
+    max_overflow: int | None = Field(default=None, ge=-1)
+    timeout: float | None = Field(default=None, ge=0, allow_inf_nan=False)
+    recycle: int | None = Field(default=None, ge=-1)
+    pre_ping: bool = True
+
+    @model_validator(mode="after")
+    def validate_sizing(self) -> "PoolProperties":
+        if self.kind in ("null", "static") and any(
+            value is not None for value in (self.size, self.max_overflow, self.timeout)
+        ):
+            raise ValueError("Pool sizing options require a queue-compatible pool")
+        return self
+
+
+@configuration_properties("pythonboot.datasource")
+class DataSourceProperties(BaseSettings):
+    """Connection settings shared by default synchronous and asynchronous engines."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="PYTHONBOOT_DATASOURCE_", env_nested_delimiter="__", extra="forbid",
+    )
+
+    url: SecretStr = SecretStr("")
+    echo: bool = False
+    hide_parameters: bool = True
+    isolation_level: str | None = None
+    connect_args: dict[str, Any] = Field(default_factory=dict)
+    pool: PoolProperties = Field(default_factory=PoolProperties)
+
+
+class SessionProperties(BaseModel):
+    """Native sessionmaker options without automatic transaction boundaries."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    expire_on_commit: bool = False
+    autoflush: bool = True
+
+
+@configuration_properties("pythonboot.sqlalchemy")
+class SqlAlchemyProperties(BaseSettings):
+    """ORM settings; mode and enabled select auto-configurations through YAML."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="PYTHONBOOT_SQLALCHEMY_", env_nested_delimiter="__", extra="forbid",
+    )
+
+    enabled: bool = True
+    mode: Literal["sync", "async"] = "async"
+    session: SessionProperties = Field(default_factory=SessionProperties)

pythonboot_sqlalchemy-0.1.0.dist-info/METADATA

@@ -0,0 +1,172 @@
+Metadata-Version: 2.5
+Name: pythonboot-sqlalchemy
+Version: 0.1.0
+Summary: Native SQLAlchemy ORM configuration and lifecycle integration for PythonBoot
+Requires-Python: >=3.12
+Requires-Dist: pydantic-settings<3,>=2.7
+Requires-Dist: pydantic<3,>=2.10
+Requires-Dist: pythonboot<0.2,>=0.1.0
+Requires-Dist: sqlalchemy[asyncio]<3,>=2.0.38
+Description-Content-Type: text/markdown
+
+# pythonboot-sqlalchemy
+
+PythonBoot 的 SQLAlchemy 原生 ORM 实现包。分发名为 `pythonboot-sqlalchemy`，
+导入名为 `pythonboot_sqlalchemy`；应用推荐安装聚合包 `pythonboot-starter-sqlalchemy`。
+
+- 通过 Configuration Properties 绑定 `pythonboot.datasource` 和 `pythonboot.sqlalchemy`。
+- 自动注册同步或异步 Engine 和原生 Session 工厂，应用 Bean 优先。
+- `SessionFactory` 是 `sessionmaker` 的类别名，`AsyncSessionFactory` 是 `async_sessionmaker`
+  的类别名，可直接作为 `autowired()` 注入类型，不增加代理或包装层。
+- Session 由业务创建并关闭；业务显式 `commit()`，需要继续复用失败 Session 时显式 `rollback()`。
+- 不提供 Mapper、自动提交、事务拦截器、自动建表或数据库迁移。
+- 默认 Engine 关闭时调用 `dispose()`；异步关闭由容器等待。
+- 数据库驱动由应用安装，URL 交由 SQLAlchemy 原生解析；未默认安装任何驱动。
+
+不使用 `@transactional` 管理 Session，是为了让 `commit()` 的位置直接出现在业务流程中，
+便于看清和管理事务边界、提交时机及异常处理。在 AI 辅助编写代码的工作流中，
+明确要求生成 Session 作用域和提交逻辑可以降低遗漏提交的概率，显式调用也便于审阅。
+
+```yaml
+pythonboot:
+  datasource:
+    url: postgresql+asyncpg://user:password@localhost:5432/app
+  sqlalchemy:
+    mode: async
+    session:
+      expire_on_commit: false
+      autoflush: true
+```
+
+```python
+from pythonboot import autowired, service
+from pythonboot_sqlalchemy import AsyncSessionFactory
+
+@service
+class UserService:
+    session_factory: AsyncSessionFactory = autowired()
+
+    async def rename(self, user_id: int, name: str) -> None:
+        async with self.session_factory() as session:
+            user = await session.get(User, user_id)
+            if user is None:
+                raise ValueError("User not found")
+            user.name = name
+            await session.commit()
+```
+
+`User` 为应用自定义 SQLAlchemy ORM 模型。多 Service 共享事务时显式传递 Session。
+连接池 Starter 可以提供自己的 Engine Bean（外部连接池适配通常配合 `NullPool`），
+或注册更早装配的自动配置；本模块退让并继续使用原生 Session 工厂。
+用户 Engine 的关闭责任由其 Bean 生命周期声明，外部池由创建方关闭。
+
+完整配置、公共 API、同步用法和多数据源说明见
+[`viteDocs/docs/zh/sqlalchemy.md`](../../viteDocs/docs/zh/sqlalchemy.md)，
+可运行用法示例见 [`examples/sqlalchemy`](../../examples/sqlalchemy/README.md)。
+
+## English
+
+`pythonboot-sqlalchemy` is the implementation distribution; import `pythonboot_sqlalchemy`.
+Install `pythonboot-starter-sqlalchemy` plus your chosen database driver in applications.
+Configuration Properties bind connection and ORM settings. Native Engine and Session factory
+Beans back off to application Beans. Callers explicitly create Sessions and commit changes;
+Session context exit closes resources and rolls back uncommitted transactions.
+There is no Mapper, implicit commit, transaction interceptor, schema creation, or migration.
+Explicit commit points make transaction boundaries and failure handling visible and easier to manage.
+In AI-assisted development, requiring Session scopes and commit logic reduces omissions and makes
+the resulting transaction flow easier to review. This Starter does not use `@transactional` to manage Sessions.
+Short factory names are aliases of native classes, compatible with concrete-class Bean injection.
+The container disposes default engines, awaiting asynchronous disposal. Custom Engine and
+external pool ownership must be declared by their providers.
+See [English documentation](../../viteDocs/docs/en/sqlalchemy.md) and the
+[example](../../examples/sqlalchemy/README.md).
+
+
+完整分层应用见 [全量 Starter 示例](../../example/README.md)，包含全部 Starter、PostgreSQL／Redis 和同步／异步 HTTP 用法。
+See the [complete Starter application](../../example/README.md) for all Starters and sync/async HTTP examples.
+
+
+## 分页查询
+
+`PageQuery` 包含 `page`（默认 1）和 `pageSize`（默认 10），二者必须大于等于 1。
+`Page[T]` 包含相同分页参数，以及 `total`（默认 0）和 `rows: list[T]`（默认空列表）。
+Python 属性与 JSON 字段均使用 `pageSize`，不需要别名转换。
+
+从 `pythonboot_sqlalchemy` 或 `pythonboot_starter_sqlalchemy` 导入这两个模型，以及
+同步 `paginate`、异步 `apaginate`。实现位于实现模块，Starter 只导出公共入口，无新增依赖。
+
+```python
+from sqlalchemy import select
+from pythonboot_starter_sqlalchemy import Page, PageQuery, paginate, apaginate
+
+query = PageQuery(page=1, pageSize=10)
+statement = select(User).where(User.name == "Alice").order_by(User.id)
+
+with session_factory() as session:
+    page = paginate(session, statement, query, mapper=UserView.model_validate)
+
+async with async_session_factory() as session:
+    page = await apaginate(session, statement, query, mapper=UserView.model_validate)
+```
+
+省略 `query` 时使用默认分页；`mapper` 可选，用于在 Session 内将实体转换成 DTO。
+省略 `mapper` 则 `rows` 保留原生实体或标量；调用方应在关闭 Session 前加载所需属性。
+
+封装对传入 Select 生成 COUNT 子查询和 OFFSET／LIMIT 查询，保留过滤、JOIN、DISTINCT、
+GROUP BY 与 HAVING；总数查询移除排序，数据查询保留原排序。原有 LIMIT／OFFSET／FETCH
+由分页参数替换，原 Select 不被修改。无匹配结果或页码超出范围时返回空 `rows`，
+`total` 始终表示完整筛选结果总数，不自动调整页码。请使用包含唯一字段的排序保证分页稳定。
+
+支持只选择一个 ORM 实体或一个标量列的 Select；多列／多实体查询明确报错。
+总数按 SQL 查询结果行统计，JOIN 重复行不自动去重；需要去重时显式使用 DISTINCT。
+需要 `.unique()` 的集合 joined eager loading 不在此封装范围内，可使用 `selectinload`。
+COUNT 与数据查询是两次顺序执行的 SQL，在并发写入时一致性取决于调用方事务隔离级别。
+封装不创建、关闭、提交或回滚 Session，不修改事务边界，异步操作不得并发共享同一 Session。
+
+全量示例提供 `GET /users/page` 和 `GET /sync/users/page`，支持 `page`、`pageSize`、`name` 参数，
+返回 `BaseResult[Page[UserView]]`；原有列表接口保持不变。
+
+
+## Pagination
+
+`PageQuery` has `page` (default 1) and `pageSize` (default 10), both at least 1.
+`Page[T]` adds `total` (default 0) and `rows: list[T]` (an independent empty list by default).
+Python attributes and JSON use the exact field name `pageSize`.
+
+Import both models and the sync `paginate` / async `apaginate` helpers from
+`pythonboot_sqlalchemy` or `pythonboot_starter_sqlalchemy`. Implementation belongs to the module;
+the Starter only re-exports public interfaces. No dependency is added.
+
+```python
+from sqlalchemy import select
+from pythonboot_starter_sqlalchemy import Page, PageQuery, paginate, apaginate
+
+query = PageQuery(page=1, pageSize=10)
+statement = select(User).where(User.name == "Alice").order_by(User.id)
+
+with session_factory() as session:
+    page = paginate(session, statement, query, mapper=UserView.model_validate)
+
+async with async_session_factory() as session:
+    page = await apaginate(session, statement, query, mapper=UserView.model_validate)
+```
+
+Omit `query` to use defaults. The optional `mapper` materializes DTOs within the Session;
+otherwise rows retain native entities or scalar values. Load required attributes before closing.
+
+A COUNT subquery measures the full selection, and an OFFSET/LIMIT query loads the page.
+Filters, joins, DISTINCT, GROUP BY, and HAVING are preserved. Count removes ordering; rows retain it.
+Existing LIMIT/OFFSET/FETCH clauses are replaced by pagination. The original Select is not mutated.
+Empty and out-of-range pages keep the full matching `total`, return empty `rows`, and retain the
+requested page number. Order by a unique key for stable paging.
+
+Select exactly one ORM entity or scalar column; multi-column/entity statements raise an error.
+Totals count SQL result rows, including duplicate join rows; use explicit DISTINCT when needed.
+Collection joined eager loading requiring `.unique()` is outside this helper's scope; use `selectinload`.
+Count and rows execute sequentially as two queries; concurrent-write consistency depends on the
+caller's transaction isolation. Helpers do not create, close, commit, or roll back Sessions.
+Never share an AsyncSession between concurrent tasks.
+
+The complete application exposes `GET /users/page` and `GET /sync/users/page`, accepting
+`page`, `pageSize`, and optional `name`, and returning `BaseResult[Page[UserView]]`.
+Existing list endpoints remain available.

pythonboot_sqlalchemy-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pythonboot_sqlalchemy/__init__.py,sha256=0JEo8XBhcrVDgutC690nsMyZmh8pHt6Tz_mIX2wfNhA,579
+pythonboot_sqlalchemy/configuration.py,sha256=WOixEYQ8-b6YiZjVa7V3d9G7hCUN3ZSfdwJ2rzU0Zrc,4264
+pythonboot_sqlalchemy/engine.py,sha256=2l14Dc6pP0ZOF0sEBqQJmkz_xx_hqDCaBUaU3Po6rMw,1653
+pythonboot_sqlalchemy/factories.py,sha256=SE3hF7MwbihVD6zGugRQrW6Qd0SjkUAWBzUpQyY2wwI,306
+pythonboot_sqlalchemy/pagination.py,sha256=11Op-AIy7OxtsCIzPNff2uQjNiLnCcuahrjYR8Fknkc,3578
+pythonboot_sqlalchemy/properties.py,sha256=EAa3ePjgcZlfJCuLw4otif9Hmt6rvV5youC76Vrvsg8,2405
+pythonboot_sqlalchemy-0.1.0.dist-info/METADATA,sha256=-fBYKMD7QL0Gh0HgobThLOgFL6CeqOgi6PxQa7JSavI,9331
+pythonboot_sqlalchemy-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+pythonboot_sqlalchemy-0.1.0.dist-info/entry_points.txt,sha256=GSuptGaH4dy7RYAhKyxza4mz_ISScR48p09DVVjSHy0,76
+pythonboot_sqlalchemy-0.1.0.dist-info/RECORD,,

pythonboot_sqlalchemy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

pythonboot_sqlalchemy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pythonboot.autoconfigure]
+sqlalchemy = pythonboot_sqlalchemy.configuration