Api

class Settings(BaseSettings):
    """
    `anystore` settings management using
    [pydantic-settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/)

    Note:
        All settings can be set via environment variables in uppercase,
        prepending `FTMQ_API_` (except for those with a given prefix)
    """

    model_config = SettingsConfigDict(
        env_prefix="ftmq_api_",
        env_nested_delimiter="_",
        nested_model_default_partial_update=True,
    )

    catalog: str | None = None
    """Catalog uri"""

    store_uri: str = DB_URL
    """ftmq store uri"""

    build_api_key: str = "secret-key-for-build"
    """Backend api key to use for build process (higher limit)"""

    min_search_length: int = 3
    """Minimum search query length"""

    use_cache: bool = False
    """Activate caching"""

    cache: StoreModel = StoreModel(
        uri=".cache", backend_config={"redis_prefix": f"ftmq-api/{__version__}"}
    )
    """Api cache (via anystore)"""

    allowed_origin: list[str] = ["http://localhost:3000"]
    """Allowed origins"""

    default_limit: int = 100
    """Default public pagination limit"""

    info: ApiInfo = ApiInfo()
    """Rendered information on redoc page"""

class View:
    """A wrapper around a store's default [`View`][ftmq.store.base.View] scoped
    to the api's use cases."""

    def __init__(self, dataset: str | None = None) -> None:
        self.store = get_store(dataset)
        self.dataset = dataset
        self.view = self.store.default_view()

    def get_entity(self, entity_id: str, params: "RetrieveParams") -> Entity:
        canonical = self.store.linker.get_canonical(entity_id)
        proxy = self.view.get_entity(canonical)
        if proxy is None:
            # fall back to the original id
            proxy = self.view.get_entity(entity_id)
            if proxy is None:
                raise HTTPException(404, detail=[f"Entity `{entity_id}` not found."])
        if params.dehydrate:
            return get_dehydrated_entity(proxy)
        if params.featured:
            return get_featured_entity(proxy)
        return proxy

    def get_entities(self, query: Query, params: "RetrieveParams") -> Entities:
        yield from retrieve_entities(self.view.query(query), params)

    def get_adjacents(self, proxies: Entities) -> set[StatementEntity]:
        return self.view.get_adjacents(proxies)

    def get_adjacent(self, proxy: StatementEntity):
        return self.view.get_adjacent(proxy)

    def stats(self, query: Query | None = None) -> DatasetStats:
        return self.view.stats(query)

    def count(self, query: Query | None = None) -> int:
        return self.view.count(query)

    def aggregations(self, query: Query) -> AggregatorResult | None:
        return self.view.aggregations(query)

class EntitiesResponse(BaseModel):
    """The list / search response, matching the OpenAleph api v2 envelope."""

    status: str = "ok"
    results: list[EntityResponse] = []
    total: int = 0
    total_type: str = "eq"
    page: int = 1
    pages: int = 0
    limit: int = 0
    offset: int = 0
    next: str | None = None
    previous: str | None = None
    facets: dict[str, Any] = {}
    metrics: dict[str, Any] = {}
    filters: dict[str, list[str]] = {}
    query_q: str | None = None
    # ftmq extensions (additive; Aleph clients ignore extra keys)
    query: dict[str, Any] = {}
    stats: DatasetStats | None = None
    links: dict[str, str] = {}

    @classmethod
    def from_view(
        cls,
        request: Request,
        entities: Entities,
        query: Query,
        stats: DatasetStats | None = None,
        adjacents: Iterable[Entity] | None = None,
        count: int = 0,
        aggregations: AggregatorResult | None = None,
        query_q: str | None = None,
    ) -> Self:
        url = furl(str(request.url))
        results = [EntityResponse.from_entity(e, adjacents) for e in entities]
        total = stats.entity_count if stats else count
        limit, offset = query.limit or 0, query.offset or 0
        response = cls(
            results=results,
            total=total,
            limit=limit,
            offset=offset,
            page=(offset // limit + 1) if limit else 1,
            pages=math.ceil(total / limit) if limit else 0,
            query=query.to_dict(),
            query_q=query_q,
            stats=stats,
            filters=build_filters(query),
            facets=build_facets(aggregations) if aggregations else {},
            metrics=build_metrics(aggregations) if aggregations else {},
        )
        if limit:
            if offset > 0:
                url.args["offset"] = max(0, offset - limit)
                url.args["limit"] = limit
                response.previous = str(url)
            if offset + limit < total:
                url.args["offset"] = offset + limit
                url.args["limit"] = limit
                response.next = str(url)
        return response