lightly-studio 0.4.6__py3-none-any.whl

lightly_studio/resolvers/video_frame_resolver/get_table_fields_bounds.py

@@ -0,0 +1,44 @@
+"""Retrieve the minimum and maximum values of each video frame table field."""
+
+from __future__ import annotations
+
+from typing import Any
+from uuid import UUID
+
+from sqlalchemy import Select, select
+from sqlmodel import Session, col, func
+
+from lightly_studio.models.range import IntRange
+from lightly_studio.models.sample import SampleTable
+from lightly_studio.models.video import (
+    VideoFrameFieldsBoundsView,
+    VideoFrameTable,
+)
+
+
+def get_table_fields_bounds(
+    session: Session,
+    dataset_id: UUID,
+) -> VideoFrameFieldsBoundsView | None:
+    """Find the minimum and maximum values (bounds) of the video frames fields.
+
+    This includes frame number.
+    """
+    query: Select[tuple[Any, ...]] = (
+        select(
+            func.min(VideoFrameTable.frame_number).label("min_frame_number"),
+            func.max(VideoFrameTable.frame_number).label("max_frame_number"),
+        )
+        .join(SampleTable)
+        .where(col(SampleTable.dataset_id) == dataset_id)
+    )
+
+    result = session.execute(query).mappings().one()
+
+    ## If the min_frame_number is empty, then no data is found.
+    if result["min_frame_number"] is None:
+        return None
+
+    return VideoFrameFieldsBoundsView(
+        frame_number=IntRange(min=result["min_frame_number"], max=result["max_frame_number"]),
+    )

lightly_studio/resolvers/video_frame_resolver/video_frame_annotations_counter_filter.py

@@ -0,0 +1,47 @@
+"""Utility functions for building database queries."""
+
+from typing import List, Optional
+
+from pydantic import BaseModel
+from sqlmodel import col, select
+
+from lightly_studio.models.annotation.annotation_base import AnnotationBaseTable
+from lightly_studio.models.annotation_label import AnnotationLabelTable
+from lightly_studio.models.video import VideoFrameTable
+from lightly_studio.resolvers.video_frame_resolver.video_frame_filter import VideoFrameFilter
+from lightly_studio.type_definitions import QueryType
+
+
+class VideoFrameAnnotationsCounterFilter(BaseModel):
+    """Encapsulates filter parameters for querying video frame annotations counter."""
+
+    video_filter: Optional[VideoFrameFilter] = None
+    annotations_labels: Optional[List[str]] = None
+
+    def apply(self, query: QueryType) -> QueryType:
+        """Apply the filters to the given query."""
+        query = self._apply_annotations_label(query)
+
+        if self.video_filter:
+            query = self.video_filter.apply(query)
+
+        return query
+
+    def _apply_annotations_label(self, query: QueryType) -> QueryType:
+        if not self.annotations_labels:
+            return query
+
+        frame_filtered_video_ids_subquery = (
+            select(VideoFrameTable.sample_id)
+            .join(
+                AnnotationBaseTable,
+                col(AnnotationBaseTable.parent_sample_id) == VideoFrameTable.sample_id,
+            )
+            .join(AnnotationBaseTable.annotation_label)
+            .where(
+                col(AnnotationLabelTable.annotation_label_name).in_(self.annotations_labels or [])
+            )
+            .distinct()
+        )
+
+        return query.where(col(VideoFrameTable.sample_id).in_(frame_filtered_video_ids_subquery))

lightly_studio/resolvers/video_frame_resolver/video_frame_filter.py

@@ -0,0 +1,57 @@
+"""Utility functions for building database queries."""
+
+from typing import Optional
+from uuid import UUID
+
+from pydantic import BaseModel
+from sqlmodel import col
+
+from lightly_studio.models.video import VideoFrameTable, VideoTable
+from lightly_studio.resolvers.image_filter import FilterDimensions
+from lightly_studio.resolvers.sample_resolver.sample_filter import SampleFilter
+from lightly_studio.type_definitions import QueryType
+
+
+class VideoFrameFilter(BaseModel):
+    """Encapsulates filter parameters for querying video frames."""
+
+    frame_number: Optional[FilterDimensions] = None
+    video_id: Optional[UUID] = None
+    sample_filter: Optional[SampleFilter] = None
+
+    def apply(self, query: QueryType) -> QueryType:
+        """Apply the filters to the given query."""
+        query = self._apply_frame_number_filters(query)
+        query = self._apply_video_id(query)
+
+        if self.sample_filter:
+            query = self.sample_filter.apply(query)
+
+        return query
+
+    def _apply_video_id(self, query: QueryType) -> QueryType:
+        if self.video_id:
+            return query.where(col(VideoTable.sample_id) == self.video_id)
+
+        return query
+
+    def _apply_frame_number_filters(self, query: QueryType) -> QueryType:
+        min_frame_number = (
+            self.frame_number.min
+            if self.frame_number and self.frame_number.min is not None
+            else None
+        )
+
+        max_frame_number = (
+            self.frame_number.max
+            if self.frame_number and self.frame_number.max is not None
+            else None
+        )
+
+        if min_frame_number is not None:
+            query = query.where(col(VideoFrameTable.frame_number) >= min_frame_number)
+
+        if max_frame_number is not None:
+            query = query.where(col(VideoFrameTable.frame_number) <= max_frame_number)
+
+        return query

lightly_studio/resolvers/video_resolver/__init__.py

@@ -0,0 +1,27 @@
+"""Resolvers for video database operations."""
+
+from lightly_studio.resolvers.video_resolver.count_video_frame_annotations_by_video_dataset import (
+    count_video_frame_annotations_by_video_dataset,
+)
+from lightly_studio.resolvers.video_resolver.create_many import create_many
+from lightly_studio.resolvers.video_resolver.filter_new_paths import filter_new_paths
+from lightly_studio.resolvers.video_resolver.get_all_by_dataset_id import (
+    get_all_by_dataset_id,
+    get_all_by_dataset_id_with_frames,
+)
+from lightly_studio.resolvers.video_resolver.get_by_id import get_by_id
+from lightly_studio.resolvers.video_resolver.get_table_fields_bounds import (
+    get_table_fields_bounds,
+)
+from lightly_studio.resolvers.video_resolver.get_view_by_id import get_view_by_id
+
+__all__ = [
+    "count_video_frame_annotations_by_video_dataset",
+    "create_many",
+    "filter_new_paths",
+    "get_all_by_dataset_id",
+    "get_all_by_dataset_id_with_frames",
+    "get_by_id",
+    "get_table_fields_bounds",
+    "get_view_by_id",
+]

lightly_studio/resolvers/video_resolver/count_video_frame_annotations_by_video_dataset.py

@@ -0,0 +1,86 @@
+"""Count video frame annotations by video dataset."""
+
+from typing import Any, List, Optional, Tuple
+from uuid import UUID
+
+from pydantic import BaseModel
+from sqlmodel import Session, asc, col, func, select
+from sqlmodel.sql.expression import Select
+
+from lightly_studio.models.annotation.annotation_base import AnnotationBaseTable
+from lightly_studio.models.annotation_label import AnnotationLabelTable
+from lightly_studio.models.sample import SampleTable
+from lightly_studio.models.video import VideoFrameTable, VideoTable
+from lightly_studio.resolvers.video_resolver.video_count_annotations_filter import (
+    VideoCountAnnotationsFilter,
+)
+
+
+class CountAnnotationsView(BaseModel):
+    """Count annotations view."""
+
+    label_name: str
+    total_count: int
+    current_count: int
+
+
+def count_video_frame_annotations_by_video_dataset(
+    session: Session, dataset_id: UUID, filters: Optional[VideoCountAnnotationsFilter] = None
+) -> List[CountAnnotationsView]:
+    """Count the annotations by video frames."""
+    unfiltered_query = (
+        _build_base_query(dataset_id=dataset_id, count_column_name="total")
+        .group_by(col(AnnotationBaseTable.annotation_label_id))
+        .subquery("unfiltered")
+    )
+    filtered_query = _build_base_query(dataset_id=dataset_id, count_column_name="filtered_count")
+
+    if filters:
+        filtered_query = filters.apply(filtered_query)
+
+    filtered_subquery = filtered_query.group_by(
+        col(AnnotationBaseTable.annotation_label_id)
+    ).subquery("filtered")
+
+    final_query: Select[Any] = (
+        select(
+            col(AnnotationLabelTable.annotation_label_name).label("label"),
+            col(unfiltered_query.c.total).label("total"),
+            func.coalesce(filtered_subquery.c.filtered_count, 0).label("filtered_count"),
+        )
+        .select_from(AnnotationLabelTable)
+        .join(
+            unfiltered_query,
+            unfiltered_query.c.label_id == col(AnnotationLabelTable.annotation_label_id),
+        )
+        .outerjoin(
+            filtered_subquery,
+            filtered_subquery.c.label_id == col(AnnotationLabelTable.annotation_label_id),
+        )
+        .order_by(asc(AnnotationLabelTable.annotation_label_name))
+    )
+
+    rows = session.execute(final_query).mappings().all()
+    return [
+        CountAnnotationsView(
+            label_name=row["label"], total_count=row["total"], current_count=row["filtered_count"]
+        )
+        for row in rows
+    ]
+
+
+def _build_base_query(dataset_id: UUID, count_column_name: str) -> Select[Tuple[Any, int]]:
+    return (
+        select(
+            col(AnnotationBaseTable.annotation_label_id).label("label_id"),
+            func.count(func.distinct(VideoTable.sample_id)).label(count_column_name),
+        )
+        .select_from(AnnotationBaseTable)
+        .join(
+            VideoFrameTable,
+            col(VideoFrameTable.sample_id) == col(AnnotationBaseTable.parent_sample_id),
+        )
+        .join(SampleTable, col(SampleTable.sample_id) == col(VideoFrameTable.parent_sample_id))
+        .join(VideoTable, col(VideoTable.sample_id) == col(SampleTable.sample_id))
+        .where(col(SampleTable.dataset_id) == dataset_id)
+    )

lightly_studio/resolvers/video_resolver/create_many.py

@@ -0,0 +1,58 @@
+"""Implementation of create functions for videos."""
+
+from __future__ import annotations
+
+from uuid import UUID
+
+from sqlmodel import Session
+
+from lightly_studio.models.dataset import SampleType
+from lightly_studio.models.sample import SampleCreate
+from lightly_studio.models.video import VideoCreate, VideoTable
+from lightly_studio.resolvers import dataset_resolver, sample_resolver
+
+
+class VideoCreateHelper(VideoCreate):
+    """Helper class to create VideoTable with sample_id."""
+
+    sample_id: UUID
+
+
+def create_many(session: Session, dataset_id: UUID, samples: list[VideoCreate]) -> list[UUID]:
+    """Create multiple video samples in a single database commit.
+
+    Args:
+        session: The database session.
+        dataset_id: The uuid of the dataset to attach to.
+        samples: The videos to create in the database.
+
+    Returns:
+        List of IDs of VideoTable entries that got added to the database.
+    """
+    dataset_resolver.check_dataset_type(
+        session=session,
+        dataset_id=dataset_id,
+        expected_type=SampleType.VIDEO,
+    )
+    sample_ids = sample_resolver.create_many(
+        session=session,
+        samples=[SampleCreate(dataset_id=dataset_id) for _ in samples],
+    )
+    # Bulk create VideoTable entries using the generated sample_ids.
+    db_videos = [
+        VideoTable.model_validate(
+            VideoCreateHelper(
+                file_name=sample.file_name,
+                width=sample.width,
+                height=sample.height,
+                duration_s=sample.duration_s,
+                fps=sample.fps,
+                file_path_abs=sample.file_path_abs,
+                sample_id=sample_id,
+            )
+        )
+        for sample_id, sample in zip(sample_ids, samples)
+    ]
+    session.bulk_save_objects(db_videos)
+    session.commit()
+    return sample_ids

lightly_studio/resolvers/video_resolver/filter_new_paths.py

@@ -0,0 +1,33 @@
+"""Implementation of filter_new_paths function for videos."""
+
+from __future__ import annotations
+
+from sqlmodel import Session, col, select
+
+from lightly_studio.models.video import VideoTable
+
+
+# TODO(Horatiu, 11/2025): Add dataset_id parameter to support multiple datasets.
+def filter_new_paths(session: Session, file_paths_abs: list[str]) -> tuple[list[str], list[str]]:
+    """Filter the file_paths into existing in DB and non existing in DB.
+
+    Args:
+        session: The database session.
+        file_paths_abs: The file paths to filter.
+
+    Returns:
+        file_paths_abs that don't exist in the database,
+        file_paths_abs that exist in the database
+    """
+    existing_file_paths_abs = set(
+        session.exec(
+            select(col(VideoTable.file_path_abs)).where(
+                col(VideoTable.file_path_abs).in_(file_paths_abs)
+            )
+        ).all()
+    )
+    file_paths_abs_set = set(file_paths_abs)
+    return (
+        list(file_paths_abs_set - existing_file_paths_abs),  # paths that are not in the DB
+        list(file_paths_abs_set & existing_file_paths_abs),  # paths that are in the DB
+    )

lightly_studio/resolvers/video_resolver/get_all_by_dataset_id.py

@@ -0,0 +1,181 @@
+"""Implementation of get_all_by_dataset_id function for videos."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from uuid import UUID
+
+from sqlalchemy import and_
+from sqlalchemy.orm import joinedload, selectinload
+from sqlmodel import Session, col, func, select
+
+from lightly_studio.api.routes.api.frame import build_frame_view
+from lightly_studio.api.routes.api.validators import Paginated
+from lightly_studio.models.embedding_model import EmbeddingModelTable
+from lightly_studio.models.sample import SampleTable, SampleView
+from lightly_studio.models.sample_embedding import SampleEmbeddingTable
+from lightly_studio.models.video import (
+    VideoFrameTable,
+    VideoTable,
+    VideoView,
+    VideoViewsWithCount,
+)
+from lightly_studio.resolvers.video_resolver.video_filter import VideoFilter
+
+
+def get_all_by_dataset_id(  # noqa: PLR0913
+    session: Session,
+    dataset_id: UUID,
+    pagination: Paginated | None = None,
+    sample_ids: list[UUID] | None = None,
+    filters: VideoFilter | None = None,
+    text_embedding: list[float] | None = None,
+) -> VideoViewsWithCount:
+    """Retrieve samples for a specific dataset with optional filtering."""
+    # Subquery to find the minimum frame_number for each video
+    min_frame_subquery = (
+        select(
+            VideoFrameTable.parent_sample_id,
+            func.min(col(VideoFrameTable.frame_number)).label("min_frame_number"),
+        )
+        .group_by(col(VideoFrameTable.parent_sample_id))
+        .subquery()
+    )
+    # TODO(Horatiu, 11/2025): Check if it is possible to optimize this query.
+    # Query to get videos with their first frame (frame with min frame_number)
+    # First join the subquery to VideoTable, then join VideoFrameTable
+    samples_query = (
+        select(VideoTable, VideoFrameTable)
+        .join(VideoTable.sample)
+        .outerjoin(
+            min_frame_subquery,
+            min_frame_subquery.c.parent_sample_id == VideoTable.sample_id,
+        )
+        .outerjoin(
+            VideoFrameTable,
+            and_(
+                col(VideoFrameTable.parent_sample_id) == col(VideoTable.sample_id),
+                col(VideoFrameTable.frame_number) == min_frame_subquery.c.min_frame_number,
+            ),
+        )
+        .where(SampleTable.dataset_id == dataset_id)
+        .options(
+            selectinload(VideoFrameTable.sample).options(
+                joinedload(SampleTable.tags),
+                # Ignore type checker error - false positive from TYPE_CHECKING.
+                joinedload(SampleTable.metadata_dict),  # type: ignore[arg-type]
+                selectinload(SampleTable.captions),
+            ),
+            selectinload(VideoTable.sample).options(
+                joinedload(SampleTable.tags),
+                # Ignore type checker error - false positive from TYPE_CHECKING.
+                joinedload(SampleTable.metadata_dict),  # type: ignore[arg-type]
+                selectinload(SampleTable.captions),
+            ),
+        )
+    )
+
+    total_count_query = (
+        select(func.count())
+        .select_from(VideoTable)
+        .join(VideoTable.sample)
+        .where(SampleTable.dataset_id == dataset_id)
+    )
+
+    if text_embedding:
+        # Fetch the first embedding_model_id for the given dataset_id
+        embedding_model_id = session.exec(
+            select(EmbeddingModelTable.embedding_model_id)
+            .where(EmbeddingModelTable.dataset_id == dataset_id)
+            .limit(1)
+        ).first()
+
+    if text_embedding and embedding_model_id:
+        # Join with SampleEmbedding table to access embeddings
+        samples_query = (
+            samples_query.join(
+                SampleEmbeddingTable,
+                col(VideoTable.sample_id) == col(SampleEmbeddingTable.sample_id),
+            )
+            .where(SampleEmbeddingTable.embedding_model_id == embedding_model_id)
+            .order_by(
+                func.list_cosine_distance(
+                    SampleEmbeddingTable.embedding,
+                    text_embedding,
+                )
+            )
+        )
+        total_count_query = total_count_query.join(
+            SampleEmbeddingTable,
+            col(VideoTable.sample_id) == col(SampleEmbeddingTable.sample_id),
+        ).where(SampleEmbeddingTable.embedding_model_id == embedding_model_id)
+    else:
+        samples_query = samples_query.order_by(col(VideoTable.file_path_abs).asc())
+
+    if sample_ids:
+        samples_query = samples_query.where(col(VideoTable.sample_id).in_(sample_ids))
+        total_count_query = total_count_query.where(col(VideoTable.sample_id).in_(sample_ids))
+
+    if filters:
+        samples_query = filters.apply(samples_query)
+        total_count_query = filters.apply(total_count_query)
+
+    samples_query = samples_query.order_by(col(VideoTable.file_path_abs).asc())
+
+    # Apply pagination if provided
+    if pagination is not None:
+        samples_query = samples_query.offset(pagination.offset).limit(pagination.limit)
+
+    total_count = session.exec(total_count_query).one()
+
+    next_cursor = None
+    if pagination and pagination.offset + pagination.limit < total_count:
+        next_cursor = pagination.offset + pagination.limit
+
+    # Fetch videos with their first frames and convert to VideoView
+    results = session.exec(samples_query).all()
+    video_views = [
+        convert_video_table_to_view(video=video, first_frame=first_frame)
+        for video, first_frame in results
+    ]
+
+    return VideoViewsWithCount(
+        samples=video_views,
+        total_count=total_count,
+        next_cursor=next_cursor,
+    )
+
+
+# TODO(Horatiu, 11/2025): This should be deleted when we have proper way of getting all frames for
+# a video.
+def get_all_by_dataset_id_with_frames(
+    session: Session,
+    dataset_id: UUID,
+) -> Sequence[VideoTable]:
+    """Retrieve video table with all the samples."""
+    samples_query = (
+        select(VideoTable).join(VideoTable.sample).where(SampleTable.dataset_id == dataset_id)
+    )
+    samples_query = samples_query.order_by(col(VideoTable.file_path_abs).asc())
+    return session.exec(samples_query).all()
+
+
+def convert_video_table_to_view(
+    video: VideoTable, first_frame: VideoFrameTable | None
+) -> VideoView:
+    """Convert VideoTable to VideoView with only the first frame."""
+    first_frame_view = None
+    if first_frame:
+        first_frame_view = build_frame_view(first_frame)
+
+    return VideoView(
+        width=video.width,
+        height=video.height,
+        duration_s=video.duration_s,
+        fps=video.fps,
+        file_name=video.file_name,
+        file_path_abs=video.file_path_abs,
+        sample_id=video.sample_id,
+        sample=SampleView.model_validate(video.sample),
+        frame=first_frame_view,
+    )

lightly_studio/resolvers/video_resolver/get_by_id.py

@@ -0,0 +1,22 @@
+"""Find a video by its id."""
+
+from __future__ import annotations
+
+from uuid import UUID
+
+from sqlmodel import Session, select
+
+from lightly_studio.models.video import VideoTable
+
+
+def get_by_id(session: Session, sample_id: UUID) -> VideoTable | None:
+    """Retrieve a single video sample by ID.
+
+    Args:
+        session: The database session.
+        sample_id: The ID of the video to retrieve.
+
+    Returns:
+        A VideoTable object or none.
+    """
+    return session.exec(select(VideoTable).where(VideoTable.sample_id == sample_id)).one()

lightly_studio/resolvers/video_resolver/get_table_fields_bounds.py

@@ -0,0 +1,72 @@
+"""Retrieve the minimum and maximum values of each video table field."""
+
+from __future__ import annotations
+
+from typing import Any
+from uuid import UUID
+
+from sqlalchemy import Select, select
+from sqlmodel import Session, col, func
+
+from lightly_studio.models.annotation.annotation_base import AnnotationBaseTable
+from lightly_studio.models.range import FloatRange, IntRange
+from lightly_studio.models.sample import SampleTable
+from lightly_studio.models.video import (
+    VideoFieldsBoundsView,
+    VideoFrameTable,
+    VideoTable,
+)
+
+
+def get_table_fields_bounds(
+    session: Session, dataset_id: UUID, annotations_frames_labels_id: list[UUID] | None = None
+) -> VideoFieldsBoundsView | None:
+    """Find the minimum and maximum values (bounds) of the video fields.
+
+    This includes fps, width, height, and duration. If annotation label
+    filters are provided, only videos containing those annotations are
+    considered.
+    """
+    query: Select[tuple[Any, ...]] = select(
+        func.min(VideoTable.width).label("min_width"),
+        func.max(VideoTable.width).label("max_width"),
+        func.min(VideoTable.height).label("min_height"),
+        func.max(VideoTable.height).label("max_height"),
+        func.min(VideoTable.duration_s).label("min_duration_s"),
+        func.max(VideoTable.duration_s).label("max_duration_s"),
+        func.min(VideoTable.fps).label("min_fps"),
+        func.max(VideoTable.fps).label("max_fps"),
+    )
+
+    query = query.join(SampleTable)
+
+    if annotations_frames_labels_id:
+        annotation_video_ids_subquery = (
+            select(col(VideoTable.sample_id))
+            .select_from(VideoTable)
+            .join(VideoFrameTable)
+            .join(SampleTable, col(SampleTable.sample_id) == col(VideoFrameTable.sample_id))
+            .join(
+                AnnotationBaseTable,
+                col(AnnotationBaseTable.parent_sample_id) == col(SampleTable.sample_id),
+            )
+            .where(col(AnnotationBaseTable.annotation_label_id).in_(annotations_frames_labels_id))
+            .distinct()
+        )
+
+        query = query.where(col(VideoTable.sample_id).in_(annotation_video_ids_subquery))
+
+    query = query.where(col(SampleTable.dataset_id) == dataset_id)
+
+    result = session.execute(query).mappings().one()
+
+    ## If the min_width is empty, then no data is found.
+    if result["min_width"] is None:
+        return None
+
+    return VideoFieldsBoundsView(
+        width=IntRange(min=result["min_width"], max=result["max_width"]),
+        height=IntRange(min=result["min_height"], max=result["max_height"]),
+        duration_s=FloatRange(min=result["min_duration_s"], max=result["max_duration_s"]),
+        fps=FloatRange(min=result["min_fps"], max=result["max_fps"]),
+    )

lightly_studio/resolvers/video_resolver/get_view_by_id.py

@@ -0,0 +1,52 @@
+"""Find a video view by its id."""
+
+from __future__ import annotations
+
+from uuid import UUID
+
+from sqlalchemy import and_
+from sqlmodel import Session, col, func, select
+
+from lightly_studio.models.video import VideoFrameTable, VideoTable, VideoView
+from lightly_studio.resolvers.video_resolver.get_all_by_dataset_id import (
+    convert_video_table_to_view,
+)
+
+
+def get_view_by_id(session: Session, sample_id: UUID) -> VideoView | None:
+    """Retrieve a video view by its ID.
+
+    Args:
+        session: The database session.
+        sample_id: The ID of the video to retrieve.
+
+    Returns:
+        A VideoView object or none.
+    """
+    min_frame_subquery = (
+        select(
+            VideoFrameTable.parent_sample_id,
+            func.min(VideoFrameTable.frame_number).label("min_frame_number"),
+        )
+        .group_by(col(VideoFrameTable.parent_sample_id))
+        .subquery()
+    )
+
+    query = (
+        select(VideoTable, VideoFrameTable)
+        .outerjoin(
+            min_frame_subquery,
+            min_frame_subquery.c.parent_sample_id == VideoTable.sample_id,
+        )
+        .outerjoin(
+            VideoFrameTable,
+            and_(
+                col(VideoFrameTable.parent_sample_id) == col(VideoTable.sample_id),
+                col(VideoFrameTable.frame_number) == min_frame_subquery.c.min_frame_number,
+            ),
+        )
+        .where(VideoTable.sample_id == sample_id)
+    )
+
+    video, first_frame = session.exec(query).one()
+    return convert_video_table_to_view(video, first_frame)