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

pixeltable/exprs/arithmetic_expr.py

@@ -6,6 +6,7 @@ import sqlalchemy as sql
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
+
 from .data_row import DataRow
 from .expr import Expr
 from .globals import ArithmeticOperator
@@ -68,11 +69,15 @@ class ArithmeticExpr(Expr):
             return left * right
         if self.operator == ArithmeticOperator.DIV:
             assert self.col_type.is_float_type()
+            # Avoid DivisionByZero: if right is 0, make this a NULL
+            # TODO: Should we cast the NULLs to NaNs when they are retrieved back into Python?
+            nullif = sql.sql.func.nullif(right, 0)
             # We have to cast to a `float`, or else we'll get a `Decimal`
-            return sql.sql.expression.cast(left / right, sql.Float)
+            return sql.sql.expression.cast(left / nullif, sql.Float)
         if self.operator == ArithmeticOperator.MOD:
             if self.col_type.is_int_type():
-                return left % right
+                nullif = sql.sql.func.nullif(right, 0)
+                return left % nullif
             if self.col_type.is_float_type():
                 # Postgres does not support modulus for floats
                 return None
@@ -82,10 +87,12 @@ class ArithmeticExpr(Expr):
             # We need the behavior to be consistent, so that expressions will evaluate the same way
             # whether or not their operands can be translated to SQL. These SQL clauses should
             # mimic the behavior of Python's // operator.
+            nullif = sql.sql.func.nullif(right, 0)
             if self.col_type.is_int_type():
-                return sql.sql.expression.cast(sql.func.floor(left / right), sql.Integer)
+                return sql.sql.expression.cast(sql.func.floor(left / nullif), sql.Integer)
             if self.col_type.is_float_type():
-                return sql.sql.expression.cast(sql.func.floor(left / right), sql.Float)
+                return sql.sql.expression.cast(sql.func.floor(left / nullif), sql.Float)
+        assert False
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         op1_val = data_row[self._op1.slot_idx]
@@ -121,7 +128,7 @@ class ArithmeticExpr(Expr):
         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]) -> ArithmeticExpr:
         assert 'operator' in d
         assert len(components) == 2
         return cls(ArithmeticOperator(d['operator']), components[0], components[1])

pixeltable/exprs/array_slice.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional, Union
 
 import sqlalchemy as sql
 
@@ -15,7 +15,7 @@ class ArraySlice(Expr):
     """
     Slice operation on an array, eg, t.array_col[:, 1:2].
     """
-    def __init__(self, arr: Expr, index: Tuple):
+    def __init__(self, arr: Expr, index: tuple[Union[int, slice], ...]):
         assert arr.col_type.is_array_type()
         # determine result type
         super().__init__(arr.col_type)
@@ -24,7 +24,7 @@ class ArraySlice(Expr):
         self.id = self._create_id()
 
     def __str__(self) -> str:
-        index_strs: List[str] = []
+        index_strs: list[str] = []
         for el in self.index:
             if isinstance(el, int):
                 index_strs.append(str(el))
@@ -39,7 +39,7 @@ class ArraySlice(Expr):
     def _equals(self, other: ArraySlice) -> bool:
         return self.index == other.index
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('index', self.index)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
@@ -49,8 +49,8 @@ class ArraySlice(Expr):
         val = data_row[self._array.slot_idx]
         data_row[self.slot_idx] = val[self.index]
 
-    def _as_dict(self) -> Dict:
-        index = []
+    def _as_dict(self) -> dict:
+        index: list[Any] = []
         for el in self.index:
             if isinstance(el, slice):
                 index.append([el.start, el.stop, el.step])
@@ -59,7 +59,7 @@ class ArraySlice(Expr):
         return {'index': index, **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> ArraySlice:
         assert 'index' in d
         index = []
         for el in d['index']:

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:
@@ -93,10 +135,43 @@ class ColumnRef(Expr):
     def __repr__(self) -> str:
         return f'ColumnRef({self.col!r})'
 
+    def _repr_html_(self) -> str:
+        tbl = catalog.Catalog.get().tbls[self.col.tbl.id]
+        return tbl._description_html(cols=[self.col])._repr_html_()  # type: ignore[attr-defined]
+
     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 +190,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 +208,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,12 @@ 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]:
+        if str(self._op1.col_type.to_sa_type()) != str(self._op2.col_type.to_sa_type()):
+            # Comparing columns of different SQL types (e.g., string vs. json); this can only be done in Python
+            # TODO(aaron-siegel): We may be able to handle some cases in SQL by casting one side to the other's type
+            return None
+
         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 +119,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
 
@@ -57,7 +57,7 @@ class DataRow:
     # - 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]):
+    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
@@ -89,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)
@@ -124,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])
@@ -231,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