pixeltable 0.4.9__py3-none-any.whl → 0.4.11__py3-none-any.whl

pixeltable/env.py

@@ -11,6 +11,7 @@ import logging
 import os
 import platform
 import shutil
+import subprocess
 import sys
 import threading
 import types
@@ -82,6 +83,7 @@ class Env:
     _file_cache_size_g: float
     _pxt_api_key: Optional[str]
     _stdout_handler: logging.StreamHandler
+    _default_video_encoder: str | None
     _initialized: bool
 
     _resource_pool_info: dict[str, Any]
@@ -132,6 +134,7 @@ class Env:
         self._spacy_nlp = None
         self._httpd = None
         self._http_address = None
+        self._default_video_encoder = None
 
         # logging-related state
         self._logger = logging.getLogger('pixeltable')
@@ -677,6 +680,41 @@ class Env:
         self._start_web_server()
         self.__register_packages()
 
+    @property
+    def default_video_encoder(self) -> str | None:
+        if self._default_video_encoder is None:
+            self._default_video_encoder = self._determine_default_video_encoder()
+        return self._default_video_encoder
+
+    def _determine_default_video_encoder(self) -> str | None:
+        """
+        Returns the first available encoder from a list of candidates.
+
+        TODO:
+        - the user might prefer a hardware-accelerated encoder (eg, h264_nvenc or h264_videotoolbox)
+        - allow user override via a config option 'video_encoder'
+        """
+        # look for available encoders, in this order
+        candidates = [
+            'libx264',  # GPL, best quality
+            'libopenh264',  # BSD
+        ]
+
+        try:
+            # Get list of available encoders
+            result = subprocess.run(['ffmpeg', '-encoders'], capture_output=True, text=True, timeout=10, check=True)
+
+            if result.returncode == 0:
+                available_encoders = result.stdout
+                for encoder in candidates:
+                    # ffmpeg -encoders output format: " V..... encoder_name  description"
+                    if f' {encoder} ' in available_encoders:
+                        _logger.debug(f'Using H.264 encoder: {encoder}')
+                        return encoder
+        except Exception:
+            pass
+        return None
+
     def __register_packages(self) -> None:
         """Declare optional packages that are utilized by some parts of the code."""
         self.__register_package('anthropic')

pixeltable/functions/audio.py

@@ -3,6 +3,7 @@ Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs)
 """
 
 import pixeltable as pxt
+import pixeltable.utils.av as av_utils
 from pixeltable.utils.code import local_public_names
 
 
@@ -47,7 +48,7 @@ def get_metadata(audio: pxt.Audio) -> dict:
 
         >>> tbl.select(tbl.audio_col.get_metadata()).collect()
     """
-    return pxt.functions.video._get_metadata(audio)
+    return av_utils.get_metadata(audio)
 
 
 __all__ = local_public_names(__name__)

pixeltable/functions/gemini.py

@@ -14,6 +14,7 @@ import PIL.Image
 
 import pixeltable as pxt
 from pixeltable import env, exceptions as excs, exprs
+from pixeltable.utils.code import local_public_names
 from pixeltable.utils.media_store import TempStore
 
 if TYPE_CHECKING:
@@ -232,3 +233,10 @@ async def generate_videos(
 @generate_videos.resource_pool
 def _(model: str) -> str:
     return f'request-rate:veo:{model}'
+
+
+__all__ = local_public_names(__name__)
+
+
+def __dir__() -> list[str]:
+    return __all__

pixeltable/functions/video.py

@@ -2,16 +2,24 @@
 Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs) for `VideoType`.
 """
 
-from typing import Any, Optional
+import logging
+import pathlib
+import shutil
+import subprocess
+from typing import Literal, NoReturn
 
 import av
+import av.stream
 import numpy as np
 import PIL.Image
 
 import pixeltable as pxt
+import pixeltable.utils.av as av_utils
+from pixeltable.env import Env
 from pixeltable.utils.code import local_public_names
 from pixeltable.utils.media_store import TempStore
 
+_logger = logging.getLogger('pixeltable')
 _format_defaults: dict[str, tuple[str, str]] = {  # format -> (codec, ext)
     'wav': ('pcm_s16le', 'wav'),
     'mp3': ('libmp3lame', 'mp3'),
@@ -39,21 +47,17 @@ _format_defaults: dict[str, tuple[str, str]] = {  # format -> (codec, ext)
 @pxt.uda(requires_order_by=True)
 class make_video(pxt.Aggregator):
     """
-    Aggregator that creates a video from a sequence of images.
-
-    Creates an H.264 encoded MP4 video from a sequence of PIL Image frames. This aggregator requires the input
-    frames to be ordered (typically by frame position) and is commonly used with `FrameIterator` views to
-    reconstruct videos from processed frames.
+    Aggregator that creates a video from a sequence of images, using the default video encoder and yuv420p pixel format.
 
     Args:
-        fps: Frames per second for the output video. Default is 25. This is set when the aggregator is created.
+        fps: Frames per second for the output video.
 
     Returns:
 
-    - A `pxt.Video` containing the created video file path.
+    - The created video.
 
     Examples:
-        Create a video from frames extracted using FrameIterator:
+        Create a video from frames extracted using `FrameIterator`:
 
         >>> import pixeltable as pxt
         >>> from pixeltable.functions.video import make_video
@@ -76,31 +80,29 @@ class make_video(pxt.Aggregator):
 
         Apply transformations to frames before creating a video:
 
-        >>> # Add computed column with transformed frames
-        >>> frames_view.add_computed_column(
-        ...     rotated_frame=frames_view.frame.rotate(30),
-        ...     stored=True
-        ... )
-        >>>
         >>> # Create video from transformed frames
         >>> frames_view.group_by(videos_table).select(
-        ...     make_video(frames_view.pos, frames_view.rotated_frame)
+        ...     make_video(frames_view.pos, frames_view.frame.rotate(30))
         ... ).show()
 
         Compare multiple processed versions side-by-side:
 
         >>> frames_view.group_by(videos_table).select(
         ...     make_video(frames_view.pos, frames_view.frame),
-        ...     make_video(frames_view.pos, frames_view.rotated_frame)
+        ...     make_video(frames_view.pos, frames_view.frame.rotate(30))
         ... ).show()
     """
 
-    container: Optional[av.container.OutputContainer]
-    stream: Optional[av.video.stream.VideoStream]
+    container: av.container.OutputContainer | None
+    stream: av.video.stream.VideoStream | None
     fps: int
 
     def __init__(self, fps: int = 25):
-        """follows https://pyav.org/docs/develop/cookbook/numpy.html#generating-video"""
+        """
+        Follows https://pyav.org/docs/develop/cookbook/numpy.html#generating-video
+
+        TODO: provide parameters for video_encoder and pix_fmt
+        """
         self.container = None
         self.stream = None
         self.fps = fps
@@ -129,7 +131,7 @@ class make_video(pxt.Aggregator):
 
 @pxt.udf(is_method=True)
 def extract_audio(
-    video_path: pxt.Video, stream_idx: int = 0, format: str = 'wav', codec: Optional[str] = None
+    video_path: pxt.Video, stream_idx: int = 0, format: str = 'wav', codec: str | None = None
 ) -> pxt.Audio:
     """
     Extract an audio stream from a video.
@@ -176,7 +178,7 @@ def get_metadata(video: pxt.Video) -> dict:
     Gets various metadata associated with a video file and returns it as a dictionary.
 
     Args:
-        video: The video to get metadata for.
+        video: The video for which to get metadata.
 
     Returns:
         A `dict` such as the following:
@@ -221,66 +223,517 @@ def get_metadata(video: pxt.Video) -> dict:
 
         >>> tbl.select(tbl.video_col.get_metadata()).collect()
     """
-    return _get_metadata(video)
-
-
-def _get_metadata(path: str) -> dict:
-    with av.open(path) as container:
-        assert isinstance(container, av.container.InputContainer)
-        streams_info = [__get_stream_metadata(stream) for stream in container.streams]
-        result = {
-            'bit_exact': getattr(container, 'bit_exact', False),
-            'bit_rate': container.bit_rate,
-            'size': container.size,
-            'metadata': container.metadata,
-            'streams': streams_info,
-        }
-    return result
-
-
-def __get_stream_metadata(stream: av.stream.Stream) -> dict:
-    if stream.type not in ('audio', 'video'):
-        return {'type': stream.type}  # Currently unsupported
-
-    codec_context = stream.codec_context
-    codec_context_md: dict[str, Any] = {
-        'name': codec_context.name,
-        'codec_tag': codec_context.codec_tag.encode('unicode-escape').decode('utf-8'),
-        'profile': codec_context.profile,
-    }
-    metadata = {
-        'type': stream.type,
-        'duration': stream.duration,
-        'time_base': float(stream.time_base) if stream.time_base is not None else None,
-        'duration_seconds': float(stream.duration * stream.time_base)
-        if stream.duration is not None and stream.time_base is not None
-        else None,
-        'frames': stream.frames,
-        'metadata': stream.metadata,
-        'codec_context': codec_context_md,
-    }
-
-    if stream.type == 'audio':
-        # Additional metadata for audio
-        channels = getattr(stream.codec_context, 'channels', None)
-        codec_context_md['channels'] = int(channels) if channels is not None else None
-    else:
-        assert stream.type == 'video'
-        assert isinstance(stream, av.video.stream.VideoStream)
-        # Additional metadata for video
-        codec_context_md['pix_fmt'] = getattr(stream.codec_context, 'pix_fmt', None)
-        metadata.update(
-            **{
-                'width': stream.width,
-                'height': stream.height,
-                'frames': stream.frames,
-                'average_rate': float(stream.average_rate) if stream.average_rate is not None else None,
-                'base_rate': float(stream.base_rate) if stream.base_rate is not None else None,
-                'guessed_rate': float(stream.guessed_rate) if stream.guessed_rate is not None else None,
-            }
-        )
+    return av_utils.get_metadata(video)
+
+
+@pxt.udf(is_method=True)
+def get_duration(video: pxt.Video) -> float | None:
+    """
+    Get video duration in seconds.
+
+    Args:
+        video: The video for which to get the duration.
+
+    Returns:
+        The duration in seconds, or None if the duration cannot be determined.
+    """
+    return av_utils.get_video_duration(video)
+
+
+@pxt.udf(is_method=True)
+def extract_frame(video: pxt.Video, *, timestamp: float) -> PIL.Image.Image | None:
+    """
+    Extract a single frame from a video at a specific timestamp.
+
+    Args:
+        video: The video from which to extract the frame.
+        timestamp: Extract frame at this timestamp (in seconds).
+
+    Returns:
+        The extracted frame as a PIL Image, or None if the timestamp is beyond the video duration.
 
-    return metadata
+    Examples:
+        Extract the first frame from each video in the `video` column of the table `tbl`:
+
+        >>> tbl.select(tbl.video.extract_frame(0.0)).collect()
+
+        Extract a frame close to the end of each video in the `video` column of the table `tbl`:
+
+        >>> tbl.select(tbl.video.extract_frame(tbl.video.get_metadata().streams[0].duration_seconds - 0.1)).collect()
+    """
+    if timestamp < 0:
+        raise ValueError("'timestamp' must be non-negative")
+
+    try:
+        with av.open(str(video)) as container:
+            video_stream = container.streams.video[0]
+            time_base = float(video_stream.time_base)
+            start_time = video_stream.start_time or 0
+            duration = video_stream.duration
+
+            # Check if timestamp is beyond video duration
+            if duration is not None:
+                duration_seconds = float(duration * time_base)
+                if timestamp > duration_seconds:
+                    return None
+
+            # Convert timestamp to stream time base units
+            target_pts = int(timestamp / time_base) + start_time
+
+            # Seek to the nearest keyframe *before* our target timestamp
+            container.seek(target_pts, backward=True, stream=video_stream)
+
+            # Decode frames until we reach or pass the target timestamp
+            for frame in container.decode(video=0):
+                frame_pts = frame.pts
+                if frame_pts is None:
+                    continue
+                frame_timestamp = (frame_pts - start_time) * time_base
+                if frame_timestamp >= timestamp:
+                    return frame.to_image()
+
+            return None
+
+    except Exception as e:
+        raise pxt.Error(f'extract_frame(): failed to extract frame: {e}') from e
+
+
+def _handle_ffmpeg_error(e: subprocess.CalledProcessError) -> NoReturn:
+    error_msg = f'ffmpeg failed with return code {e.returncode}'
+    if e.stderr is not None:
+        error_msg += f':\n{e.stderr.strip()}'
+    raise pxt.Error(error_msg) from e
+
+
+@pxt.udf(is_method=True)
+def clip(
+    video: pxt.Video, *, start_time: float, end_time: float | None = None, duration: float | None = None
+) -> pxt.Video | None:
+    """
+    Extract a clip from a video, specified by `start_time` and either `end_time` or `duration` (in seconds).
+
+    If `start_time` is beyond the end of the video, returns None. Can only specify one of `end_time` and `duration`.
+    If both `end_time` and `duration` are None, the clip goes to the end of the video.
+
+    __Requirements:__
+
+    - `ffmpeg` needs to be installed and in PATH
+
+    Args:
+        video: Input video file
+        start_time: Start time in seconds
+        end_time: End time in seconds
+        duration: Duration of the clip in seconds
+
+    Returns:
+        New video containing only the specified time range or None if start_time is beyond the end of the video.
+    """
+    if start_time < 0:
+        raise pxt.Error(f'start_time must be non-negative, got {start_time}')
+    if end_time is not None and end_time <= start_time:
+        raise pxt.Error(f'end_time ({end_time}) must be greater than start_time ({start_time})')
+    if duration is not None and duration <= 0:
+        raise pxt.Error(f'duration must be positive, got {duration}')
+    if end_time is not None and duration is not None:
+        raise pxt.Error('end_time and duration cannot both be specified')
+    if not shutil.which('ffmpeg'):
+        raise pxt.Error('ffmpeg is not installed or not in PATH. Please install ffmpeg to use get_clip().')
+
+    video_duration = av_utils.get_video_duration(video)
+    if video_duration is not None and start_time > video_duration:
+        return None
+
+    output_path = str(TempStore.create_path(extension='.mp4'))
+
+    if end_time is not None:
+        duration = end_time - start_time
+    cmd = av_utils.ffmpeg_clip_cmd(str(video), output_path, start_time, duration)
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        output_file = pathlib.Path(output_path)
+        if not output_file.exists() or output_file.stat().st_size == 0:
+            stderr_output = result.stderr.strip() if result.stderr is not None else ''
+            raise pxt.Error(f'ffmpeg failed to create output file for commandline: {" ".join(cmd)}\n{stderr_output}')
+        return output_path
+    except subprocess.CalledProcessError as e:
+        _handle_ffmpeg_error(e)
+
+
+@pxt.udf(is_method=True)
+def segment_video(video: pxt.Video, *, duration: float) -> list[str]:
+    """
+    Split a video into fixed-size segments.
+
+    __Requirements:__
+
+    - `ffmpeg` needs to be installed and in PATH
+
+    Args:
+        video: Input video file to segment
+        duration: Approximate duration of each segment (in seconds).
+
+    Returns:
+        List of file paths for the generated video segments.
+
+    Raises:
+        pxt.Error: If the video is missing timing information.
+
+    Examples:
+        Split a video at 1 minute intervals
+
+        >>> tbl.select(segment_paths=tbl.video.segment_video(duration=60)).collect()
+
+        Split video into two parts at the midpoint:
+
+        >>> duration = tbl.video.get_duration()
+        >>> tbl.select(segment_paths=tbl.video.segment_video(duration=duration / 2 + 1)).collect()
+    """
+    if duration <= 0:
+        raise pxt.Error(f'duration must be positive, got {duration}')
+    if not shutil.which('ffmpeg'):
+        raise pxt.Error('ffmpeg is not installed or not in PATH. Please install ffmpeg to use segment_video().')
+
+    base_path = TempStore.create_path(extension='')
+
+    # we extract consecutive clips instead of running ffmpeg -f segment, which is inexplicably much slower
+    start_time = 0.0
+    result: list[str] = []
+    try:
+        while True:
+            segment_path = f'{base_path}_segment_{len(result)}.mp4'
+            cmd = av_utils.ffmpeg_clip_cmd(str(video), segment_path, start_time, duration)
+
+            _ = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            segment_duration = av_utils.get_video_duration(segment_path)
+            if segment_duration == 0.0:
+                # we're done
+                pathlib.Path(segment_path).unlink()
+                return result
+            result.append(segment_path)
+            start_time += segment_duration  # use the actual segment duration here, it won't match duration exactly
+
+        return result
+
+    except subprocess.CalledProcessError as e:
+        # clean up partial results
+        for segment_path in result:
+            pathlib.Path(segment_path).unlink()
+        _handle_ffmpeg_error(e)
+
+
+@pxt.udf(is_method=True)
+def concat_videos(videos: list[pxt.Video]) -> pxt.Video:
+    """
+    Merge multiple videos into a single video.
+
+    __Requirements:__
+
+    - `ffmpeg` needs to be installed and in PATH
+
+    Args:
+        videos: List of videos to merge.
+
+    Returns:
+        A new video containing the merged videos.
+    """
+    if len(videos) == 0:
+        raise pxt.Error('concat_videos(): empty argument list')
+    if not shutil.which('ffmpeg'):
+        raise pxt.Error('ffmpeg is not installed or not in PATH. Please install ffmpeg to use concat_videos().')
+
+    # Check that all videos have the same resolution
+    resolutions: list[tuple[int, int]] = []
+    for video in videos:
+        metadata = av_utils.get_metadata(str(video))
+        video_stream = next((stream for stream in metadata['streams'] if stream['type'] == 'video'), None)
+        if video_stream is None:
+            raise pxt.Error(f'concat_videos(): file {video!r} has no video stream')
+        resolutions.append((video_stream['width'], video_stream['height']))
+
+    # check for divergence
+    x0, y0 = resolutions[0]
+    for i, (x, y) in enumerate(resolutions[1:], start=1):
+        if (x0, y0) != (x, y):
+            raise pxt.Error(
+                f'concat_videos(): requires that all videos have the same resolution, but:'
+                f'\n  video 0 ({videos[0]!r}): {x0}x{y0}'
+                f'\n  video {i} ({videos[i]!r}): {x}x{y}.'
+            )
+
+    # ffmpeg -f concat needs an input file list
+    filelist_path = TempStore.create_path(extension='.txt')
+    with filelist_path.open('w', encoding='utf-8') as f:
+        for video in videos:
+            f.write(f'file {video!r}\n')
+
+    output_path = TempStore.create_path(extension='.mp4')
+
+    try:
+        # First attempt: fast copy without re-encoding (works for compatible formats)
+        cmd = ['ffmpeg', '-f', 'concat', '-safe', '0', '-i', str(filelist_path), '-c', 'copy', '-y', str(output_path)]
+        _logger.debug(f'concat_videos(): {" ".join(cmd)}')
+        try:
+            _ = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            return str(output_path)
+        except subprocess.CalledProcessError:
+            # Expected for mixed formats - continue to fallback
+            pass
+
+        # we might have some corrupted output
+        if output_path.exists():
+            output_path.unlink()
+
+        # general approach: re-encode with -f filter_complex
+        #
+        # example: 2 videos with audio:
+        #   ffmpeg -i video1.mp4 -i video2.mp4
+        #     -filter_complex "[0:v:0][1:v:0]concat=n=2:v=1:a=0[outv];[0:a:0][1:a:0]concat=n=2:v=0:a=1[outa]"
+        #     -map "[outv]" -map "[outa]"
+        #     ...
+        # breakdown:
+        # - [0:v:0][1:v:0] - video stream 0 from inputs 0 and 1
+        # - concat=n=2:v=1:a=0[outv] - concat 2 inputs, 1 video stream, 0 audio, output to [outv]
+        # - [0:a:0][1:a:0] - audio stream 0 from inputs 0 and 1
+        # - concat=n=2:v=0:a=1[outa] - concat 2 inputs, 0 video, 1 audio stream, output to [outa]
+
+        cmd = ['ffmpeg']
+        for video in videos:
+            cmd.extend(['-i', video])
+
+        all_have_audio = all(av_utils.has_audio_stream(str(video)) for video in videos)
+        video_inputs = ''.join([f'[{i}:v:0]' for i in range(len(videos))])
+        # concat video streams
+        filter_str = f'{video_inputs}concat=n={len(videos)}:v=1:a=0[outv]'
+        if all_have_audio:
+            # also concat audio streams
+            audio_inputs = ''.join([f'[{i}:a:0]' for i in range(len(videos))])
+            filter_str += f';{audio_inputs}concat=n={len(videos)}:v=0:a=1[outa]'
+        cmd.extend(['-filter_complex', filter_str, '-map', '[outv]'])
+        if all_have_audio:
+            cmd.extend(['-map', '[outa]'])
+
+        video_encoder = Env.get().default_video_encoder
+        if video_encoder is not None:
+            cmd.extend(['-c:v', video_encoder])
+        if all_have_audio:
+            cmd.extend(['-c:a', 'aac'])
+        cmd.extend(['-pix_fmt', 'yuv420p', str(output_path)])
+
+        _ = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return str(output_path)
+
+    except subprocess.CalledProcessError as e:
+        _handle_ffmpeg_error(e)
+    finally:
+        filelist_path.unlink()
+
+
+@pxt.udf(is_method=True)
+def overlay_text(
+    video: pxt.Video,
+    text: str,
+    *,
+    font: str | None = None,
+    font_size: int = 24,
+    color: str = 'white',
+    opacity: float = 1.0,
+    horizontal_align: Literal['left', 'center', 'right'] = 'center',
+    horizontal_margin: int = 0,
+    vertical_align: Literal['top', 'center', 'bottom'] = 'center',
+    vertical_margin: int = 0,
+    box: bool = False,
+    box_color: str = 'black',
+    box_opacity: float = 1.0,
+    box_border: list[int] | None = None,
+) -> pxt.Video:
+    """
+    Overlay text on a video with customizable positioning and styling.
+
+    __Requirements:__
+
+    - `ffmpeg` needs to be installed and in PATH
+
+    Args:
+        video: Input video to overlay text on.
+        text: The text string to overlay on the video.
+        font: Font family or path to font file. If None, uses the system default.
+        font_size: Size of the text in points.
+        color: Text color (e.g., `'white'`, `'red'`, `'#FF0000'`).
+        opacity: Text opacity from 0.0 (transparent) to 1.0 (opaque).
+        horizontal_align: Horizontal text alignment (`'left'`, `'center'`, `'right'`).
+        horizontal_margin: Horizontal margin in pixels from the alignment edge.
+        vertical_align: Vertical text alignment (`'top'`, `'center'`, `'bottom'`).
+        vertical_margin: Vertical margin in pixels from the alignment edge.
+        box: Whether to draw a background box behind the text.
+        box_color: Background box color as a string.
+        box_opacity: Background box opacity from 0.0 to 1.0.
+        box_border: Padding around text in the box in pixels.
+
+            - `[10]`: 10 pixels on all sides
+            - `[10, 20]`: 10 pixels on top/bottom, 20 on left/right
+            - `[10, 20, 30]`: 10 pixels on top, 20 on left/right, 30 on bottom
+            - `[10, 20, 30, 40]`: 10 pixels on top, 20 on right, 30 on bottom, 40 on left
+
+    Returns:
+        A new video with the text overlay applied.
+
+    Examples:
+        Add a simple text overlay to videos in a table:
+
+        >>> tbl.select(tbl.video.overlay_text('Sample Text')).collect()
+
+        Add a YouTube-style caption:
+
+        >>> tbl.select(
+        ...     tbl.video.overlay_text(
+        ...         'Caption text',
+        ...         font_size=32,
+        ...         color='white',
+        ...         opacity=1.0,
+        ...         box=True,
+        ...         box_color='black',
+        ...         box_opacity=0.8,
+        ...         box_border=[6, 14],
+        ...         horizontal_margin=10,
+        ...         vertical_align='bottom',
+        ...         vertical_margin=70
+        ...     )
+        ... ).collect()
+
+        Add text with a semi-transparent background box:
+
+        >>> tbl.select(
+        ...     tbl.video.overlay_text(
+        ...         'Important Message',
+        ...         font_size=32,
+        ...         color='yellow',
+        ...         box=True,
+        ...         box_color='black',
+        ...         box_opacity=0.6,
+        ...         box_border=[20, 10]
+        ...     )
+        ... ).collect()
+    """
+    if not shutil.which('ffmpeg'):
+        raise pxt.Error('ffmpeg is not installed or not in PATH. Please install ffmpeg to use overlay_text().')
+    if font_size <= 0:
+        raise pxt.Error(f'font_size must be positive, got {font_size}')
+    if opacity < 0.0 or opacity > 1.0:
+        raise pxt.Error(f'opacity must be between 0.0 and 1.0, got {opacity}')
+    if horizontal_margin < 0:
+        raise pxt.Error(f'horizontal_margin must be non-negative, got {horizontal_margin}')
+    if vertical_margin < 0:
+        raise pxt.Error(f'vertical_margin must be non-negative, got {vertical_margin}')
+    if box_opacity < 0.0 or box_opacity > 1.0:
+        raise pxt.Error(f'box_opacity must be between 0.0 and 1.0, got {box_opacity}')
+    if box_border is not None and not (
+        isinstance(box_border, (list, tuple))
+        and len(box_border) >= 1
+        and len(box_border) <= 4
+        and all(isinstance(x, int) for x in box_border)
+        and all(x >= 0 for x in box_border)
+    ):
+        raise pxt.Error(f'box_border must be a list or tuple of 1-4 non-negative ints, got {box_border!s} instead')
+
+    output_path = str(TempStore.create_path(extension='.mp4'))
+
+    drawtext_params = _create_drawtext_params(
+        text,
+        font,
+        font_size,
+        color,
+        opacity,
+        horizontal_align,
+        horizontal_margin,
+        vertical_align,
+        vertical_margin,
+        box,
+        box_color,
+        box_opacity,
+        box_border,
+    )
+
+    cmd = [
+        'ffmpeg',
+        '-i',
+        str(video),
+        '-vf',
+        'drawtext=' + ':'.join(drawtext_params),
+        '-c:a',
+        'copy',  # Copy audio stream unchanged
+        '-loglevel',
+        'error',  # Only show errors
+        output_path,
+    ]
+    _logger.debug(f'overlay_text(): {" ".join(cmd)}')
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        output_file = pathlib.Path(output_path)
+        if not output_file.exists() or output_file.stat().st_size == 0:
+            stderr_output = result.stderr.strip() if result.stderr is not None else ''
+            raise pxt.Error(f'ffmpeg failed to create output file for commandline: {" ".join(cmd)}\n{stderr_output}')
+        return output_path
+    except subprocess.CalledProcessError as e:
+        _handle_ffmpeg_error(e)
+
+
+def _create_drawtext_params(
+    text: str,
+    font: str | None,
+    font_size: int,
+    color: str,
+    opacity: float,
+    horizontal_align: str,
+    horizontal_margin: int,
+    vertical_align: str,
+    vertical_margin: int,
+    box: bool,
+    box_color: str,
+    box_opacity: float,
+    box_border: list[int] | None,
+) -> list[str]:
+    """Construct parameters for the ffmpeg drawtext filter"""
+    drawtext_params: list[str] = []
+    escaped_text = text.replace('\\', '\\\\').replace(':', '\\:').replace("'", "\\'")
+    drawtext_params.append(f"text='{escaped_text}'")
+    drawtext_params.append(f'fontsize={font_size}')
+
+    if font is not None:
+        if pathlib.Path(font).exists():
+            drawtext_params.append(f"fontfile='{font}'")
+        else:
+            drawtext_params.append(f"font='{font}'")
+    if opacity < 1.0:
+        drawtext_params.append(f'fontcolor={color}@{opacity}')
+    else:
+        drawtext_params.append(f'fontcolor={color}')
+
+    if horizontal_align == 'left':
+        x_expr = str(horizontal_margin)
+    elif horizontal_align == 'center':
+        x_expr = '(w-text_w)/2'
+    else:  # right
+        x_expr = f'w-text_w-{horizontal_margin}' if horizontal_margin != 0 else 'w-text_w'
+    if vertical_align == 'top':
+        y_expr = str(vertical_margin)
+    elif vertical_align == 'center':
+        y_expr = '(h-text_h)/2'
+    else:  # bottom
+        y_expr = f'h-text_h-{vertical_margin}' if vertical_margin != 0 else 'h-text_h'
+    drawtext_params.extend([f'x={x_expr}', f'y={y_expr}'])
+
+    if box:
+        drawtext_params.append('box=1')
+        if box_opacity < 1.0:
+            drawtext_params.append(f'boxcolor={box_color}@{box_opacity}')
+        else:
+            drawtext_params.append(f'boxcolor={box_color}')
+        if box_border is not None:
+            drawtext_params.append(f'boxborderw={"|".join(map(str, box_border))}')
+
+    return drawtext_params
 
 
 __all__ = local_public_names(__name__)

pixeltable/functions/whisper.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING, Optional, Sequence
 
 import pixeltable as pxt
 from pixeltable.env import Env
+from pixeltable.utils.code import local_public_names
 
 if TYPE_CHECKING:
     from whisper import Whisper  # type: ignore[import-untyped]
@@ -90,3 +91,10 @@ def _lookup_model(model_id: str, device: str) -> 'Whisper':
 
 
 _model_cache: dict[tuple[str, str], 'Whisper'] = {}
+
+
+__all__ = local_public_names(__name__)
+
+
+def __dir__() -> list[str]:
+    return __all__

pixeltable/iterators/__init__.py

@@ -5,7 +5,7 @@ from .base import ComponentIterator
 from .document import DocumentSplitter
 from .image import TileIterator
 from .string import StringSplitter
-from .video import FrameIterator
+from .video import FrameIterator, VideoSplitter
 
 __default_dir = {symbol for symbol in dir() if not symbol.startswith('_')}
 __removed_symbols = {'base', 'document', 'video'}

pixeltable/iterators/video.py

@@ -1,5 +1,7 @@
 import logging
 import math
+import shutil
+import subprocess
 from fractions import Fraction
 from pathlib import Path
 from typing import Any, Optional
@@ -8,8 +10,11 @@ import av
 import pandas as pd
 import PIL.Image
 
+import pixeltable as pxt
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
+import pixeltable.utils.av as av_utils
+from pixeltable.utils.media_store import TempStore
 
 from .base import ComponentIterator
 
@@ -224,3 +229,136 @@ class FrameIterator(ComponentIterator):
         # then the iterator will step forward to the desired frame on the subsequent call to next().
         self.container.seek(seek_pos, backward=True, stream=self.container.streams.video[0])
         self.next_pos = pos
+
+
+class VideoSplitter(ComponentIterator):
+    """
+    Iterator over segments of a video file, which is split into fixed-size segments of length `segment_duration`
+    seconds.
+
+    Args:
+        segment_duration: Video segment duration in seconds
+        overlap: Overlap between consecutive segments in seconds.
+        min_segment_duration: Drop the last segment if it is smaller than min_segment_duration
+    """
+
+    # Input parameters
+    video_path: Path
+    segment_duration: float
+    overlap: float
+    min_segment_duration: float
+
+    # Video metadata
+    video_duration: float
+    video_time_base: Fraction
+    video_start_time: int
+
+    # position tracking
+    next_segment_start: float
+    next_segment_start_pts: int
+
+    def __init__(self, video: str, segment_duration: float, *, overlap: float = 0.0, min_segment_duration: float = 0.0):
+        assert segment_duration > 0.0
+        assert segment_duration >= min_segment_duration
+        assert overlap < segment_duration
+
+        video_path = Path(video)
+        assert video_path.exists() and video_path.is_file()
+
+        if not shutil.which('ffmpeg'):
+            raise pxt.Error('ffmpeg is not installed or not in PATH. Please install ffmpeg to use VideoSplitter.')
+
+        self.video_path = video_path
+        self.segment_duration = segment_duration
+        self.overlap = overlap
+        self.min_segment_duration = min_segment_duration
+
+        with av.open(str(video_path)) as container:
+            video_stream = container.streams.video[0]
+            self.video_time_base = video_stream.time_base
+            self.video_start_time = video_stream.start_time or 0
+
+        self.next_segment_start = float(self.video_start_time * self.video_time_base)
+        self.next_segment_start_pts = self.video_start_time
+
+    @classmethod
+    def input_schema(cls) -> dict[str, ts.ColumnType]:
+        return {
+            'video': ts.VideoType(nullable=False),
+            'segment_duration': ts.FloatType(nullable=False),
+            'overlap': ts.FloatType(nullable=True),
+            'min_segment_duration': ts.FloatType(nullable=True),
+        }
+
+    @classmethod
+    def output_schema(cls, *args: Any, **kwargs: Any) -> tuple[dict[str, ts.ColumnType], list[str]]:
+        param_names = ['segment_duration', 'overlap', 'min_segment_duration']
+        params = dict(zip(param_names, args))
+        params.update(kwargs)
+
+        segment_duration = params['segment_duration']
+        min_segment_duration = params.get('min_segment_duration', 0.0)
+        overlap = params.get('overlap', 0.0)
+
+        if segment_duration <= 0.0:
+            raise excs.Error('segment_duration must be a positive number')
+        if segment_duration < min_segment_duration:
+            raise excs.Error('segment_duration must be at least min_segment_duration')
+        if overlap >= segment_duration:
+            raise excs.Error('overlap must be less than segment_duration')
+
+        return {
+            'segment_start': ts.FloatType(nullable=False),
+            'segment_start_pts': ts.IntType(nullable=False),
+            'segment_end': ts.FloatType(nullable=False),
+            'segment_end_pts': ts.IntType(nullable=False),
+            'video_segment': ts.VideoType(nullable=False),
+        }, []
+
+    def __next__(self) -> dict[str, Any]:
+        segment_path = str(TempStore.create_path(extension='.mp4'))
+        try:
+            cmd = av_utils.ffmpeg_clip_cmd(
+                str(self.video_path), segment_path, self.next_segment_start, self.segment_duration
+            )
+            _ = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+            # use the actual duration
+            segment_duration = av_utils.get_video_duration(segment_path)
+            if segment_duration - self.overlap == 0.0:
+                # we're done
+                Path(segment_path).unlink()
+                raise StopIteration
+
+            if segment_duration < self.min_segment_duration:
+                Path(segment_path).unlink()
+                raise StopIteration
+
+            segment_end = self.next_segment_start + segment_duration
+            segment_end_pts = self.next_segment_start_pts + round(segment_duration / self.video_time_base)
+
+            result = {
+                'segment_start': self.next_segment_start,
+                'segment_start_pts': self.next_segment_start_pts,
+                'segment_end': segment_end,
+                'segment_end_pts': segment_end_pts,
+                'video_segment': segment_path,
+            }
+            self.next_segment_start = segment_end - self.overlap
+            self.next_segment_start_pts = segment_end_pts - round(self.overlap / self.video_time_base)
+
+            return result
+
+        except subprocess.CalledProcessError as e:
+            if Path(segment_path).exists():
+                Path(segment_path).unlink()
+            error_msg = f'ffmpeg failed with return code {e.returncode}'
+            if e.stderr:
+                error_msg += f': {e.stderr.strip()}'
+            raise pxt.Error(error_msg) from e
+
+    def close(self) -> None:
+        pass
+
+    def set_pos(self, pos: int) -> None:
+        pass

pixeltable/utils/av.py

@@ -0,0 +1,111 @@
+from typing import Any
+
+import av
+import av.stream
+
+
+def get_metadata(path: str) -> dict:
+    with av.open(path) as container:
+        assert isinstance(container, av.container.InputContainer)
+        streams_info = [__get_stream_metadata(stream) for stream in container.streams]
+        result = {
+            'bit_exact': getattr(container, 'bit_exact', False),
+            'bit_rate': container.bit_rate,
+            'size': container.size,
+            'metadata': container.metadata,
+            'streams': streams_info,
+        }
+    return result
+
+
+def __get_stream_metadata(stream: av.stream.Stream) -> dict:
+    if stream.type not in ('audio', 'video'):
+        return {'type': stream.type}  # Currently unsupported
+
+    codec_context = stream.codec_context
+    codec_context_md: dict[str, Any] = {
+        'name': codec_context.name,
+        'codec_tag': codec_context.codec_tag.encode('unicode-escape').decode('utf-8'),
+        'profile': codec_context.profile,
+    }
+    metadata = {
+        'type': stream.type,
+        'duration': stream.duration,
+        'time_base': float(stream.time_base) if stream.time_base is not None else None,
+        'duration_seconds': float(stream.duration * stream.time_base)
+        if stream.duration is not None and stream.time_base is not None
+        else None,
+        'frames': stream.frames,
+        'metadata': stream.metadata,
+        'codec_context': codec_context_md,
+    }
+
+    if stream.type == 'audio':
+        # Additional metadata for audio
+        channels = getattr(stream.codec_context, 'channels', None)
+        codec_context_md['channels'] = int(channels) if channels is not None else None
+    else:
+        assert stream.type == 'video'
+        assert isinstance(stream, av.video.stream.VideoStream)
+        # Additional metadata for video
+        codec_context_md['pix_fmt'] = getattr(stream.codec_context, 'pix_fmt', None)
+        metadata.update(
+            **{
+                'width': stream.width,
+                'height': stream.height,
+                'frames': stream.frames,
+                'average_rate': float(stream.average_rate) if stream.average_rate is not None else None,
+                'base_rate': float(stream.base_rate) if stream.base_rate is not None else None,
+                'guessed_rate': float(stream.guessed_rate) if stream.guessed_rate is not None else None,
+            }
+        )
+
+    return metadata
+
+
+def get_video_duration(path: str) -> float | None:
+    """Return video duration in seconds."""
+    with av.open(path) as container:
+        video_stream = container.streams.video[0]
+        if video_stream is None:
+            return None
+        if video_stream.duration is not None:
+            return float(video_stream.duration * video_stream.time_base)
+
+        # if duration is not in the header, look for it in the last packet
+        last_pts: int | None = None
+        for packet in container.demux(video_stream):
+            if packet.pts is not None:
+                last_pts = packet.pts
+        if last_pts is not None:
+            return float(last_pts * video_stream.time_base)
+
+        return None
+
+
+def has_audio_stream(path: str) -> bool:
+    """Check if video has audio stream using PyAV."""
+    md = get_metadata(path)
+    return any(stream['type'] == 'audio' for stream in md['streams'])
+
+
+def ffmpeg_clip_cmd(input_path: str, output_path: str, start_time: float, duration: float | None = None) -> list[str]:
+    # the order of arguments is critical: -ss <start> -t <duration> -i <input>
+    cmd = ['ffmpeg', '-ss', str(start_time)]
+    if duration is not None:
+        cmd.extend(['-t', str(duration)])
+    cmd.extend(
+        [
+            '-i',  # Input file
+            input_path,
+            '-y',  # Overwrite output file
+            '-loglevel',
+            'error',  # Only show errors
+            '-c',
+            'copy',  # Stream copy (no re-encoding)
+            '-map',
+            '0',  # Copy all streams from input
+            output_path,
+        ]
+    )
+    return cmd

pixeltable/utils/code.py

@@ -21,7 +21,8 @@ def local_public_names(mod_name: str, exclude: Optional[list[str]] = None) -> li
     for obj in mod.__dict__.values():
         if isinstance(obj, Function):
             # Pixeltable function
-            names.append(obj.name)
+            if not obj.name.startswith('_'):
+                names.append(obj.name)
         elif isinstance(obj, types.FunctionType):
             # Python function
             if obj.__module__ == mod.__name__ and not obj.__name__.startswith('_'):

{pixeltable-0.4.9.dist-info → pixeltable-0.4.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pixeltable
-Version: 0.4.9
+Version: 0.4.11
 Summary: AI Data Infrastructure: Declarative, Multimodal, and Incremental
 Project-URL: homepage, https://pixeltable.com/
 Project-URL: repository, https://github.com/pixeltable/pixeltable

{pixeltable-0.4.9.dist-info → pixeltable-0.4.11.dist-info}/RECORD

@@ -2,7 +2,7 @@ pixeltable/__init__.py,sha256=wJ_4oQdkBAaaVKM8XiZKKSsWPnoemZxh34o6_5vDcxk,1562
 pixeltable/__version__.py,sha256=LnMIuAxx6nAQDMev_jnZyUdgsaiE3F8lulfXQBRl9qQ,112
 pixeltable/config.py,sha256=-aoSVF0Aak83IC-u-XANw3if76TDq5VnnWNWoFDR5Hc,8390
 pixeltable/dataframe.py,sha256=I6iEJGD4pivUN-cPVFq_rcniZN7C55xpr37sMJ2BIdE,62986
-pixeltable/env.py,sha256=EZXZPx-OKNo-QqOik1tZyJKSK0brM_b3p2r9ksS6JJs,42964
+pixeltable/env.py,sha256=vmqDgsfonYLYubsR1N4n5H7aSo4MXtlnBN1Z8xFOeFI,44443
 pixeltable/exceptions.py,sha256=Gm8d3TL2iiv6Pj2DLd29wp_j41qNBhxXL9iTQnL4Nk4,1116
 pixeltable/globals.py,sha256=8NijkEmtjY5me6J8zF4G-t1v5_z4q7btOK2yjUREUak,39118
 pixeltable/plan.py,sha256=4yAe7ExAqaSvkFxwK7LPH_HpmoumwqoLeOo7czJ8CyQ,48001
@@ -83,12 +83,12 @@ pixeltable/func/tools.py,sha256=2_M_u0Jiy5-uToZziB4O54aTuJeaytPmh71q3I2ydNw,6062
 pixeltable/func/udf.py,sha256=6tKpMt37t3BmXwRyA5fFAd6OM4D5EPEd2KuAr7DQhr0,13231
 pixeltable/functions/__init__.py,sha256=ZeRB7ksbzjdrvePXtd_mNxyP2RhjvN0ayl5nv7TdWcQ,613
 pixeltable/functions/anthropic.py,sha256=2Ja-pryC_3Yd1sXW-pibRuvKjgyfYqOhhl6nBWNOBt0,10504
-pixeltable/functions/audio.py,sha256=6_tUhSZgxhOQQJemvZYNEoKNjWdr3SgJsvLkKCSmtfw,1633
+pixeltable/functions/audio.py,sha256=S9xSg45Fx5kmB4NxOTSG99_5Kxc8kFfxuawV7qjMeS8,1660
 pixeltable/functions/bedrock.py,sha256=lTCFHjYunF3minBGWcjXR90yJ8resFjXr4niyKhfxms,4217
 pixeltable/functions/date.py,sha256=qs1svJ9FVod3OTa5hQNKIuashb6tVhW_2EAEXYGQX74,5308
 pixeltable/functions/deepseek.py,sha256=iw59TKKcw3VqbHMHB2ugtcTPeTVKuHp_3pfkjF6DYmE,3550
 pixeltable/functions/fireworks.py,sha256=q7eWlYfiWbA0d9r3CB_NAe1fw3q-Z7qsw2gyGJNgWLQ,4786
-pixeltable/functions/gemini.py,sha256=beGMdpcL55mLaMMJkIL_TZrGdLJRL1RP-GkEuC6m8fs,8781
+pixeltable/functions/gemini.py,sha256=igtpGBiVekkaWtVE6X04pQ7C9md8nY42W7xU_XuMayE,8924
 pixeltable/functions/globals.py,sha256=OyPJUJ4S6VWyzxstxIzk3xzYBGIEMwgk1RmSTWTZzdI,5106
 pixeltable/functions/groq.py,sha256=FpR_LJpfZfzyhEvoBMMbQpQ-VQSRzBsS9U21qaINwww,3593
 pixeltable/functions/huggingface.py,sha256=Y-io3EungSs5ibr43vLEXs4dz_Ej20F1nglD0fyLrXA,20371
@@ -104,9 +104,9 @@ pixeltable/functions/string.py,sha256=LdBNOna5PUSPmM5VlJ_qhmwzyFhumW0k6Dvx2rXSZt
 pixeltable/functions/timestamp.py,sha256=3GVCVIWdry96Qk5XXuvbJ58Tp30iY5snBibzl2CHjQc,9143
 pixeltable/functions/together.py,sha256=A8J19BXywyWQ6a2_n05-8uIG5jquOBGqPmW3mb-NrIc,8842
 pixeltable/functions/util.py,sha256=uQNkyBSkTVMe1wbUI2Q0nz-mM3qPVTF86yK8c9OFIcE,954
-pixeltable/functions/video.py,sha256=Z0X0Z-oCS-c4cqjlfCPLUxvTUAkQdxDZ-tL-jAIKKA0,10590
+pixeltable/functions/video.py,sha256=0Hgfi3PHA2BPVpgWEQ3RffFtvc2YkjX3UX3dXSzrEJk,27009
 pixeltable/functions/vision.py,sha256=17h9bOm3NJyQzFMBwXDHMqnkcuCspyQJgHdBOXV1Ip8,15380
-pixeltable/functions/whisper.py,sha256=c9E6trhc2UcShVaGaEBCUEpArke1ql3MV5We0qSgmuU,2960
+pixeltable/functions/whisper.py,sha256=u2QcDU7JdtgLIImCkFPkzjWEjLTJIrlSkAWqeITyIJw,3103
 pixeltable/functions/whisperx.py,sha256=BT9gwXEf5V1lgDxynkrrH6gsuCLqjCzfMJKj5DaOtSM,7661
 pixeltable/functions/yolox.py,sha256=ZdYr6WIqTCHOJoZSoXe4CbME54dYeeeOhkOi1I7VtcE,3518
 pixeltable/index/__init__.py,sha256=97aFuxiP_oz1ldn5iq8IWApkOV8XG6ZIBW5-9rkS0vM,122
@@ -124,13 +124,13 @@ pixeltable/io/pandas.py,sha256=xQmkwbqE9_fjbbPUgeG5yNICrbVVK73UHxDL-cgrQw0,9007
 pixeltable/io/parquet.py,sha256=qoVDuCoW-Tq14IlzN_psoNP7z83hIQ3ZEg_pKzHSqoY,7796
 pixeltable/io/table_data_conduit.py,sha256=--UWwG6agBtOA5PLPfjxp2XKoAQ-f5nSPJqOgA5DAAI,22062
 pixeltable/io/utils.py,sha256=qzBTmqdIawXMt2bfXQOraYnEstL69eC2Z33nl8RrwJk,4244
-pixeltable/iterators/__init__.py,sha256=bU4EmbX85J1URmRw6G71f2I77b1ctqngEOwDmRB3T0w,455
+pixeltable/iterators/__init__.py,sha256=hI937cmBRU3eWbfJ7miFthAGUo_xmcYciw6gAjOCg9g,470
 pixeltable/iterators/audio.py,sha256=HYE8JcqaJsTGdrq4NkwV5tn7lcyMp6Fjrm59efOLzb0,9671
 pixeltable/iterators/base.py,sha256=ZC0ZvXL4iw6AmT8cu-Mdx-T2UG9nmJYV1C6LK4efAfw,1669
 pixeltable/iterators/document.py,sha256=7NIN5W5jHVm4v5_FzGsH0XJigtPCm8DfXJUc3_hEtHQ,20073
 pixeltable/iterators/image.py,sha256=RrFdf5cnFIQzWKJk4uYi1m1p2qAiz909THYhRQ27DbY,3603
 pixeltable/iterators/string.py,sha256=URj5edWp-CsorjN_8nnfWGvtIFs_Zh4VPm6htlJbFkU,1257
-pixeltable/iterators/video.py,sha256=PKztCS_FEtu-AoHR6X-wJG6UJddX195lS-9eQp5ClGc,10810
+pixeltable/iterators/video.py,sha256=aKT2YxZGUsAifkWK434RDnqZj_gGtcQ1waN9AV98fMA,16105
 pixeltable/metadata/__init__.py,sha256=oTO9kN6h4xJ2lsk4a2bq6ejAD-4wToy7b5_i3Pq1Qnc,3289
 pixeltable/metadata/notes.py,sha256=3fdZDFpL1-b194Ejv0Y0YP-vbnV-XvVP9wOmZM9XARA,1545
 pixeltable/metadata/schema.py,sha256=fs9W2SLh32Ehxc9AChVH7YCtlSSnQkgGMbEyOh0B4W0,13416
@@ -172,8 +172,9 @@ pixeltable/share/packager.py,sha256=5rSKnQCs3YP5h48d79bXEK4L8tLUSeTSbXaB8X9SmBI,
 pixeltable/share/publish.py,sha256=KS_R59AuVkHWkXHwELP74xgSHs8Z5z8SBPMcjzttt44,11469
 pixeltable/utils/__init__.py,sha256=45qEM20L2VuIe-Cc3BTKWFqQb-S7A8qDtmmgl77zYK0,1728
 pixeltable/utils/arrow.py,sha256=Rooa02GL5k--D2utlKATtYKrrlsHbbi6JmkarXMux1M,6384
+pixeltable/utils/av.py,sha256=omJufz62dzaTTwlR7quKfcT7apf8KkBLJ9cQ9240dt0,4016
 pixeltable/utils/coco.py,sha256=Y1DWVYguZD4VhKyf7JruYfHWvhkJLq39fzbiSm5cdyY,7304
-pixeltable/utils/code.py,sha256=SbG5OUF_fQAbOgGZHDuENijmbzisVqa4VS9guaZ0KtU,1231
+pixeltable/utils/code.py,sha256=3CZMVJm69JIG5sxmd56mjB4Fo4L-s0_Y8YvQeJIj0F0,1280
 pixeltable/utils/console_output.py,sha256=x23iDnNwUbsr7Ec20BQ7BLATTsrQZflxc9NucAt_sVU,1150
 pixeltable/utils/coroutine.py,sha256=d87kLlkVIZq2u0kTE7kJ5Tc_yjEkdGi5sXAuxjLLxXY,896
 pixeltable/utils/dbms.py,sha256=cuQqlzLF7WON_mkJZ4QWlfX6lCxA97V32lhtMcOlDLg,2018
@@ -190,8 +191,8 @@ pixeltable/utils/pytorch.py,sha256=564VHRdDHwD9h0v5lBHEDTJ8c6zx8wuzWYx8ZYjBxlI,3
 pixeltable/utils/s3.py,sha256=pxip2MlCqd2Qon2dzJXzfxvwtZyc-BAsjAnLL4J_OXY,587
 pixeltable/utils/sql.py,sha256=Sa4Lh-VGe8GToU5W7DRiWf2lMl9B6saPqemiT0ZdHEc,806
 pixeltable/utils/transactional_directory.py,sha256=OFKmu90oP7KwBAljwjnzP_w8euGdAXob3y4Nx9SCNHA,1357
-pixeltable-0.4.9.dist-info/METADATA,sha256=OvTlQgjU2P7wXoyAQhd8p4MrQU1jv5btGrtIHhRF9so,24247
-pixeltable-0.4.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pixeltable-0.4.9.dist-info/entry_points.txt,sha256=rrKugZmxDtGnXCnEQ5UJMaaSYY7-g1cLjUZ4W1moIhM,98
-pixeltable-0.4.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pixeltable-0.4.9.dist-info/RECORD,,
+pixeltable-0.4.11.dist-info/METADATA,sha256=HVVzENixWm3Kc_3PBsO-sDo7M3LF8IpNwwcuU4bUvQk,24248
+pixeltable-0.4.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pixeltable-0.4.11.dist-info/entry_points.txt,sha256=rrKugZmxDtGnXCnEQ5UJMaaSYY7-g1cLjUZ4W1moIhM,98
+pixeltable-0.4.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pixeltable-0.4.11.dist-info/RECORD,,