pixeltable 0.2.20__py3-none-any.whl → 0.2.22__py3-none-any.whl

pixeltable/exprs/column_property_ref.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
 import enum
-from typing import Optional, List, Any, Dict, Tuple
+from typing import Any, Optional
 
 import sqlalchemy as sql
 
 import pixeltable.type_system as ts
+from pixeltable import catalog
 from .column_ref import ColumnRef
 from .data_row import DataRow
 from .expr import Expr
@@ -33,22 +34,36 @@ class ColumnPropertyRef(Expr):
     def default_column_name(self) -> Optional[str]:
         return str(self).replace('.', '_')
 
-    def _equals(self, other: ColumnRef) -> bool:
+    def _equals(self, other: ColumnPropertyRef) -> bool:
         return self.prop == other.prop
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('prop', self.prop.value)]
 
     @property
     def _col_ref(self) -> ColumnRef:
-        return self.components[0]
+        col_ref = self.components[0]
+        assert isinstance(col_ref, ColumnRef)
+        return col_ref
 
     def __str__(self) -> str:
         return f'{self._col_ref}.{self.prop.name.lower()}'
 
+    def is_error_prop(self) -> bool:
+        return self.prop == self.Property.ERRORTYPE or self.prop == self.Property.ERRORMSG
+
     def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
         if not self._col_ref.col.is_stored:
             return None
+
+        # the errortype/-msg properties of a read-validated media column need to be extracted from the DataRow
+        if (
+            self._col_ref.col.col_type.is_media_type()
+            and self._col_ref.col.media_validation == catalog.MediaValidation.ON_READ
+            and self.is_error_prop()
+        ):
+            return None
+
         if self.prop == self.Property.ERRORTYPE:
             assert self._col_ref.col.sa_errortype_col is not None
             return self._col_ref.col.sa_errortype_col
@@ -61,18 +76,30 @@ class ColumnPropertyRef(Expr):
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
-        assert self.prop == self.Property.FILEURL or self.prop == self.Property.LOCALPATH
-        assert data_row.has_val[self._col_ref.slot_idx]
         if self.prop == self.Property.FILEURL:
+            assert data_row.has_val[self._col_ref.slot_idx]
             data_row[self.slot_idx] = data_row.file_urls[self._col_ref.slot_idx]
-        if self.prop == self.Property.LOCALPATH:
+            return
+        elif self.prop == self.Property.LOCALPATH:
+            assert data_row.has_val[self._col_ref.slot_idx]
             data_row[self.slot_idx] = data_row.file_paths[self._col_ref.slot_idx]
-
-    def _as_dict(self) -> Dict:
+            return
+        elif self.is_error_prop():
+            exc = data_row.get_exc(self._col_ref.slot_idx)
+            if exc is None:
+                data_row[self.slot_idx] = None
+            elif self.prop == self.Property.ERRORTYPE:
+                data_row[self.slot_idx] = type(exc).__name__
+            else:
+                data_row[self.slot_idx] = str(exc)
+        else:
+            assert False
+
+    def _as_dict(self) -> dict:
         return {'prop': self.prop.value, **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> ColumnPropertyRef:
         assert 'prop' in d
         assert isinstance(components[0], ColumnRef)
         return cls(components[0], cls.Property(d['prop']))

pixeltable/exprs/column_ref.py

@@ -1,16 +1,18 @@
 from __future__ import annotations
-from typing import Optional, Any, Tuple
+
+from typing import Any, Optional, Sequence
 from uuid import UUID
 
 import sqlalchemy as sql
 
-from .expr import Expr
+import pixeltable.catalog as catalog
+import pixeltable.exceptions as excs
+import pixeltable.iterators as iters
+
 from .data_row import DataRow
+from .expr import Expr
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
-import pixeltable.iterators as iters
-import pixeltable.exceptions as excs
-import pixeltable.catalog as catalog
 
 
 class ColumnRef(Expr):
@@ -19,18 +21,31 @@ class ColumnRef(Expr):
     When this reference is created in the context of a view, it can also refer to a column of the view base.
     For that reason, a ColumnRef needs to be serialized with the qualifying table id (column ids are only
     unique in the context of a particular table).
+
+    Media validation:
+    - media validation is potentially cpu-intensive, and it's desirable to schedule and parallelize it during
+      general expr evaluation
+    - media validation on read is done in ColumnRef.eval()
+    - a validating ColumnRef cannot be translated to SQL (because the validation is done in Python)
+    - in that case, the ColumnRef also instantiates a second non-validating ColumnRef as a component (= dependency)
+    - the non-validating ColumnRef is used for SQL translation
+
+    TODO:
+    separate Exprs (like validating ColumnRefs) from the logical expression tree and instead have RowBuilder
+    insert them into the EvalCtxs as needed
     """
 
     col: catalog.Column
     is_unstored_iter_col: bool
     iter_arg_ctx: Optional[RowBuilder.EvalCtx]
     base_rowid_len: int
-    base_rowid: list[Optional[Any]]
+    base_rowid: Sequence[Optional[Any]]
     iterator: Optional[iters.ComponentIterator]
     pos_idx: Optional[int]
     id: int
+    perform_validation: bool  # if True, performs media validation
 
-    def __init__(self, col: catalog.Column):
+    def __init__(self, col: catalog.Column, perform_validation: Optional[bool] = None):
         super().__init__(col.col_type)
         assert col.tbl is not None
         self.col = col
@@ -43,17 +58,44 @@ class ColumnRef(Expr):
         self.iterator = None
         # index of the position column in the view's primary key; don't try to reference tbl.store_tbl here
         self.pos_idx = col.tbl.num_rowid_columns() - 1 if self.is_unstored_iter_col else None
+
+        self.perform_validation = False
+        if col.col_type.is_media_type():
+            # we perform media validation if the column is a media type and the validation is set to ON_READ,
+            # unless we're told not to
+            if perform_validation is not None:
+                self.perform_validation = perform_validation
+            else:
+                self.perform_validation = (
+                    col.col_type.is_media_type() and col.media_validation == catalog.MediaValidation.ON_READ
+                )
+        else:
+            assert perform_validation is None or not perform_validation
+        if self.perform_validation:
+            non_validating_col_ref = ColumnRef(col, perform_validation=False)
+            self.components = [non_validating_col_ref]
         self.id = self._create_id()
 
     def set_iter_arg_ctx(self, iter_arg_ctx: RowBuilder.EvalCtx) -> None:
         self.iter_arg_ctx = iter_arg_ctx
         assert len(self.iter_arg_ctx.target_slot_idxs) == 1  # a single inline dict
 
-    def _id_attrs(self) -> list[Tuple[str, Any]]:
-        return super()._id_attrs() + [('tbl_id', self.col.tbl.id), ('col_id', self.col.id)]
+    def _id_attrs(self) -> list[tuple[str, Any]]:
+        return (
+            super()._id_attrs()
+            + [('tbl_id', self.col.tbl.id), ('col_id', self.col.id), ('perform_validation', self.perform_validation)]
+        )
+
+    # override
+    def _retarget(self, tbl_versions: dict[UUID, catalog.TableVersion]) -> ColumnRef:
+        target = tbl_versions[self.col.tbl.id]
+        assert self.col.id in target.cols_by_id
+        col = target.cols_by_id[self.col.id]
+        return ColumnRef(col)
 
     def __getattr__(self, name: str) -> Expr:
         from .column_property_ref import ColumnPropertyRef
+
         # resolve column properties
         if name == ColumnPropertyRef.Property.ERRORTYPE.name.lower() \
                 or name == ColumnPropertyRef.Property.ERRORMSG.name.lower():
@@ -82,7 +124,7 @@ class ColumnRef(Expr):
         return str(self)
 
     def _equals(self, other: ColumnRef) -> bool:
-        return self.col == other.col
+        return self.col == other.col and self.perform_validation == other.perform_validation
 
     def __str__(self) -> str:
         if self.col.name is None:
@@ -94,9 +136,38 @@ class ColumnRef(Expr):
         return f'ColumnRef({self.col!r})'
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
-        return self.col.sa_col
+        return None if self.perform_validation else self.col.sa_col
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        if self.perform_validation:
+            # validate media file of our input ColumnRef and if successful, replicate the state of that slot
+            # to our slot
+            unvalidated_slot_idx = self.components[0].slot_idx
+            if data_row.file_paths[unvalidated_slot_idx] is None:
+                # no media file to validate, we still need to replicate the value
+                assert data_row.file_urls[unvalidated_slot_idx] is None
+                val = data_row.vals[unvalidated_slot_idx]
+                data_row.vals[self.slot_idx] = val
+                data_row.has_val[self.slot_idx] = True
+                return
+
+            try:
+                self.col.col_type.validate_media(data_row.file_paths[unvalidated_slot_idx])
+                # access the value only after successful validation
+                val = data_row[unvalidated_slot_idx]
+                data_row.vals[self.slot_idx] = val
+                data_row.has_val[self.slot_idx] = True
+                # make sure that the validated slot points to the same file as the unvalidated slot
+                data_row.file_paths[self.slot_idx] = data_row.file_paths[unvalidated_slot_idx]
+                data_row.file_urls[self.slot_idx] = data_row.file_urls[unvalidated_slot_idx]
+                return
+            except excs.Error as exc:
+                # propagate the exception, but ignore it otherwise;
+                # media validation errors don't cause exceptions during query execution
+                # TODO: allow for different error-handling behavior
+                row_builder.set_exc(data_row, self.slot_idx, exc)
+                return
+
         if not self.is_unstored_iter_col:
             # supply default
             data_row[self.slot_idx] = None
@@ -115,7 +186,14 @@ class ColumnRef(Expr):
     def _as_dict(self) -> dict:
         tbl = self.col.tbl
         version = tbl.version if tbl.is_snapshot else None
-        return {'tbl_id': str(tbl.id), 'tbl_version': version, 'col_id': self.col.id}
+        # we omit self.components, even if this is a validating ColumnRef, because init() will recreate the
+        # non-validating component ColumnRef
+        return {
+            'tbl_id': str(tbl.id),
+            'tbl_version': version,
+            'col_id': self.col.id,
+            'perform_validation': self.perform_validation
+        }
 
     @classmethod
     def get_column(cls, d: dict) -> catalog.Column:
@@ -126,6 +204,7 @@ class ColumnRef(Expr):
         return col
 
     @classmethod
-    def _from_dict(cls, d: dict, _: list[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, _: list[Expr]) -> ColumnRef:
         col = cls.get_column(d)
-        return cls(col)
+        perform_validation = d['perform_validation']
+        return cls(col, perform_validation=perform_validation)

pixeltable/exprs/comparison.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
-from typing import Optional, List, Any, Dict
+from typing import Any, Optional
 
 import sqlalchemy as sql
 
 import pixeltable.exceptions as excs
 import pixeltable.index as index
 import pixeltable.type_system as ts
+
 from .column_ref import ColumnRef
 from .data_row import DataRow
 from .expr import Expr
@@ -65,7 +66,7 @@ class Comparison(Expr):
     def _op2(self) -> Expr:
         return self.components[1]
 
-    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
         left = sql_elements.get(self._op1)
         if self.is_search_arg_comparison:
             # reference the index value column if there is an index and this is not a snapshot
@@ -113,11 +114,10 @@ class Comparison(Expr):
         elif self.operator == ComparisonOperator.GE:
             data_row[self.slot_idx] = left >= right
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         return {'operator': self.operator.value, **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> Comparison:
         assert 'operator' in d
         return cls(ComparisonOperator(d['operator']), components[0], components[1])
-

pixeltable/exprs/compound_predicate.py

@@ -1,20 +1,21 @@
 from __future__ import annotations
 
 import operator
-from typing import Optional, List, Any, Dict, Callable
+from typing import Any, Callable, Optional
 
 import sqlalchemy as sql
 
+import pixeltable.type_system as ts
+
 from .data_row import DataRow
 from .expr import Expr
 from .globals import LogicalOperator
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
-import pixeltable.type_system as ts
 
 
 class CompoundPredicate(Expr):
-    def __init__(self, operator: LogicalOperator, operands: List[Expr]):
+    def __init__(self, operator: LogicalOperator, operands: list[Expr]):
         super().__init__(ts.BoolType())
         self.operator = operator
         # operands are stored in self.components
@@ -23,7 +24,7 @@ class CompoundPredicate(Expr):
             self.components = operands
         else:
             assert len(operands) > 1
-            self.operands: List[Expr] = []
+            self.operands: list[Expr] = []
             for operand in operands:
                 self._merge_operand(operand)
 
@@ -35,7 +36,7 @@ class CompoundPredicate(Expr):
         return f' {self.operator} '.join([f'({e})' for e in self.components])
 
     @classmethod
-    def make_conjunction(cls, operands: List[Expr]) -> Optional[Expr]:
+    def make_conjunction(cls, operands: list[Expr]) -> Optional[Expr]:
         if len(operands) == 0:
             return None
         if len(operands) == 1:
@@ -89,11 +90,11 @@ class CompoundPredicate(Expr):
                 val = op_function(val, data_row[op.slot_idx])
             data_row[self.slot_idx] = val
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         return {'operator': self.operator.value, **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> CompoundPredicate:
         assert 'operator' in d
         return cls(LogicalOperator(d['operator']), components)
 

pixeltable/exprs/data_row.py

@@ -4,13 +4,13 @@ import datetime
 import io
 import urllib.parse
 import urllib.request
-from typing import Optional, List, Any, Tuple
+from typing import Any, Optional
 
-import sqlalchemy as sql
-import pgvector.sqlalchemy
+import numpy as np
+import pgvector.sqlalchemy  # type: ignore[import-untyped]
 import PIL
 import PIL.Image
-import numpy as np
+import sqlalchemy as sql
 
 from pixeltable import env
 
@@ -33,29 +33,40 @@ class DataRow:
     - ImageType: PIL.Image.Image
     - VideoType: local path if available, otherwise url
     """
-    def __init__(self, size: int, img_slot_idxs: List[int], media_slot_idxs: List[int], array_slot_idxs: List[int]):
-        self.vals: List[Any] = [None] * size  # either cell values or exceptions
-        self.has_val = [False] * size
-        self.excs: List[Optional[Exception]] = [None] * size
 
-        # control structures that are shared across all DataRows in a batch
-        self.img_slot_idxs = img_slot_idxs
-        self.media_slot_idxs = media_slot_idxs  # all media types aside from image
-        self.array_slot_idxs = array_slot_idxs
+    vals: list[Any]
+    has_val: list[bool]
+    excs: list[Optional[Exception]]
+
+    # control structures that are shared across all DataRows in a batch
+    img_slot_idxs: list[int]
+    media_slot_idxs: list[int]
+    array_slot_idxs: list[int]
 
-        # the primary key of a store row is a sequence of ints (the number is different for table vs view)
-        self.pk: Optional[Tuple[int, ...]] = None
+    # the primary key of a store row is a sequence of ints (the number is different for table vs view)
+    pk: Optional[tuple[int, ...]]
 
-        # file_urls:
-        # - stored url of file for media in vals[i]
-        # - None if vals[i] is not media type
-        # - not None if file_paths[i] is not None
-        self.file_urls: List[Optional[str]] = [None] * size
+    # file_urls:
+    # - stored url of file for media in vals[i]
+    # - None if vals[i] is not media type
+    # - not None if file_paths[i] is not None
+    file_urls: list[Optional[str]]
 
-        # file_paths:
-        # - local path of media file in vals[i]; points to the file cache if file_urls[i] is remote
-        # - None if vals[i] is not a media type or if there is no local file yet for file_urls[i]
-        self.file_paths: List[Optional[str]] = [None] * size
+    # file_paths:
+    # - local path of media file in vals[i]; points to the file cache if file_urls[i] is remote
+    # - None if vals[i] is not a media type or if there is no local file yet for file_urls[i]
+    file_paths: list[Optional[str]]
+
+    def __init__(self, size: int, img_slot_idxs: list[int], media_slot_idxs: list[int], array_slot_idxs: list[int]):
+        self.vals = [None] * size
+        self.has_val = [False] * size
+        self.excs = [None] * size
+        self.img_slot_idxs = img_slot_idxs
+        self.media_slot_idxs = media_slot_idxs
+        self.array_slot_idxs = array_slot_idxs
+        self.pk = None
+        self.file_urls = [None] * size
+        self.file_paths = [None] * size
 
     def clear(self) -> None:
         size = len(self.vals)
@@ -78,27 +89,35 @@ class DataRow:
         target.file_urls = self.file_urls.copy()
         target.file_paths = self.file_paths.copy()
 
-    def set_pk(self, pk: Tuple[int, ...]) -> None:
+    def set_pk(self, pk: tuple[int, ...]) -> None:
         self.pk = pk
 
-    def has_exc(self, slot_idx: int) -> bool:
-        return self.excs[slot_idx] is not None
+    def has_exc(self, slot_idx: Optional[int] = None) -> bool:
+        """
+        Returns True if an exception has been set for the given slot index, or for any slot index if slot_idx is None
+        """
+        if slot_idx is not None:
+            return self.excs[slot_idx] is not None
+        return any(exc is not None for exc in self.excs)
 
-    def get_exc(self, slot_idx: int) -> Exception:
-        assert self.has_val[slot_idx] is False
-        assert self.excs[slot_idx] is not None
+    def get_exc(self, slot_idx: int) -> Optional[Exception]:
         return self.excs[slot_idx]
 
+    def get_first_exc(self) -> Optional[Exception]:
+        for exc in self.excs:
+            if exc is not None:
+                return exc
+        return None
+
     def set_exc(self, slot_idx: int, exc: Exception) -> None:
         assert self.excs[slot_idx] is None
         self.excs[slot_idx] = exc
 
-        if self.has_val[slot_idx]:
-            # eg. during validation, where contents of file is found invalid
-            self.has_val[slot_idx] = False
-            self.vals[slot_idx] = None
-            self.file_paths[slot_idx] = None
-            self.file_urls[slot_idx] = None
+        # an exception means the value is None
+        self.has_val[slot_idx] = True
+        self.vals[slot_idx] = None
+        self.file_paths[slot_idx] = None
+        self.file_urls[slot_idx] = None
 
     def __len__(self) -> int:
         return len(self.vals)
@@ -113,6 +132,7 @@ class DataRow:
 
         if self.file_urls[index] is not None and index in self.img_slot_idxs:
             # if we need to load this from a file, it should have been materialized locally
+            # TODO this fails if the url was instantiated dynamically using astype()
             assert self.file_paths[index] is not None
             if self.vals[index] is None:
                 self.vals[index] = PIL.Image.open(self.file_paths[index])
@@ -220,7 +240,7 @@ class DataRow:
         self.vals[index] = None
 
     @property
-    def rowid(self) -> Tuple[int]:
+    def rowid(self) -> tuple[int, ...]:
         return self.pk[:-1]
 
     @property