pixeltable 0.2.21__py3-none-any.whl → 0.2.23__py3-none-any.whl

pixeltable/metadata/converters/util.py

@@ -4,7 +4,7 @@ from typing import Any, Callable, Optional
 
 import sqlalchemy as sql
 
-from pixeltable.metadata.schema import Table
+from pixeltable.metadata.schema import Table, TableSchemaVersion
 
 __logger = logging.getLogger('pixeltable')
 
@@ -17,12 +17,12 @@ def convert_table_md(
     substitution_fn: Optional[Callable[[Optional[str], Any], Optional[tuple[Optional[str], Any]]]] = None
 ) -> None:
     """
-    Converts table metadata based on the specified conversion functions.
+    Converts schema.TableMd dicts based on the specified conversion functions.
 
     Args:
         engine: The SQLAlchemy engine.
-        table_md_updater: A function that updates the table metadata in place.
-        column_md_updater: A function that updates the column metadata in place.
+        table_md_updater: A function that updates schema.TableMd dicts in place.
+        column_md_updater: A function that updates schema.ColumnMd dicts in place.
         external_store_md_updater: A function that updates the external store metadata in place.
         substitution_fn: A function that substitutes metadata values. If specified, all metadata will be traversed
             recursively, and `substitution_fn` will be called once for each metadata entry. If the entry appears in
@@ -90,3 +90,44 @@ def __substitute_md_rec(
         return updated_list
     else:
         return md
+
+
+def convert_table_schema_version_md(
+    engine: sql.engine.Engine,
+    table_schema_version_md_updater: Optional[Callable[[dict], None]] = None,
+    schema_column_updater: Optional[Callable[[dict], None]] = None
+) -> None:
+    """
+    Converts schema.TableSchemaVersionMd dicts based on the specified conversion functions.
+
+    Args:
+        engine: The SQLAlchemy engine.
+        table_schema_version_md_updater: A function that updates schema.TableSchemaVersionMd dicts in place.
+        schema_column_updater: A function that updates schema.SchemaColumn dicts in place.
+    """
+    with engine.begin() as conn:
+        stmt = sql.select(TableSchemaVersion.tbl_id, TableSchemaVersion.schema_version, TableSchemaVersion.md)
+        for row in conn.execute(stmt):
+            tbl_id, schema_version, md = row[0], row[1], row[2]
+            assert isinstance(md, dict)
+            updated_md = copy.deepcopy(md)
+            if table_schema_version_md_updater is not None:
+                table_schema_version_md_updater(updated_md)
+            if schema_column_updater is not None:
+                __update_schema_column(updated_md, schema_column_updater)
+            if updated_md != md:
+                __logger.info(f'Updating TableSchemaVersion(tbl_id={tbl_id}, schema_version={schema_version})')
+                update_stmt = (
+                    sql.update(TableSchemaVersion)
+                    .where(TableSchemaVersion.tbl_id == tbl_id)
+                    .where(TableSchemaVersion.schema_version == schema_version)
+                    .values(md=updated_md)
+                )
+                conn.execute(update_stmt)
+
+
+def __update_schema_column(table_schema_version_md: dict, schema_column_updater: Callable[[dict], None]) -> None:
+    cols = table_schema_version_md['columns']
+    assert isinstance(cols, dict)
+    for schema_col in cols.values():
+        schema_column_updater(schema_col)

pixeltable/metadata/notes.py

@@ -2,6 +2,7 @@
 # rather than as a comment, so that the existence of a description can be enforced by
 # the unit tests when new versions are added.
 VERSION_NOTES = {
+    22: 'TableMd/ColumnMd.media_validation',
     21: 'Separate InlineArray and InlineList',
     20: 'Store DB timestamps in UTC',
     19: 'UDF renames; ImageMemberAccess removal',

pixeltable/metadata/schema.py

@@ -202,6 +202,10 @@ class SchemaColumn:
     pos: int
     name: str
 
+    # media validation strategy of this particular media column; if not set, TableMd.media_validation applies
+    # stores column.MediaValiation.name.lower()
+    media_validation: Optional[str]
+
 
 @dataclasses.dataclass
 class TableSchemaVersionMd:
@@ -214,6 +218,10 @@ class TableSchemaVersionMd:
     num_retained_versions: int
     comment: str
 
+    # default validation strategy for any media column of this table
+    # stores column.MediaValiation.name.lower()
+    media_validation: str
+
 
 # versioning: each table schema change results in a new record
 class TableSchemaVersion(Base):

pixeltable/plan.py

@@ -1,4 +1,4 @@
-from typing import Any, Iterable, Optional, Sequence, cast
+from typing import Any, Iterable, Optional, Sequence
 from uuid import UUID
 
 import sqlalchemy as sql
@@ -225,27 +225,28 @@ class Planner:
         assert not tbl.is_view()
         # stored_cols: all cols we need to store, incl computed cols (and indices)
         stored_cols = [c for c in tbl.cols if c.is_stored]
-        assert len(stored_cols) > 0
-
+        assert len(stored_cols) > 0  # there needs to be something to store
         row_builder = exprs.RowBuilder([], stored_cols, [])
 
         # create InMemoryDataNode for 'rows'
-        stored_col_info = row_builder.output_slot_idxs()
-        stored_img_col_info = [info for info in stored_col_info if info.col.col_type.is_image_type()]
-        input_col_info = [info for info in stored_col_info if not info.col.is_computed]
         plan: exec.ExecNode = exec.InMemoryDataNode(tbl, rows, row_builder, tbl.next_rowid)
 
-        media_input_cols = [info for info in input_col_info if info.col.col_type.is_media_type()]
-        if len(media_input_cols) > 0:
-            # prefetch external files for all input column refs for validation
-            plan = exec.CachePrefetchNode(tbl.id, media_input_cols, input=plan)
-            plan = exec.MediaValidationNode(row_builder, media_input_cols, input=plan)
+        media_input_col_info = [
+            exprs.ColumnSlotIdx(col_ref.col, col_ref.slot_idx)
+            for col_ref in row_builder.input_exprs
+            if isinstance(col_ref, exprs.ColumnRef) and col_ref.col_type.is_media_type()
+        ]
+        if len(media_input_col_info) > 0:
+            # prefetch external files for all input column refs
+            plan = exec.CachePrefetchNode(tbl.id, media_input_col_info, input=plan)
 
-        computed_exprs = [e for e in row_builder.default_eval_ctx.target_exprs if not isinstance(e, exprs.ColumnRef)]
+        computed_exprs = row_builder.output_exprs - row_builder.input_exprs
         if len(computed_exprs) > 0:
             # add an ExprEvalNode when there are exprs to compute
             plan = exec.ExprEvalNode(row_builder, computed_exprs, plan.output_exprs, input=plan)
 
+        stored_col_info = row_builder.output_slot_idxs()
+        stored_img_col_info = [info for info in stored_col_info if info.col.col_type.is_image_type()]
         plan.set_stored_img_cols(stored_img_col_info)
         plan.set_ctx(
             exec.ExecContext(
@@ -621,7 +622,8 @@ class Planner:
         assert isinstance(tbl, catalog.TableVersionPath)
         sql_elements = analyzer.sql_elements
         is_python_agg = (
-            not sql_elements.contains(analyzer.agg_fn_calls) or not sql_elements.contains(analyzer.window_fn_calls)
+            not sql_elements.contains_all(analyzer.agg_fn_calls)
+            or not sql_elements.contains_all(analyzer.window_fn_calls)
         )
         ctx = exec.ExecContext(row_builder)
         cls._verify_ordering(analyzer, verify_agg=is_python_agg)
@@ -671,8 +673,8 @@ class Planner:
             ctx.batch_size = 16
 
             # do aggregation in SQL if all agg exprs can be translated
-            if (sql_elements.contains(analyzer.select_list)
-                    and sql_elements.contains(analyzer.grouping_exprs)
+            if (sql_elements.contains_all(analyzer.select_list)
+                    and sql_elements.contains_all(analyzer.grouping_exprs)
                     and isinstance(plan, exec.SqlNode)
                     and plan.to_cte() is not None):
                 plan = exec.SqlAggregationNode(

pixeltable/store.py

@@ -303,7 +303,7 @@ class StoreBase:
 
     def insert_rows(
             self, exec_plan: ExecNode, conn: sql.engine.Connection, v_min: Optional[int] = None,
-            show_progress: bool = True, rowids: Optional[Iterator[int]] = None
+            show_progress: bool = True, rowids: Optional[Iterator[int]] = None, abort_on_exc: bool = False
     ) -> tuple[int, int, set[int]]:
         """Insert rows into the store table and update the catalog table's md
         Returns:
@@ -325,8 +325,13 @@ class StoreBase:
                 for batch_start_idx in range(0, len(row_batch), self.__INSERT_BATCH_SIZE):
                     # compute batch of rows and convert them into table rows
                     table_rows: list[dict[str, Any]] = []
-                    for row_idx in range(batch_start_idx, min(batch_start_idx + self.__INSERT_BATCH_SIZE, len(row_batch))):
+                    batch_stop_idx = min(batch_start_idx + self.__INSERT_BATCH_SIZE, len(row_batch))
+                    for row_idx in range(batch_start_idx, batch_stop_idx):
                         row = row_batch[row_idx]
+                        # if abort_on_exc == True, we need to check for media validation exceptions
+                        if abort_on_exc and row.has_exc():
+                            exc = row.get_first_exc()
+                            raise exc
 
                         rowid = (next(rowids),) if rowids is not None else row.pk[:-1]
                         pk = rowid + (v_min,)

pixeltable/tool/create_test_db_dump.py

@@ -153,7 +153,7 @@ class Dumper:
         self.__add_expr_columns(v, 'view')
 
         # snapshot
-        _ = pxt.create_view('views.snapshot', t.where(t.c2 >= 75), is_snapshot=True)
+        _ = pxt.create_snapshot('views.snapshot', t.where(t.c2 >= 75))
 
         # view of views
         vv = pxt.create_view('views.view_of_views', v.where(t.c2 >= 25))

pixeltable/tool/create_test_video.py

@@ -1,4 +1,4 @@
-import av
+import av  # type: ignore[import-untyped]
 import PIL.Image
 import PIL.ImageDraw
 import PIL.ImageFont

pixeltable/tool/embed_udf.py

@@ -6,4 +6,4 @@ import pixeltable as pxt
 # TODO This can go away once we have the ability to inline expr_udf's
 @pxt.expr_udf
 def clip_text_embed(txt: str) -> np.ndarray:
-    return pxt.functions.huggingface.clip_text(txt, model_id='openai/clip-vit-base-patch32')
+    return pxt.functions.huggingface.clip_text(txt, model_id='openai/clip-vit-base-patch32')  # type: ignore[return-value]

pixeltable/tool/mypy_plugin.py

@@ -1,12 +1,15 @@
 from typing import Callable, Optional
 
-from mypy.plugin import AnalyzeTypeContext, Plugin
-from mypy.types import Type
+from mypy import nodes
+from mypy.plugin import AnalyzeTypeContext, ClassDefContext, Plugin
+from mypy.plugins.common import add_method_to_class
+from mypy.types import AnyType, Type, TypeOfAny
 
 import pixeltable as pxt
 
 
 class PxtPlugin(Plugin):
+    __UDA_FULLNAME = f'{pxt.uda.__module__}.{pxt.uda.__name__}'
     __TYPE_MAP = {
         pxt.Json: 'typing.Any',
         pxt.Array: 'numpy.ndarray',
@@ -20,13 +23,33 @@ class PxtPlugin(Plugin):
         for k, v in __TYPE_MAP.items()
     }
 
-    def get_type_analyze_hook(self, fullname: str) -> Optional[Callable[[AnalyzeTypeContext], type]]:
+    def get_type_analyze_hook(self, fullname: str) -> Optional[Callable[[AnalyzeTypeContext], Type]]:
         if fullname in self.__FULLNAME_MAP:
             subst_name = self.__FULLNAME_MAP[fullname]
             return lambda ctx: pxt_hook(ctx, subst_name)
+        return None
 
-def plugin(version: str):
+    def get_class_decorator_hook_2(self, fullname: str) -> Optional[Callable[[ClassDefContext], bool]]:
+        if fullname == self.__UDA_FULLNAME:
+            return pxt_decorator_hook
+        return None
+
+def plugin(version: str) -> type:
     return PxtPlugin
 
 def pxt_hook(ctx: AnalyzeTypeContext, subst_name: str) -> Type:
-    return ctx.api.named_type(subst_name)
+    if subst_name == 'typing.Any':
+        return AnyType(TypeOfAny.special_form)
+    return ctx.api.named_type(subst_name, [])
+
+def pxt_decorator_hook(ctx: ClassDefContext) -> bool:
+    arg = nodes.Argument(nodes.Var('fn'), AnyType(TypeOfAny.special_form), None, nodes.ARG_POS)
+    add_method_to_class(
+        ctx.api,
+        ctx.cls,
+        "to_sql",
+        args=[arg],
+        return_type=AnyType(TypeOfAny.special_form),
+        is_staticmethod=True,
+    )
+    return True

pixeltable/type_system.py

@@ -3,16 +3,18 @@ from __future__ import annotations
 import abc
 import datetime
 import enum
+import io
 import json
+import types
 import typing
 import urllib.parse
 import urllib.request
 from pathlib import Path
 from typing import Any, Iterable, Mapping, Optional, Sequence, Union
 
+import PIL.Image
 import av  # type: ignore
 import numpy as np
-import PIL.Image
 import sqlalchemy as sql
 from typing import _GenericAlias  # type: ignore[attr-defined]
 from typing_extensions import _AnnotatedAlias
@@ -271,63 +273,110 @@ class ColumnType:
         return inferred_type
 
     @classmethod
-    def from_python_type(cls, t: Union[type, _GenericAlias], nullable_default: bool = False) -> Optional[ColumnType]:
-        if typing.get_origin(t) is typing.Union:
+    def from_python_type(
+        cls,
+        t: Union[type, _GenericAlias],
+        nullable_default: bool = False,
+        allow_builtin_types: bool = True
+    ) -> Optional[ColumnType]:
+        """
+        Convert a Python type into a Pixeltable `ColumnType` instance.
+
+        Args:
+            t: The Python type.
+            nullable_default: If True, then the returned `ColumnType` will be nullable unless it is marked as
+                `Required`.
+            allow_builtin_types: If True, then built-in types such as `str`, `int`, `float`, etc., will be
+                allowed (as in UDF definitions). If False, then only Pixeltable types such as `pxt.String`,
+                `pxt.Int`, etc., will be allowed (as in schema definitions). `Optional` and `Required`
+                designations will be allowed regardless.
+        """
+        origin = typing.get_origin(t)
+        if origin is typing.Union:
+            # Check if `t` has the form Optional[T].
             union_args = typing.get_args(t)
             if len(union_args) == 2 and type(None) in union_args:
                 # `t` is a type of the form Optional[T] (equivalently, Union[T, None] or Union[None, T]).
                 # We treat it as the underlying type but with nullable=True.
                 underlying_py_type = union_args[0] if union_args[1] is type(None) else union_args[1]
-                underlying = cls.from_python_type(underlying_py_type)
+                underlying = cls.from_python_type(underlying_py_type, allow_builtin_types=allow_builtin_types)
                 if underlying is not None:
                     return underlying.copy(nullable=True)
-        elif typing.get_origin(t) is typing.Annotated:
+        elif origin is Required:
+            required_args = typing.get_args(t)
+            assert len(required_args) == 1
+            return cls.from_python_type(
+                required_args[0],
+                nullable_default=False,
+                allow_builtin_types=allow_builtin_types
+            )
+        elif origin is typing.Annotated:
             annotated_args = typing.get_args(t)
             origin = annotated_args[0]
             parameters = annotated_args[1]
             if isinstance(parameters, ColumnType):
                 return parameters.copy(nullable=nullable_default)
-        elif typing.get_origin(t) is Required:
-            required_args = typing.get_args(t)
-            assert len(required_args) == 1
-            return cls.from_python_type(required_args[0], nullable_default=False)
         else:
-            # Discard type parameters to ensure that parameterized types such as `list[T]`
-            # are correctly mapped to Pixeltable types.
-            origin = typing.get_origin(t)
-            if origin is None:
-                # No type parameters; the origin type is just `t` itself
-                origin = t
-            if issubclass(origin, _PxtType):
-                return origin.as_col_type(nullable=nullable_default)
-            if origin is str:
-                return StringType(nullable=nullable_default)
-            if origin is int:
-                return IntType(nullable=nullable_default)
-            if origin is float:
-                return FloatType(nullable=nullable_default)
-            if origin is bool:
-                return BoolType(nullable=nullable_default)
-            if origin is datetime.datetime:
-                return TimestampType(nullable=nullable_default)
-            if origin is PIL.Image.Image:
-                return ImageType(nullable=nullable_default)
-            if issubclass(origin, Sequence) or issubclass(origin, Mapping):
-                return JsonType(nullable=nullable_default)
+            # It's something other than Optional[T], Required[T], or an explicitly annotated type.
+            if origin is not None:
+                # Discard type parameters to ensure that parameterized types such as `list[T]`
+                # are correctly mapped to Pixeltable types.
+                t = origin
+            if isinstance(t, type) and issubclass(t, _PxtType):
+                return t.as_col_type(nullable=nullable_default)
+            elif allow_builtin_types:
+                if t is str:
+                    return StringType(nullable=nullable_default)
+                if t is int:
+                    return IntType(nullable=nullable_default)
+                if t is float:
+                    return FloatType(nullable=nullable_default)
+                if t is bool:
+                    return BoolType(nullable=nullable_default)
+                if t is datetime.datetime:
+                    return TimestampType(nullable=nullable_default)
+                if t is PIL.Image.Image:
+                    return ImageType(nullable=nullable_default)
+                if issubclass(t, Sequence) or issubclass(t, Mapping):
+                    return JsonType(nullable=nullable_default)
         return None
 
     @classmethod
-    def normalize_type(cls, t: Union[ColumnType, type, _AnnotatedAlias], nullable_default: bool = False) -> ColumnType:
+    def normalize_type(
+        cls,
+        t: Union[ColumnType, type, _AnnotatedAlias],
+        nullable_default: bool = False,
+        allow_builtin_types: bool = True
+    ) -> ColumnType:
         """
         Convert any type recognizable by Pixeltable to its corresponding ColumnType.
         """
         if isinstance(t, ColumnType):
             return t
-        col_type = cls.from_python_type(t, nullable_default)
+        col_type = cls.from_python_type(t, nullable_default, allow_builtin_types)
         if col_type is None:
-            raise excs.Error(f'Unknown type: {t}')
+            cls.__raise_exc_for_invalid_type(t)
         return col_type
 
+    __TYPE_SUGGESTIONS: list[tuple[type, str]] = [
+        (str, 'pxt.String'),
+        (bool, 'pxt.Bool'),
+        (int, 'pxt.Int'),
+        (float, 'pxt.Float'),
+        (datetime.datetime, 'pxt.Timestamp'),
+        (PIL.Image.Image, 'pxt.Image'),
+        (Sequence, 'pxt.Json'),
+        (Mapping, 'pxt.Json'),
+    ]
+
+    @classmethod
+    def __raise_exc_for_invalid_type(cls, t: Union[type, _AnnotatedAlias]) -> None:
+        for builtin_type, suggestion in cls.__TYPE_SUGGESTIONS:
+            if t is builtin_type or (isinstance(t, type) and issubclass(t, builtin_type)):
+                name = t.__name__ if t.__module__ == 'builtins' else f'{t.__module__}.{t.__name__}'
+                raise excs.Error(f'Standard Python type `{name}` cannot be used here; use `{suggestion}` instead')
+        raise excs.Error(f'Unknown type: {t}')
+
     def validate_literal(self, val: Any) -> None:
         """Raise TypeError if val is not a valid literal for this type"""
         if val is None:
@@ -798,6 +847,20 @@ class ImageType(ColumnType):
     def to_sa_type(self) -> sql.types.TypeEngine:
         return sql.String()
 
+    def _create_literal(self, val: Any) -> Any:
+        if isinstance(val, str) and val.startswith('data:'):
+            # try parsing this as a `data:` URL, and if successful, decode the image immediately
+            try:
+                with urllib.request.urlopen(val) as response:
+                    b = response.read()
+                img = PIL.Image.open(io.BytesIO(b))
+                img.load()
+                return img
+            except Exception as exc:
+                errormsg_val = val if len(val) < 50 else val[:50] + '...'
+                raise excs.Error(f'data URL could not be decoded into a valid image: {errormsg_val}') from exc
+        return val
+
     def _validate_literal(self, val: Any) -> None:
         if isinstance(val, PIL.Image.Image):
             return
@@ -876,6 +939,7 @@ class DocumentType(ColumnType):
         HTML = 0
         MD = 1
         PDF = 2
+        XML = 3
 
     def __init__(self, nullable: bool = False, doc_formats: Optional[str] = None):
         super().__init__(self.Type.DOCUMENT, nullable=nullable)
@@ -963,7 +1027,7 @@ class Array(np.ndarray, _PxtType):
         `item` (the type subscript) must be a tuple with exactly two elements (in any order):
         - A tuple of `Optional[int]`s, specifying the shape of the array
         - A type, specifying the dtype of the array
-        Example: Array[(3, None, 2), float]
+        Example: Array[(3, None, 2), pxt.Float]
         """
         params = item if isinstance(item, tuple) else (item,)
         shape: Optional[tuple] = None
@@ -978,7 +1042,7 @@ class Array(np.ndarray, _PxtType):
             elif isinstance(param, type) or isinstance(param, _AnnotatedAlias):
                 if dtype is not None:
                     raise TypeError(f'Duplicate Array type parameter: {param}')
-                dtype = ColumnType.from_python_type(param)
+                dtype = ColumnType.normalize_type(param, allow_builtin_types=False)
             else:
                 raise TypeError(f'Invalid Array type parameter: {param}')
         if shape is None:

pixeltable/utils/coco.py

@@ -1,6 +1,6 @@
 import json
 from pathlib import Path
-from typing import Any, Dict, List, Set
+from typing import Any
 
 import PIL
 
@@ -22,7 +22,7 @@ Required format:
 }
 """
 
-def _verify_input_dict(input_dict: Dict[str, Any]) -> None:
+def _verify_input_dict(input_dict: dict[str, Any]) -> None:
     """Verify that input_dict is a valid input dict for write_coco_dataset()"""
     if not isinstance(input_dict, dict):
         raise excs.Error(f'Expected dict, got {input_dict}{format_msg}')
@@ -61,11 +61,11 @@ def write_coco_dataset(df: pxt.DataFrame, dest_path: Path) -> Path:
     images_dir = dest_path / 'images'
     images_dir.mkdir()
 
-    images: List[Dict[str, Any]] = []
+    images: list[dict[str, Any]] = []
     img_id = -1
-    annotations: List[Dict[str, Any]] = []
+    annotations: list[dict[str, Any]] = []
     ann_id = -1
-    categories: Set[Any] = set()
+    categories: set[Any] = set()
     for input_row in df._exec():
         if input_dict_slot_idx == -1:
             input_dict_expr = df._select_list_exprs[0]

pixeltable/utils/documents.py

@@ -35,6 +35,11 @@ def get_document_handle(path: str) -> Optional[DocumentHandle]:
         if md_ast is not None:
             return DocumentHandle(format=ts.DocumentType.DocumentFormat.MD, md_ast=md_ast)
 
+    if doc_format == '.xml':
+        bs_doc = get_xml_handle(path)
+        if bs_doc is not None:
+            return DocumentHandle(format=ts.DocumentType.DocumentFormat.XML, bs_doc=bs_doc)
+
     return None
 
 
@@ -54,7 +59,16 @@ def get_pdf_handle(path: str) -> Optional[fitz.Document]:
 def get_html_handle(path: str) -> Optional[bs4.BeautifulSoup]:
     try:
         with open(path, 'r', encoding='utf8') as fp:
-            doc = bs4.BeautifulSoup(fp, 'html.parser')
+            doc = bs4.BeautifulSoup(fp, 'lxml')
+        return doc if doc.find() is not None else None
+    except Exception:
+        return None
+
+
+def get_xml_handle(path: str) -> Optional[bs4.BeautifulSoup]:
+    try:
+        with open(path, 'r', encoding='utf8') as fp:
+            doc = bs4.BeautifulSoup(fp, 'xml')
         return doc if doc.find() is not None else None
     except Exception:
         return None

pixeltable/utils/formatter.py

@@ -1,16 +1,16 @@
 import base64
 import html
+import io
 import json
 import logging
 import mimetypes
 from typing import Any, Callable, Optional
 
+import av  # type: ignore[import-untyped]
+import numpy as np
 import PIL
 import PIL.Image as Image
-import cv2
-import numpy as np
 
-import io
 import pixeltable.type_system as ts
 from pixeltable.utils.http_server import get_file_uri
 
@@ -138,11 +138,11 @@ class Formatter:
         assert isinstance(img, Image.Image), f'Wrong type: {type(img)}'
         # Try to make it look decent in a variety of display scenarios
         if self.__num_rows > 1:
-            width = 240  # Multiple rows: display small images
+            width = min(240, img.width)  # Multiple rows: display small images
         elif self.__num_cols > 1:
-            width = 480  # Multiple columns: display medium images
+            width = min(480, img.width)  # Multiple columns: display medium images
         else:
-            width = 640  # A single image: larger display
+            width = min(640, img.width)  # A single image: larger display
         with io.BytesIO() as buffer:
             img.save(buffer, 'webp')
             img_base64 = base64.b64encode(buffer.getvalue()).decode()
@@ -159,17 +159,16 @@ class Formatter:
         # the video itself is not accessible.
         # TODO(aaron-siegel): If the video is backed by a concrete external URL,
         # should we link to that instead?
-        video_reader = cv2.VideoCapture(str(file_path))
-        if video_reader.isOpened():
-            status, img_array = video_reader.read()
-            if status:
-                img_array = cv2.cvtColor(img_array, cv2.COLOR_BGR2RGB)
-                thumb = PIL.Image.fromarray(img_array)
+        with av.open(file_path) as container:
+            try:
+                thumb = next(container.decode(video=0)).to_image()
+                assert isinstance(thumb, Image.Image)
                 with io.BytesIO() as buffer:
                     thumb.save(buffer, 'jpeg')
                     thumb_base64 = base64.b64encode(buffer.getvalue()).decode()
                     thumb_tag = f'poster="data:image/jpeg;base64,{thumb_base64}"'
-            video_reader.release()
+            except Exception:
+                pass
         if self.__num_rows > 1:
             width = 320
         elif self.__num_cols > 1:

pixeltable/utils/s3.py

@@ -1,13 +1,16 @@
 from typing import Any
 
 
-def get_client() -> Any:
+def get_client(**kwargs: Any) -> Any:
     import boto3
     import botocore
     try:
         boto3.Session().get_credentials().get_frozen_credentials()
-        return boto3.client('s3')  # credentials are available
+        config = botocore.config.Config(**kwargs)
+        return boto3.client('s3', config=config)  # credentials are available
     except AttributeError:
         # No credentials available, use unsigned mode
-        config = botocore.config.Config(signature_version=botocore.UNSIGNED)
+        config_args = kwargs.copy()
+        config_args['signature_version'] = botocore.UNSIGNED
+        config = botocore.config.Config(**config_args)
         return boto3.client('s3', config=config)