pixeltable 0.4.19__py3-none-any.whl → 0.4.21__py3-none-any.whl

pixeltable/functions/video.py

@@ -6,7 +6,7 @@ import glob
 import logging
 import pathlib
 import subprocess
-from typing import Any, Literal, NoReturn
+from typing import TYPE_CHECKING, Any, Literal, NamedTuple, NoReturn
 
 import av
 import av.stream
@@ -19,6 +19,9 @@ from pixeltable.env import Env
 from pixeltable.utils.code import local_public_names
 from pixeltable.utils.local_store import TempStore
 
+if TYPE_CHECKING:
+    from scenedetect.detectors import SceneDetector  # type: ignore[import-untyped]
+
 _logger = logging.getLogger('pixeltable')
 
 
@@ -936,6 +939,536 @@ def _create_drawtext_params(
     return drawtext_params
 
 
+@pxt.udf(is_method=True)
+def scene_detect_adaptive(
+    video: pxt.Video,
+    *,
+    fps: float | None = None,
+    adaptive_threshold: float = 3.0,
+    min_scene_len: int = 15,
+    window_width: int = 2,
+    min_content_val: float = 15.0,
+    delta_hue: float = 1.0,
+    delta_sat: float = 1.0,
+    delta_lum: float = 1.0,
+    delta_edges: float = 0.0,
+    luma_only: bool = False,
+    kernel_size: int | None = None,
+) -> list[dict]:
+    """
+    Detect scene cuts in a video using PySceneDetect's
+    [AdaptiveDetector](https://www.scenedetect.com/docs/latest/api/detectors.html#scenedetect.detectors.adaptive_detector.AdaptiveDetector).
+
+    __Requirements:__
+
+    - `pip install scenedetect`
+
+    Args:
+        video: The video to analyze for scene cuts.
+        fps: Number of frames to extract per second for analysis. If None or 0, analyzes all frames.
+            Lower values process faster but may miss exact scene cuts.
+        adaptive_threshold: Threshold that the score ratio must exceed to trigger a new scene cut.
+            Lower values will detect more scenes (more sensitive), higher values will detect fewer scenes.
+        min_scene_len: Once a cut is detected, this many frames must pass before a new one can be added to the scene
+            list.
+        window_width: Size of window (number of frames) before and after each frame to average together in order to
+            detect deviations from the mean. Must be at least 1.
+        min_content_val: Minimum threshold (float) that the content_val must exceed in order to register as a new scene.
+            This is calculated the same way that `scene_detect_content()` calculates frame
+            score based on weights/luma_only/kernel_size.
+        delta_hue: Weight for hue component changes. Higher values make hue changes more important.
+        delta_sat: Weight for saturation component changes. Higher values make saturation changes more important.
+        delta_lum: Weight for luminance component changes. Higher values make brightness changes more important.
+        delta_edges: Weight for edge detection changes. Higher values make edge changes more important.
+            Edge detection can help detect cuts in scenes with similar colors but different content.
+        luma_only: If True, only analyzes changes in the luminance (brightness) channel of the video,
+            ignoring color information. This can be faster and may work better for grayscale content.
+        kernel_size: Size of kernel to use for post edge detection filtering. If None, automatically set based on video
+            resolution.
+
+    Returns:
+        A list of dictionaries, one for each detected scene, with the following keys:
+
+        - `start_time` (float): The start time of the scene in seconds.
+        - `start_pts` (int): The pts of the start of the scene.
+        - `duration` (float): The duration of the scene in seconds.
+
+        The list is ordered chronologically. Returns the full duration of the video if no scenes are detected.
+
+    Examples:
+        Detect scene cuts with default parameters:
+
+        >>> tbl.select(tbl.video.scene_detect_adaptive()).collect()
+
+        Detect more scenes by lowering the threshold:
+
+        >>> tbl.select(tbl.video.scene_detect_adaptive(adaptive_threshold=1.5)).collect()
+
+        Use luminance-only detection with a longer minimum scene length:
+
+        >>> tbl.select(
+        ...     tbl.video.scene_detect_adaptive(
+        ...         luma_only=True,
+        ...         min_scene_len=30
+        ...     )
+        ... ).collect()
+
+        Add scene cuts as a computed column:
+
+        >>> tbl.add_computed_column(
+        ...     scene_cuts=tbl.video.scene_detect_adaptive(adaptive_threshold=2.0)
+        ... )
+
+        Analyze at a lower frame rate for faster processing:
+
+        >>> tbl.select(tbl.video.scene_detect_adaptive(fps=2.0)).collect()
+    """
+    Env.get().require_package('scenedetect')
+    from scenedetect.detectors import AdaptiveDetector, ContentDetector
+
+    weights = ContentDetector.Components(
+        delta_hue=delta_hue, delta_sat=delta_sat, delta_lum=delta_lum, delta_edges=delta_edges
+    )
+    try:
+        detector = AdaptiveDetector(
+            adaptive_threshold=adaptive_threshold,
+            min_scene_len=min_scene_len,
+            window_width=window_width,
+            min_content_val=min_content_val,
+            weights=weights,
+            luma_only=luma_only,
+            kernel_size=kernel_size,
+        )
+        return _scene_detect(video, fps, detector)
+    except Exception as e:
+        raise pxt.Error(f'scene_detect_adaptive(): failed to detect scenes: {e}') from e
+
+
+@pxt.udf(is_method=True)
+def scene_detect_content(
+    video: pxt.Video,
+    *,
+    fps: float | None = None,
+    threshold: float = 27.0,
+    min_scene_len: int = 15,
+    delta_hue: float = 1.0,
+    delta_sat: float = 1.0,
+    delta_lum: float = 1.0,
+    delta_edges: float = 0.0,
+    luma_only: bool = False,
+    kernel_size: int | None = None,
+    filter_mode: Literal['merge', 'suppress'] = 'merge',
+) -> list[dict]:
+    """
+    Detect scene cuts in a video using PySceneDetect's
+    [ContentDetector](https://www.scenedetect.com/docs/latest/api/detectors.html#scenedetect.detectors.content_detector.ContentDetector).
+
+    __Requirements:__
+
+    - `pip install scenedetect`
+
+    Args:
+        video: The video to analyze for scene cuts.
+        fps: Number of frames to extract per second for analysis. If None, analyzes all frames.
+            Lower values process faster but may miss exact scene cuts.
+        threshold: Threshold that the weighted sum of component changes must exceed to trigger a scene cut.
+            Lower values detect more scenes (more sensitive), higher values detect fewer scenes.
+        min_scene_len: Once a cut is detected, this many frames must pass before a new one can be added to the scene
+            list.
+        delta_hue: Weight for hue component changes. Higher values make hue changes more important.
+        delta_sat: Weight for saturation component changes. Higher values make saturation changes more important.
+        delta_lum: Weight for luminance component changes. Higher values make brightness changes more important.
+        delta_edges: Weight for edge detection changes. Higher values make edge changes more important.
+            Edge detection can help detect cuts in scenes with similar colors but different content.
+        luma_only: If True, only analyzes changes in the luminance (brightness) channel,
+            ignoring color information. This can be faster and may work better for grayscale content.
+        kernel_size: Size of kernel for expanding detected edges. Must be odd integer greater than or equal to 3. If
+            None, automatically set using video resolution.
+        filter_mode: How to handle fast cuts/flashes. 'merge' combines quick cuts, 'suppress' filters them out.
+
+    Returns:
+        A list of dictionaries, one for each detected scene, with the following keys:
+
+        - `start_time` (float): The start time of the scene in seconds.
+        - `start_pts` (int): The pts of the start of the scene.
+        - `duration` (float): The duration of the scene in seconds.
+
+        The list is ordered chronologically. Returns the full duration of the video if no scenes are detected.
+
+    Examples:
+        Detect scene cuts with default parameters:
+
+        >>> tbl.select(tbl.video.scene_detect_content()).collect()
+
+        Detect more scenes by lowering the threshold:
+
+        >>> tbl.select(tbl.video.scene_detect_content(threshold=15.0)).collect()
+
+        Use luminance-only detection:
+
+        >>> tbl.select(tbl.video.scene_detect_content(luma_only=True)).collect()
+
+        Emphasize edge detection for scenes with similar colors:
+
+        >>> tbl.select(
+        ...     tbl.video.scene_detect_content(
+        ...         delta_edges=1.0,
+        ...         delta_hue=0.5,
+        ...         delta_sat=0.5
+        ...     )
+        ... ).collect()
+
+        Add scene cuts as a computed column:
+
+        >>> tbl.add_computed_column(
+        ...     scene_cuts=tbl.video.scene_detect_content(threshold=20.0)
+        ... )
+    """
+    Env.get().require_package('scenedetect')
+    from scenedetect.detectors import ContentDetector
+    from scenedetect.detectors.content_detector import FlashFilter  # type: ignore[import-untyped]
+
+    weights = ContentDetector.Components(
+        delta_hue=delta_hue, delta_sat=delta_sat, delta_lum=delta_lum, delta_edges=delta_edges
+    )
+    filter_mode_enum = FlashFilter.Mode.MERGE if filter_mode == 'merge' else FlashFilter.Mode.SUPPRESS
+
+    try:
+        detector = ContentDetector(
+            threshold=threshold,
+            min_scene_len=min_scene_len,
+            weights=weights,
+            luma_only=luma_only,
+            kernel_size=kernel_size,
+            filter_mode=filter_mode_enum,
+        )
+        return _scene_detect(video, fps, detector)
+    except Exception as e:
+        raise pxt.Error(f'scene_detect_content(): failed to detect scenes: {e}') from e
+
+
+@pxt.udf(is_method=True)
+def scene_detect_threshold(
+    video: pxt.Video,
+    *,
+    fps: float | None = None,
+    threshold: float = 12.0,
+    min_scene_len: int = 15,
+    fade_bias: float = 0.0,
+    add_final_scene: bool = False,
+    method: Literal['ceiling', 'floor'] = 'floor',
+) -> list[dict]:
+    """
+    Detect fade-in and fade-out transitions in a video using PySceneDetect's
+    [ThresholdDetector](https://www.scenedetect.com/docs/latest/api/detectors.html#scenedetect.detectors.threshold_detector.ThresholdDetector).
+
+    ThresholdDetector identifies scenes by detecting when pixel brightness falls below or rises above
+    a threshold value, suitable for detecting fade-to-black, fade-to-white, and similar transitions.
+
+    __Requirements:__
+
+    - `pip install scenedetect`
+
+    Args:
+        video: The video to analyze for fade transitions.
+        fps: Number of frames to extract per second for analysis. If None or 0, analyzes all frames.
+            Lower values process faster but may miss exact transition points.
+        threshold: 8-bit intensity value that each pixel value (R, G, and B) must be <= to in order to trigger a fade
+            in/out.
+        min_scene_len: Once a cut is detected, this many frames must pass before a new one can be added to the scene
+            list.
+        fade_bias: Float between -1.0 and +1.0 representing the percentage of timecode skew for the start of a scene
+            (-1.0 causing a cut at the fade-to-black, 0.0 in the middle, and +1.0 causing the cut to be right at the
+            position where the threshold is passed).
+        add_final_scene: Boolean indicating if the video ends on a fade-out to generate an additional scene at this
+            timecode.
+        method: How to treat threshold when detecting fade events
+            - 'ceiling': Fade out happens when frame brightness rises above threshold.
+            - 'floor': Fade out happens when frame brightness falls below threshold.
+
+
+    Returns:
+        A list of dictionaries, one for each detected scene, with the following keys:
+
+        - `start_time` (float): The start time of the scene in seconds.
+        - `start_pts` (int): The pts of the start of the scene.
+        - `duration` (float): The duration of the scene in seconds.
+
+        The list is ordered chronologically. Returns the full duration of the video if no scenes are detected.
+
+    Examples:
+        Detect fade-to-black transitions with default parameters:
+
+        >>> tbl.select(tbl.video.scene_detect_threshold()).collect()
+
+        Use a lower threshold to detect darker fades:
+
+        >>> tbl.select(tbl.video.scene_detect_threshold(threshold=8.0)).collect()
+
+        Detect both fade-to-black and fade-to-white using absolute method:
+
+        >>> tbl.select(tbl.video.scene_detect_threshold(method='absolute')).collect()
+
+        Add final scene boundary:
+
+        >>> tbl.select(
+        ...     tbl.video.scene_detect_threshold(
+        ...         add_final_scene=True
+        ...     )
+        ... ).collect()
+
+        Add fade transitions as a computed column:
+
+        >>> tbl.add_computed_column(
+        ...     fade_cuts=tbl.video.scene_detect_threshold(threshold=15.0)
+        ... )
+    """
+    Env.get().require_package('scenedetect')
+    from scenedetect.detectors import ThresholdDetector
+
+    method_enum = ThresholdDetector.Method.FLOOR if method == 'floor' else ThresholdDetector.Method.CEILING
+    try:
+        detector = ThresholdDetector(
+            threshold=threshold,
+            min_scene_len=min_scene_len,
+            fade_bias=fade_bias,
+            add_final_scene=add_final_scene,
+            method=method_enum,
+        )
+        return _scene_detect(video, fps, detector)
+    except Exception as e:
+        raise pxt.Error(f'scene_detect_threshold(): failed to detect scenes: {e}') from e
+
+
+@pxt.udf(is_method=True)
+def scene_detect_histogram(
+    video: pxt.Video, *, fps: float | None = None, threshold: float = 0.05, bins: int = 256, min_scene_len: int = 15
+) -> list[dict]:
+    """
+    Detect scene cuts in a video using PySceneDetect's
+    [HistogramDetector](https://www.scenedetect.com/docs/latest/api/detectors.html#scenedetect.detectors.histogram_detector.HistogramDetector).
+
+    HistogramDetector compares frame histograms on the Y (luminance) channel after YUV conversion.
+    It detects scenes based on relative histogram differences and is more robust to gradual lighting
+    changes than content-based detection.
+
+    __Requirements:__
+
+    - `pip install scenedetect`
+
+    Args:
+        video: The video to analyze for scene cuts.
+        fps: Number of frames to extract per second for analysis. If None or 0, analyzes all frames.
+            Lower values process faster but may miss exact scene cuts.
+        threshold: Maximum relative difference between 0.0 and 1.0 that the histograms can differ. Histograms are
+            calculated on the Y channel after converting the frame to YUV, and normalized based on the number of bins.
+            Higher differences imply greater change in content, so larger threshold values are less sensitive to cuts.
+            Lower values detect more scenes (more sensitive), higher values detect fewer scenes.
+        bins: Number of bins to use for histogram calculation (typically 16-256). More bins provide
+            finer granularity but may be more sensitive to noise.
+        min_scene_len: Once a cut is detected, this many frames must pass before a new one can be added to the scene
+            list.
+
+
+    Returns:
+        A list of dictionaries, one for each detected scene, with the following keys:
+
+        - `start_time` (float): The start time of the scene in seconds.
+        - `start_pts` (int): The pts of the start of the scene.
+        - `duration` (float): The duration of the scene in seconds.
+
+        The list is ordered chronologically. Returns the full duration of the video if no scenes are detected.
+
+    Examples:
+        Detect scene cuts with default parameters:
+
+        >>> tbl.select(tbl.video.scene_detect_histogram()).collect()
+
+        Detect more scenes by lowering the threshold:
+
+        >>> tbl.select(tbl.video.scene_detect_histogram(threshold=0.03)).collect()
+
+        Use fewer bins for faster processing:
+
+        >>> tbl.select(tbl.video.scene_detect_histogram(bins=64)).collect()
+
+        Use with a longer minimum scene length:
+
+        >>> tbl.select(
+        ...     tbl.video.scene_detect_histogram(
+        ...         min_scene_len=30
+        ...     )
+        ... ).collect()
+
+        Add scene cuts as a computed column:
+
+        >>> tbl.add_computed_column(
+        ...     scene_cuts=tbl.video.scene_detect_histogram(threshold=0.04)
+        ... )
+    """
+    Env.get().require_package('scenedetect')
+    from scenedetect.detectors import HistogramDetector
+
+    try:
+        detector = HistogramDetector(threshold=threshold, bins=bins, min_scene_len=min_scene_len)
+        return _scene_detect(video, fps, detector)
+    except Exception as e:
+        raise pxt.Error(f'scene_detect_histogram(): failed to detect scenes: {e}') from e
+
+
+@pxt.udf(is_method=True)
+def scene_detect_hash(
+    video: pxt.Video,
+    *,
+    fps: float | None = None,
+    threshold: float = 0.395,
+    size: int = 16,
+    lowpass: int = 2,
+    min_scene_len: int = 15,
+) -> list[dict]:
+    """
+    Detect scene cuts in a video using PySceneDetect's
+    [HashDetector](https://www.scenedetect.com/docs/latest/api/detectors.html#scenedetect.detectors.hash_detector.HashDetector).
+
+    HashDetector uses perceptual hashing for very fast scene detection. It computes a hash of each
+    frame at reduced resolution and compares hash distances.
+
+    __Requirements:__
+
+    - `pip install scenedetect`
+
+    Args:
+        video: The video to analyze for scene cuts.
+        fps: Number of frames to extract per second for analysis. If None, analyzes all frames.
+            Lower values process faster but may miss exact scene cuts.
+        threshold: Value from 0.0 and 1.0 representing the relative hamming distance between the perceptual hashes of
+            adjacent frames. A distance of 0 means the image is the same, and 1 means no correlation. Smaller threshold
+            values thus require more correlation, making the detector more sensitive. The Hamming distance is divided
+            by size x size before comparing to threshold for normalization.
+            Lower values detect more scenes (more sensitive), higher values detect fewer scenes.
+        size: Size of square of low frequency data to use for the DCT. Larger values are more precise but slower.
+            Common values are 8, 16, or 32.
+        lowpass: How much high frequency information to filter from the DCT. A value of 2 means keep lower 1/2 of the
+            frequency data, 4 means only keep 1/4, etc. Larger values make the
+            detector less sensitive to high-frequency details and noise.
+        min_scene_len: Once a cut is detected, this many frames must pass before a new one can be added to the scene
+            list.
+
+
+    Returns:
+        A list of dictionaries, one for each detected scene, with the following keys:
+
+        - `start_time` (float): The start time of the scene in seconds.
+        - `start_pts` (int): The pts of the start of the scene.
+        - `duration` (float): The duration of the scene in seconds.
+
+        The list is ordered chronologically. Returns the full duration of the video if no scenes are detected.
+
+    Examples:
+        Detect scene cuts with default parameters:
+
+        >>> tbl.select(tbl.video.scene_detect_hash()).collect()
+
+        Detect more scenes by lowering the threshold:
+
+        >>> tbl.select(tbl.video.scene_detect_hash(threshold=0.3)).collect()
+
+        Use larger hash size for more precision:
+
+        >>> tbl.select(tbl.video.scene_detect_hash(size=32)).collect()
+
+        Use for fast processing with lower frame rate:
+
+        >>> tbl.select(
+        ...     tbl.video.scene_detect_hash(
+        ...         fps=1.0,
+        ...         threshold=0.4
+        ...     )
+        ... ).collect()
+
+        Add scene cuts as a computed column:
+
+        >>> tbl.add_computed_column(
+        ...     scene_cuts=tbl.video.scene_detect_hash()
+        ... )
+    """
+    Env.get().require_package('scenedetect')
+    from scenedetect.detectors import HashDetector
+
+    try:
+        detector = HashDetector(threshold=threshold, size=size, lowpass=lowpass, min_scene_len=min_scene_len)
+        return _scene_detect(video, fps, detector)
+    except Exception as e:
+        raise pxt.Error(f'scene_detect_hash(): failed to detect scenes: {e}') from e
+
+
+class _SceneDetectFrameInfo(NamedTuple):
+    frame_idx: int
+    frame_pts: int
+    frame_time: float
+
+
+def _scene_detect(video: str, fps: float, detector: 'SceneDetector') -> list[dict[str, int | float]]:
+    from scenedetect import FrameTimecode  # type: ignore[import-untyped]
+
+    with av_utils.VideoFrames(pathlib.Path(video), fps=fps) as frame_iter:
+        video_fps = float(frame_iter.video_framerate)
+
+        scenes: list[dict[str, int | float]] = []
+        frame_idx: int | None = None
+        start_time: float | None = None  # of current scene
+        start_pts: int | None = None  # of current scene
+
+        # in order to determine the cut frame times, we need to record frame times (chronologically) and look them
+        # up by index; trying to derive frame times from frame indices isn't possible due to variable frame rates
+        frame_info: list[_SceneDetectFrameInfo] = []
+
+        def process_cuts(cuts: list[FrameTimecode]) -> None:
+            nonlocal frame_info, start_time, start_pts
+            for cut_timecode in cuts:
+                cut_frame_idx = cut_timecode.get_frames()
+                # we expect cuts to come back in chronological order
+                assert cut_frame_idx >= frame_info[0].frame_idx
+                info_offset = next((i for i, info in enumerate(frame_info) if info.frame_idx == cut_frame_idx), None)
+                assert info_offset is not None  # the cut is at a previously reported frame idx
+                info = frame_info[info_offset]
+                scenes.append(
+                    {'start_time': start_time, 'start_pts': start_pts, 'duration': info.frame_time - start_time}
+                )
+                start_time = info.frame_time
+                start_pts = info.frame_pts
+                frame_info = frame_info[info_offset + 1 :]
+
+        for item in frame_iter:
+            if start_time is None:
+                start_time = item.time
+                start_pts = item.pts
+            frame_info.append(_SceneDetectFrameInfo(item.frame_idx, item.pts, item.time))
+            frame_array = np.array(item.frame.convert('RGB'))
+            frame_idx = item.frame_idx
+            timecode = FrameTimecode(item.frame_idx, video_fps)
+            cuts = detector.process_frame(timecode, frame_array)
+            process_cuts(cuts)
+
+        # Post-process to capture any final scene cuts
+        if frame_idx is not None:
+            final_timecode = FrameTimecode(frame_idx, video_fps)
+            final_cuts = detector.post_process(final_timecode)
+            process_cuts(final_cuts)
+
+            # if we didn't detect any cuts but the video has content, add the full video as a single scene
+            if len(scenes) == 0:
+                scenes.append(
+                    {
+                        'start_time': start_time,
+                        'start_pts': start_pts,
+                        'duration': frame_info[-1].frame_time - start_time,
+                    }
+                )
+
+        return scenes
+
+
 __all__ = local_public_names(__name__)
 
 

pixeltable/globals.py

@@ -456,7 +456,8 @@ def replicate(remote_uri: str, local_path: str) -> catalog.Table:
     queried offline just as any other Pixeltable table.
 
     Args:
-        remote_uri: Remote URI of the table to be replicated, such as `'pxt://org_name/my_dir/my_table'`.
+        remote_uri: Remote URI of the table to be replicated, such as `'pxt://org_name/my_dir/my_table'` or
+            `'pxt://org_name/my_dir/my_table:5'` (with version 5).
         local_path: Local table path where the replica will be created, such as `'my_new_dir.my_new_tbl'`. It can be
             the same or different from the cloud table name.
 

pixeltable/index/base.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import abc
-from typing import Any
 
 import sqlalchemy as sql
 
@@ -19,47 +18,35 @@ class IndexBase(abc.ABC):
     the specific subclass.
     """
 
-    @abc.abstractmethod
-    def __init__(self, **kwargs: Any):
-        pass
-
     @abc.abstractmethod
     def create_value_expr(self, c: catalog.Column) -> exprs.Expr:
         """
         Validates that the index can be created on column c and returns an expression that computes the index value.
         """
-        pass
 
     @abc.abstractmethod
     def records_value_errors(self) -> bool:
         """True if index_value_expr() can raise errors"""
-        pass
 
     @abc.abstractmethod
     def get_index_sa_type(self, value_col_type: ts.ColumnType) -> sql.types.TypeEngine:
         """Return the sqlalchemy type of the index value column"""
-        pass
 
     @abc.abstractmethod
-    def sa_index(self, index_name: str, index_value_col: catalog.Column) -> sql.Index:
-        """Return a sqlalchemy Index instance"""
-        pass
+    def sa_create_stmt(self, store_index_name: str, sa_value_col: sql.Column) -> sql.Compiled:
+        """Return a sqlalchemy statement for creating the index"""
 
     @abc.abstractmethod
     def drop_index(self, index_name: str, index_value_col: catalog.Column) -> None:
         """Drop the index on the index value column"""
-        pass
 
     @classmethod
     @abc.abstractmethod
-    def display_name(cls) -> str:
-        pass
+    def display_name(cls) -> str: ...
 
     @abc.abstractmethod
-    def as_dict(self) -> dict:
-        pass
+    def as_dict(self) -> dict: ...
 
     @classmethod
     @abc.abstractmethod
-    def from_dict(cls, d: dict) -> IndexBase:
-        pass
+    def from_dict(cls, d: dict) -> IndexBase: ...

pixeltable/index/btree.py

@@ -53,8 +53,12 @@ class BtreeIndex(IndexBase):
         """Return the sqlalchemy type of the index value column"""
         return val_col_type.to_sa_type()
 
-    def sa_index(self, store_index_name: str, index_value_col: 'catalog.Column') -> sql.Index:
-        return sql.Index(store_index_name, index_value_col.sa_col, postgresql_using='btree')
+    def sa_create_stmt(self, store_index_name: str, sa_value_col: sql.Column) -> sql.Compiled:
+        """Return a sqlalchemy statement for creating the index"""
+        from sqlalchemy.dialects import postgresql
+
+        sa_idx = sql.Index(store_index_name, sa_value_col, postgresql_using='btree')
+        return sql.schema.CreateIndex(sa_idx, if_not_exists=True).compile(dialect=postgresql.dialect())
 
     def drop_index(self, index_name: str, index_value_col: 'catalog.Column') -> None:
         """Drop the index on the index value column"""

pixeltable/index/embedding_index.py

@@ -131,10 +131,10 @@ class EmbeddingIndex(IndexBase):
         assert vector_size is not None
         return pgvector.sqlalchemy.Vector(vector_size)
 
-    def sa_index(self, store_index_name: str, index_value_col: 'catalog.Column') -> sql.Index:
-        """Create the index on the index value column"""
-        return Env.get().dbms.sa_vector_index(
-            store_index_name, index_value_col.sa_col, metric=self.PGVECTOR_OPS[self.metric]
+    def sa_create_stmt(self, store_index_name: str, sa_value_col: sql.Column) -> sql.Compiled:
+        """Return a sqlalchemy statement for creating the index"""
+        return Env.get().dbms.create_vector_index_stmt(
+            store_index_name, sa_value_col, metric=self.PGVECTOR_OPS[self.metric]
         )
 
     def drop_index(self, index_name: str, index_value_col: catalog.Column) -> None: