pixeltable 0.2.14__py3-none-any.whl → 0.2.15__py3-none-any.whl

pixeltable/io/globals.py

@@ -191,7 +191,7 @@ def import_rows(
                 if col_name not in schema:
                     schema[col_name] = col_type
                 else:
-                    supertype = pxt.ColumnType.supertype(schema[col_name], col_type)
+                    supertype = schema[col_name].supertype(col_type)
                     if supertype is None:
                         raise excs.Error(
                             f'Could not infer type of column `{col_name}`; the value in row {n} does not match preceding type {schema[col_name]}: {value!r}\n'

pixeltable/io/pandas.py

@@ -1,7 +1,9 @@
+import datetime
 from typing import Any, Optional, Union
 
 import numpy as np
 import pandas as pd
+import PIL.Image
 
 import pixeltable as pxt
 import pixeltable.exceptions as excs
@@ -103,6 +105,17 @@ def __df_to_pxt_schema(
         if pd_name in schema_overrides:
             pxt_type = schema_overrides[pd_name]
         else:
+            # This complicated-looking condition is necessary because we cannot safely call `pd.isna()` on
+            # general objects, so we need to check for nulls in the specific cases where we might expect them.
+            # isinstance(val, float) will check for NaN values in float columns *as well as* floats appearing
+            # in object columns (where Pandas uses NaN as a general null).
+            # np.issubdtype(pd_dtype, np.datetime64) checks for NaT values specifically in datetime columns.
+            has_na = any(
+                (isinstance(val, float) or np.issubdtype(pd_dtype, np.datetime64)) and pd.isna(val)
+                for val in df[pd_name]
+            )
+            if has_na and pd_name in primary_key:
+                raise excs.Error(f'Primary key column `{pd_name}` cannot contain null values.')
             pxt_type = __np_dtype_to_pxt_type(pd_dtype, df[pd_name], pd_name not in primary_key)
         pxt_name = __normalize_pxt_col_name(pd_name)
         # Ensure that column names are unique by appending a distinguishing suffix
@@ -140,21 +153,34 @@ def __np_dtype_to_pxt_type(np_dtype: np.dtype, data_col: pd.Series, nullable: bo
     """
     if np.issubdtype(np_dtype, np.integer):
         return pxt.IntType(nullable=nullable)
+
     if np.issubdtype(np_dtype, np.floating):
         return pxt.FloatType(nullable=nullable)
+
     if np.issubdtype(np_dtype, np.bool_):
         return pxt.BoolType(nullable=nullable)
-    if np_dtype == np.object_ or np.issubdtype(np_dtype, np.character):
-        has_nan = any(isinstance(val, float) and np.isnan(val) for val in data_col)
-        if has_nan and not nullable:
-            raise excs.Error(f'Primary key column `{data_col.name}` cannot contain null values.')
+
+    if np.issubdtype(np_dtype, np.character):
         return pxt.StringType(nullable=nullable)
+
     if np.issubdtype(np_dtype, np.datetime64):
-        has_nat = any(pd.isnull(val) for val in data_col)
-        if has_nat and not nullable:
-            raise excs.Error(f'Primary key column `{data_col.name}` cannot contain null values.')
         return pxt.TimestampType(nullable=nullable)
-    raise excs.Error(f'Unsupported dtype: {np_dtype}')
+
+    if np_dtype == np.object_:
+        # The `object_` dtype can mean all sorts of things; see if we can infer the Pixeltable type
+        # based on the actual data in `data_col`.
+        # First drop any null values (they don't contribute to type inference).
+        data_col = data_col.dropna()
+
+        if len(data_col) == 0:
+            # No non-null values; default to FloatType (the Pandas type of an all-NaN column)
+            return pxt.FloatType(nullable=nullable)
+
+        inferred_type = pxt.ColumnType.infer_common_literal_type(data_col)
+        if inferred_type is not None:
+            return inferred_type.copy(nullable=nullable)
+
+    raise excs.Error(f'Could not infer Pixeltable type of column: {data_col.name} (dtype: {np_dtype})')
 
 
 def __df_row_to_pxt_row(row: tuple[Any, ...], schema: dict[str, pxt.ColumnType]) -> dict[str, Any]:

pixeltable/iterators/video.py

@@ -1,57 +1,89 @@
 import logging
 import math
 from pathlib import Path
-from typing import Dict, Any, List, Tuple
+from typing import Any, Optional
 
-import PIL.Image
 import cv2
+import PIL.Image
 
 from pixeltable.exceptions import Error
-from pixeltable.type_system import ColumnType, VideoType, ImageType, IntType, FloatType
+from pixeltable.type_system import ColumnType, FloatType, ImageType, IntType, VideoType
+
 from .base import ComponentIterator
 
 _logger = logging.getLogger('pixeltable')
 
 
 class FrameIterator(ComponentIterator):
-    """Iterator over frames of a video.
+    """
+    Iterator over frames of a video. At most one of `fps` or `num_frames` may be specified. If `fps` is specified,
+    then frames will be extracted at the specified rate (frames per second). If `num_frames` is specified, then the
+    exact number of frames will be extracted. If neither is specified, then all frames will be extracted. The first
+    frame of the video will always be extracted, and the remaining frames will be spaced as evenly as possible.
 
         Args:
-            video: URL or file of the video to use for frame extraction
-            fps: number of frames to extract per second of video. This may be a fractional value, such as 0.5.
-                If set to 0.0, then the native framerate of the video will be used (all frames will be extracted).
-                Default: 0.0
+            video: URL or path of the video to use for frame extraction.
+            fps: Number of frames to extract per second of video. This may be a fractional value, such as 0.5.
+                If omitted or set to 0.0, then the native framerate of the video will be used (all frames will be
+                extracted). If `fps` is greater than the frame rate of the video, an error will be raised.
+            num_frames: Exact number of frames to extract. The frames will be spaced as evenly as possible. If
+                `num_frames` is greater than the number of frames in the video, all frames will be extracted.
     """
-    def __init__(self, video: str, *, fps: float = 0.0):
+    def __init__(self, video: str, *, fps: Optional[float] = None, num_frames: Optional[int] = None):
+        if fps is not None and num_frames is not None:
+            raise Error('At most one of `fps` or `num_frames` may be specified')
+
         video_path = Path(video)
         assert video_path.exists() and video_path.is_file()
         self.video_path = video_path
-        self.fps = fps
         self.video_reader = cv2.VideoCapture(str(video_path))
+        self.fps = fps
+        self.num_frames = num_frames
         if not self.video_reader.isOpened():
             raise Error(f'Failed to open video: {video}')
+
         video_fps = int(self.video_reader.get(cv2.CAP_PROP_FPS))
-        if fps > video_fps:
+        if fps is not None and fps > video_fps:
             raise Error(f'Video {video}: requested fps ({fps}) exceeds that of the video ({video_fps})')
-        self.frame_freq = int(video_fps / fps) if fps > 0 else 1
         num_video_frames = int(self.video_reader.get(cv2.CAP_PROP_FRAME_COUNT))
         if num_video_frames == 0:
             raise Error(f'Video {video}: failed to get number of frames')
-        # ceil: round up to ensure we count frame 0
-        self.num_frames = math.ceil(num_video_frames / self.frame_freq) if fps > 0 else num_video_frames
-        _logger.debug(f'FrameIterator: path={self.video_path} fps={self.fps}')
 
+        if num_frames is not None:
+            # specific number of frames
+            if num_frames > num_video_frames:
+                # Extract all frames
+                self.frames_to_extract = range(num_video_frames)
+            else:
+                spacing = float(num_video_frames) / float(num_frames)
+                self.frames_to_extract = list(round(i * spacing) for i in range(num_frames))
+                assert len(self.frames_to_extract) == num_frames
+        else:
+            if fps is None or fps == 0.0:
+                # Extract all frames
+                self.frames_to_extract = range(num_video_frames)
+            else:
+                # Extract frames at the implied frequency
+                freq = fps / video_fps
+                n = math.ceil(num_video_frames * freq)  # number of frames to extract
+                self.frames_to_extract = list(round(i / freq) for i in range(n))
+
+        # We need the list of frames as both a list (for set_pos) and a set (for fast lookups when
+        # there are lots of frames)
+        self.frames_set = set(self.frames_to_extract)
+        _logger.debug(f'FrameIterator: path={self.video_path} fps={self.fps} num_frames={self.num_frames}')
         self.next_frame_idx = 0
 
     @classmethod
-    def input_schema(cls) -> Dict[str, ColumnType]:
+    def input_schema(cls) -> dict[str, ColumnType]:
         return {
             'video': VideoType(nullable=False),
-            'fps': FloatType()
+            'fps': FloatType(nullable=True),
+            'num_frames': IntType(nullable=True),
         }
 
     @classmethod
-    def output_schema(cls, *args: Any, **kwargs: Any) -> Tuple[Dict[str, ColumnType], List[str]]:
+    def output_schema(cls, *args: Any, **kwargs: Any) -> tuple[dict[str, ColumnType], list[str]]:
         return {
             'frame_idx': IntType(),
             'pos_msec': FloatType(),
@@ -59,7 +91,9 @@ class FrameIterator(ComponentIterator):
             'frame': ImageType(),
         }, ['frame']
 
-    def __next__(self) -> Dict[str, Any]:
+    def __next__(self) -> dict[str, Any]:
+        # jumping to the target frame here with video_reader.set() is far slower than just
+        # skipping the unwanted frames
         while True:
             pos_msec = self.video_reader.get(cv2.CAP_PROP_POS_MSEC)
             pos_frame = self.video_reader.get(cv2.CAP_PROP_POS_FRAMES)
@@ -69,7 +103,7 @@ class FrameIterator(ComponentIterator):
                 self.video_reader.release()
                 self.video_reader = None
                 raise StopIteration
-            if pos_frame % self.frame_freq == 0:
+            if pos_frame in self.frames_set:
                 img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
                 result = {
                     'frame_idx': self.next_frame_idx,
@@ -78,8 +112,6 @@ class FrameIterator(ComponentIterator):
                     'frame': PIL.Image.fromarray(img),
                 }
                 self.next_frame_idx += 1
-                # frame_freq > 1: jumping to the target frame here with video_reader.set() is far slower than just
-                # skipping the unwanted frames
                 return result
 
     def close(self) -> None:
@@ -92,5 +124,5 @@ class FrameIterator(ComponentIterator):
         if pos == self.next_frame_idx:
             return
         _logger.debug(f'seeking to frame {pos}')
-        self.video_reader.set(cv2.CAP_PROP_POS_FRAMES, pos * self.frame_freq)
+        self.video_reader.set(cv2.CAP_PROP_POS_FRAMES, self.frames_to_extract[pos])
         self.next_frame_idx = pos

pixeltable/store.py

@@ -223,35 +223,70 @@ class StoreBase:
         """
         num_excs = 0
         num_rows = 0
-        for row_batch in exec_plan:
-            num_rows += len(row_batch)
-            for result_row in row_batch:
-                values_dict: Dict[sql.Column, Any] = {}
-
-                if col.is_computed:
-                    if result_row.has_exc(value_expr_slot_idx):
-                        num_excs += 1
-                        value_exc = result_row.get_exc(value_expr_slot_idx)
-                        # we store a NULL value and record the exception/exc type
-                        error_type = type(value_exc).__name__
-                        error_msg = str(value_exc)
-                        values_dict = {
-                            col.sa_col: None,
-                            col.sa_errortype_col: error_type,
-                            col.sa_errormsg_col: error_msg
-                        }
-                    else:
-                        val = result_row.get_stored_val(value_expr_slot_idx, col.sa_col.type)
-                        if col.col_type.is_media_type():
-                            val = self._move_tmp_media_file(val, col, result_row.pk[-1])
-                        values_dict = {col.sa_col: val}
-
-                update_stmt = sql.update(self.sa_tbl).values(values_dict)
-                for pk_col, pk_val in zip(self.pk_columns(), result_row.pk):
-                    update_stmt = update_stmt.where(pk_col == pk_val)
-                log_stmt(_logger, update_stmt)
-                conn.execute(update_stmt)
 
+        # create temp table to store output of exec_plan, with the same primary key as the store table
+        tmp_name = f'temp_{self._storage_name()}'
+        tmp_pk_cols = [sql.Column(col.name, col.type, primary_key=True) for col in self.pk_columns()]
+        tmp_cols = tmp_pk_cols.copy()
+        tmp_val_col = sql.Column(col.sa_col.name, col.sa_col.type)
+        tmp_cols.append(tmp_val_col)
+        # add error columns if the store column records errors
+        if col.records_errors:
+            tmp_errortype_col = sql.Column(col.sa_errortype_col.name, col.sa_errortype_col.type)
+            tmp_cols.append(tmp_errortype_col)
+            tmp_errormsg_col = sql.Column(col.sa_errormsg_col.name, col.sa_errormsg_col.type)
+            tmp_cols.append(tmp_errormsg_col)
+        tmp_tbl = sql.Table(tmp_name, self.sa_md, *tmp_cols, prefixes=['TEMPORARY'])
+        tmp_tbl.create(bind=conn)
+
+        try:
+            # insert rows from exec_plan into temp table
+            for row_batch in exec_plan:
+                num_rows += len(row_batch)
+                tbl_rows: list[dict[str, Any]] = []
+                for result_row in row_batch:
+                    tbl_row: dict[str, Any] = {}
+                    for pk_col, pk_val in zip(self.pk_columns(), result_row.pk):
+                        tbl_row[pk_col.name] = pk_val
+
+                    if col.is_computed:
+                        if result_row.has_exc(value_expr_slot_idx):
+                            num_excs += 1
+                            value_exc = result_row.get_exc(value_expr_slot_idx)
+                            # we store a NULL value and record the exception/exc type
+                            error_type = type(value_exc).__name__
+                            error_msg = str(value_exc)
+                            tbl_row[col.sa_col.name] = None
+                            tbl_row[col.sa_errortype_col.name] = error_type
+                            tbl_row[col.sa_errormsg_col.name] = error_msg
+                        else:
+                            val = result_row.get_stored_val(value_expr_slot_idx, col.sa_col.type)
+                            if col.col_type.is_media_type():
+                                val = self._move_tmp_media_file(val, col, result_row.pk[-1])
+                            tbl_row[col.sa_col.name] = val
+                            if col.records_errors:
+                                tbl_row[col.sa_errortype_col.name] = None
+                                tbl_row[col.sa_errormsg_col.name] = None
+
+                    tbl_rows.append(tbl_row)
+                conn.execute(sql.insert(tmp_tbl), tbl_rows)
+
+            # update store table with values from temp table
+            update_stmt = sql.update(self.sa_tbl)
+            for pk_col, tmp_pk_col in zip(self.pk_columns(), tmp_pk_cols):
+                update_stmt = update_stmt.where(pk_col == tmp_pk_col)
+            update_stmt = update_stmt.values({col.sa_col: tmp_val_col})
+            if col.records_errors:
+                update_stmt = update_stmt.values({
+                    col.sa_errortype_col: tmp_errortype_col,
+                    col.sa_errormsg_col: tmp_errormsg_col
+                })
+            log_explain(_logger, update_stmt, conn)
+            conn.execute(update_stmt)
+
+        finally:
+            tmp_tbl.drop(bind=conn)
+            self.sa_md.remove(tmp_tbl)
         return num_excs
 
     def insert_rows(
@@ -295,6 +330,8 @@ class StoreBase:
                                     file=sys.stdout
                                 )
                             progress_bar.update(1)
+
+                    # insert batch of rows
                     self._move_tmp_media_files(table_rows, media_cols, v_min)
                     conn.execute(sql.insert(self.sa_tbl), table_rows)
             if progress_bar is not None:

pixeltable/tool/create_test_db_dump.py

@@ -6,7 +6,7 @@ import pathlib
 import subprocess
 from typing import Any
 
-import pgserver
+import pixeltable_pgserver
 import toml
 
 import pixeltable as pxt
@@ -41,7 +41,7 @@ class Dumper:
         md_version = metadata.VERSION
         dump_file = self.output_dir / f'pixeltable-v{md_version:03d}-test.dump.gz'
         _logger.info(f'Creating database dump at: {dump_file}')
-        pg_package_dir = os.path.dirname(pgserver.__file__)
+        pg_package_dir = os.path.dirname(pixeltable_pgserver.__file__)
         pg_dump_binary = f'{pg_package_dir}/pginstall/bin/pg_dump'
         _logger.info(f'Using pg_dump binary at: {pg_dump_binary}')
         with open(dump_file, 'wb') as dump:
@@ -177,8 +177,8 @@ class Dumper:
         assert t.base_table_image_rot.col in project.stored_proxies
 
     def __add_expr_columns(self, t: pxt.Table, col_prefix: str, include_expensive_functions=False) -> None:
-        def add_column(col_name: str, col_expr: Any) -> None:
-            t.add_column(**{f'{col_prefix}_{col_name}': col_expr})
+        def add_column(col_name: str, col_expr: Any, stored: bool = True) -> None:
+            t.add_column(**{f'{col_prefix}_{col_name}': col_expr}, stored=stored)
 
         # arithmetic_expr
         add_column('plus', t.c2 + 6)
@@ -217,7 +217,7 @@ class Dumper:
 
         # image_member_access
         add_column('image_mode', t.c8.mode)
-        add_column('image_rot', t.c8.rotate(180))
+        add_column('image_rot', t.c8.rotate(180), stored=False)
 
         # in_predicate
         add_column('isin_1', t.c1.isin(['test string 1', 'test string 2', 'test string 3']))

pixeltable/type_system.py

@@ -9,7 +9,7 @@ import urllib.parse
 import urllib.request
 from copy import deepcopy
 from pathlib import Path
-from typing import Any, Optional, Tuple, Dict, Callable, List, Union, Sequence, Mapping
+from typing import Any, Iterable, Optional, Tuple, Dict, Callable, List, Union, Sequence, Mapping
 
 import PIL.Image
 import av
@@ -166,24 +166,14 @@ class ColumnType:
         return self._type.name.lower()
 
     def __eq__(self, other: object) -> bool:
-        return self.matches(other) and self.nullable == other.nullable
+        return isinstance(other, ColumnType) and self.matches(other) and self.nullable == other.nullable
 
-    def is_supertype_of(self, other: ColumnType) -> bool:
-        if type(self) != type(other):
-            return False
-        if self.matches(other):
-            return True
-        return self._is_supertype_of(other)
-
-    @abc.abstractmethod
-    def _is_supertype_of(self, other: ColumnType) -> bool:
-        return False
+    def is_supertype_of(self, other: ColumnType, ignore_nullable: bool = False) -> bool:
+        operand = self.copy(nullable=True) if ignore_nullable else self
+        return operand.supertype(other) == operand
 
-    def matches(self, other: object) -> bool:
+    def matches(self, other: ColumnType) -> bool:
         """Two types match if they're equal, aside from nullability"""
-        if not isinstance(other, ColumnType):
-            pass
-        assert isinstance(other, ColumnType), type(other)
         if type(self) != type(other):
             return False
         for member_var in vars(self).keys():
@@ -193,36 +183,23 @@ class ColumnType:
                 return False
         return True
 
-    @classmethod
-    def supertype(cls, type1: ColumnType, type2: ColumnType) -> Optional[ColumnType]:
-        if type1 == type2:
-            return type1
+    def supertype(self, other: ColumnType) -> Optional[ColumnType]:
+        if self.copy(nullable=True) == other.copy(nullable=True):
+            return self.copy(nullable=(self.nullable or other.nullable))
 
-        if type1.is_invalid_type():
-            return type2
-        if type2.is_invalid_type():
-            return type1
+        if self.is_invalid_type():
+            return other
+        if other.is_invalid_type():
+            return self
 
-        if type1.is_scalar_type() and type2.is_scalar_type():
-            t = cls.Type.supertype(type1._type, type2._type, cls.common_supertypes)
+        if self.is_scalar_type() and other.is_scalar_type():
+            t = self.Type.supertype(self._type, other._type, self.common_supertypes)
             if t is not None:
-                return cls.make_type(t).copy(nullable=(type1.nullable or type2.nullable))
+                return self.make_type(t).copy(nullable=(self.nullable or other.nullable))
             return None
 
-        if type1._type == type2._type:
-            return cls._supertype(type1, type2)
-
         return None
 
-    @classmethod
-    @abc.abstractmethod
-    def _supertype(cls, type1: ColumnType, type2: ColumnType) -> Optional[ColumnType]:
-        """
-        Class-specific implementation of determining the supertype. type1 and type2 are from the same subclass of
-        ColumnType.
-        """
-        pass
-
     @classmethod
     def infer_literal_type(cls, val: Any) -> Optional[ColumnType]:
         if isinstance(val, str):
@@ -251,6 +228,26 @@ class ColumnType:
                 return None
         return None
 
+    @classmethod
+    def infer_common_literal_type(cls, vals: Iterable[Any]) -> Optional[ColumnType]:
+        """
+        Returns the most specific type that is a supertype of all literals in `vals`. If no such type
+        exists, returns None.
+
+        Args:
+            vals: A collection of literals.
+        """
+        inferred_type: Optional[ColumnType] = None
+        for val in vals:
+            val_type = cls.infer_literal_type(val)
+            if inferred_type is None:
+                inferred_type = val_type
+            else:
+                inferred_type = inferred_type.supertype(val_type)
+                if inferred_type is None:
+                    return None
+        return inferred_type
+
     @classmethod
     def from_python_type(cls, t: type) -> Optional[ColumnType]:
         if typing.get_origin(t) is typing.Union:
@@ -522,6 +519,28 @@ class JsonType(ColumnType):
         super().__init__(self.Type.JSON, nullable=nullable)
         self.type_spec = type_spec
 
+    def supertype(self, other: ColumnType) -> Optional[JsonType]:
+        if self.type_spec is None:
+            # we don't have a type spec and can accept anything accepted by other
+            return JsonType(nullable=(self.nullable or other.nullable))
+        if other.type_spec is None:
+            # we have a type spec but other doesn't
+            return JsonType(nullable=(self.nullable or other.nullable))
+
+        # we both have type specs; the supertype's type spec is the union of the two
+        type_spec = deepcopy(self.type_spec)
+        for other_field_name, other_field_type in other.type_spec.items():
+            if other_field_name not in type_spec:
+                type_spec[other_field_name] = other_field_type.copy()
+            else:
+                # both type specs have this field
+                field_type = type_spec[other_field_name].supertype(other_field_type)
+                if field_type is None:
+                    # conflicting types
+                    return JsonType(nullable=(self.nullable or other.nullable))
+                type_spec[other_field_name] = field_type
+        return JsonType(type_spec, nullable=(self.nullable or other.nullable))
+
     def _as_dict(self) -> Dict:
         result = super()._as_dict()
         if self.type_spec is not None:
@@ -564,21 +583,22 @@ class JsonType(ColumnType):
 
 
 class ArrayType(ColumnType):
-    def __init__(
-            self, shape: Tuple[Union[int, None], ...], dtype: ColumnType, nullable: bool = False):
+    def __init__(self, shape: Tuple[Union[int, None], ...], dtype: ColumnType, nullable: bool = False):
         super().__init__(self.Type.ARRAY, nullable=nullable)
         self.shape = shape
         assert dtype.is_int_type() or dtype.is_float_type() or dtype.is_bool_type() or dtype.is_string_type()
         self.dtype = dtype._type
 
-    def _supertype(cls, type1: ArrayType, type2: ArrayType) -> Optional[ArrayType]:
-        if len(type1.shape) != len(type2.shape):
+    def supertype(self, other: ColumnType) -> Optional[ArrayType]:
+        if not isinstance(other, ArrayType):
+            return None
+        if len(self.shape) != len(other.shape):
             return None
-        base_type = ColumnType.supertype(type1.dtype, type2.dtype)
+        base_type = self.Type.supertype(self.dtype, other.dtype, self.common_supertypes)
         if base_type is None:
             return None
-        shape = [n1 if n1 == n2 else None for n1, n2 in zip(type1.shape, type2.shape)]
-        return ArrayType(tuple(shape), base_type, nullable=(type1.nullable or type2.nullable))
+        shape = [n1 if n1 == n2 else None for n1, n2 in zip(self.shape, other.shape)]
+        return ArrayType(tuple(shape), self.make_type(base_type), nullable=(self.nullable or other.nullable))
 
     def _as_dict(self) -> Dict:
         result = super()._as_dict()
@@ -695,13 +715,13 @@ class ImageType(ColumnType):
             params_str = ''
         return f'{self._type.name.lower()}{params_str}'
 
-    def _is_supertype_of(self, other: ImageType) -> bool:
-        if self.mode is not None and self.mode != other.mode:
-            return False
-        if self.width is None and self.height is None:
-            return True
-        if self.width != other.width and self.height != other.height:
-            return False
+    def supertype(self, other: ColumnType) -> Optional[ImageType]:
+        if not isinstance(other, ImageType):
+            return None
+        width = self.width if self.width == other.width else None
+        height = self.height if self.height == other.height else None
+        mode = self.mode if self.mode == other.mode else None
+        return ImageType(width=width, height=height, mode=mode, nullable=(self.nullable or other.nullable))
 
     @property
     def size(self) -> Optional[Tuple[int, int]]:

{pixeltable-0.2.14.dist-info → pixeltable-0.2.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixeltable
-Version: 0.2.14
+Version: 0.2.15
 Summary: Pixeltable: The Multimodal AI Data Plane
 Author: Pixeltable, Inc.
 Author-email: contact@pixeltable.com
@@ -21,9 +21,9 @@ Requires-Dist: more-itertools (>=10.2,<11.0)
 Requires-Dist: numpy (>=1.25)
 Requires-Dist: opencv-python-headless (>=4.7.0.68,<5.0.0.0)
 Requires-Dist: pandas (>=2.0,<3.0)
-Requires-Dist: pgserver (==0.1.4)
 Requires-Dist: pgvector (>=0.2.1,<0.3.0)
 Requires-Dist: pillow (>=9.3.0)
+Requires-Dist: pixeltable-pgserver (==0.2.4)
 Requires-Dist: psutil (>=5.9.5,<6.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.5,<3.0.0)
 Requires-Dist: pymupdf (>=1.24.1,<2.0.0)