pixeltable 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

pixeltable/exprs/in_predicate.py

@@ -26,7 +26,8 @@ class InPredicate(Expr):
         if value_set_expr is not None:
             if not value_set_expr.col_type.is_json_type():
                 raise excs.Error(
-                    f'isin(): argument must have a JSON type, but {value_set_expr} has type {value_set_expr.col_type}')
+                    f'isin(): argument must have a JSON type, but {value_set_expr} has type {value_set_expr.col_type}'
+                )
             self.components = [lhs.copy(), value_set_expr.copy()]
         else:
             assert value_set_literal is not None
@@ -95,4 +96,3 @@ class InPredicate(Expr):
         assert 'value_list' in d
         assert len(components) <= 2
         return cls(components[0], d['value_list'], components[1] if len(components) == 2 else None)
-

pixeltable/exprs/inline_expr.py

@@ -45,8 +45,7 @@ class InlineArray(Expr):
         elif inferred_element_type.is_array_type():
             assert isinstance(inferred_element_type, ts.ArrayType)
             col_type = ts.ArrayType(
-                (len(exprs), *inferred_element_type.shape),
-                ts.ColumnType.make_type(inferred_element_type.dtype)
+                (len(exprs), *inferred_element_type.shape), ts.ColumnType.make_type(inferred_element_type.dtype)
             )
         else:
             raise excs.Error(f'Element type is not a valid dtype for an array: {inferred_element_type}')
@@ -82,9 +81,14 @@ class InlineArray(Expr):
             # loaded and their types are known.
             return InlineList(components)  # type: ignore[return-value]
 
-    def _as_constant(self) -> Optional[np.ndarray]:
+    def as_literal(self) -> Optional[Literal]:
         assert isinstance(self.col_type, ts.ArrayType)
-        return np.array([c.as_constant() for c in self.components], dtype=self.col_type.numpy_dtype())
+        if not all(isinstance(comp, Literal) for comp in self.components):
+            return None
+        return Literal(
+            np.array([c.as_literal().val for c in self.components], dtype=self.col_type.numpy_dtype()), self.col_type
+        )
+
 
 class InlineList(Expr):
     """
@@ -97,7 +101,7 @@ class InlineList(Expr):
         json_schema = {
             'type': 'array',
             'prefixItems': [expr.col_type.to_json_schema() for expr in exprs],
-            'items': False  # No additional items (fixed length)
+            'items': False,  # No additional items (fixed length)
         }
 
         super().__init__(ts.JsonType(json_schema))
@@ -124,8 +128,11 @@ class InlineList(Expr):
     def _from_dict(cls, _: dict, components: list[Expr]) -> InlineList:
         return cls(components)
 
-    def _as_constant(self) -> Optional[list[Any]]:
-       return list(c.as_constant() for c in self.components)
+    def as_literal(self) -> Optional[Literal]:
+        if not all(isinstance(comp, Literal) for comp in self.components):
+            return None
+        return Literal(list(c.as_literal().val for c in self.components), self.col_type)
+
 
 class InlineDict(Expr):
     """
@@ -147,10 +154,7 @@ class InlineDict(Expr):
         try:
             json_schema = {
                 'type': 'object',
-                'properties': {
-                    key: expr.col_type.to_json_schema()
-                    for key, expr in zip(self.keys, exprs)
-                },
+                'properties': {key: expr.col_type.to_json_schema() for key, expr in zip(self.keys, exprs)},
             }
         except excs.Error:
             # InlineDicts are used to store iterator arguments, which are not required to be valid JSON types,
@@ -177,10 +181,7 @@ class InlineDict(Expr):
 
     def eval(self, data_row: DataRow, _: RowBuilder) -> None:
         assert len(self.keys) == len(self.components)
-        data_row[self.slot_idx] = {
-            key: data_row[expr.slot_idx]
-            for key, expr in zip(self.keys, self.components)
-        }
+        data_row[self.slot_idx] = {key: data_row[expr.slot_idx] for key, expr in zip(self.keys, self.components)}
 
     def to_kwargs(self) -> dict[str, Any]:
         """Deconstructs this expression into a dictionary by recursively unwrapping all Literals,
@@ -207,5 +208,7 @@ class InlineDict(Expr):
         arg = dict(zip(d['keys'], components))
         return InlineDict(arg)
 
-    def _as_constant(self) -> Optional[dict[str, Any]]:
-        return dict(zip(self.keys, (c.as_constant() for c in self.components)))
+    def as_literal(self) -> Optional[Literal]:
+        if not all(isinstance(comp, Literal) for comp in self.components):
+            return None
+        return Literal(dict(zip(self.keys, (c.as_literal().val for c in self.components))), self.col_type)

pixeltable/exprs/json_mapper.py

@@ -5,8 +5,9 @@ from typing import Optional
 import sqlalchemy as sql
 
 import pixeltable.type_system as ts
+
 from .data_row import DataRow
-from .expr import Expr, ExprScope, _GLOBAL_SCOPE
+from .expr import _GLOBAL_SCOPE, Expr, ExprScope
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
 
@@ -17,6 +18,7 @@ class JsonMapper(Expr):
     The target expr would typically contain relative JsonPaths, which are bound to an ObjectRef, which in turn
     is populated by JsonMapper.eval(). The JsonMapper effectively creates a new scope for its target expr.
     """
+
     def __init__(self, src_expr: Expr, target_expr: Expr):
         # TODO: type spec should be list[target_expr.col_type]
         super().__init__(ts.JsonType())
@@ -26,6 +28,7 @@ class JsonMapper(Expr):
         self.target_expr_scope = ExprScope(_GLOBAL_SCOPE)
 
         from .object_ref import ObjectRef
+
         scope_anchor = ObjectRef(self.target_expr_scope, self)
         self.components = [src_expr, target_expr, scope_anchor]
         self.parent_mapper: Optional[JsonMapper] = None
@@ -118,4 +121,3 @@ class JsonMapper(Expr):
     def _from_dict(cls, d: dict, components: list[Expr]) -> JsonMapper:
         assert len(components) == 2
         return cls(components[0], components[1])
-

pixeltable/exprs/json_path.py

@@ -23,7 +23,7 @@ class JsonPath(Expr):
         self,
         anchor: Optional['pxt.exprs.Expr'],
         path_elements: Optional[list[Union[str, int, slice]]] = None,
-        scope_idx: int = 0
+        scope_idx: int = 0,
     ) -> None:
         """
         anchor can be None, in which case this is a relative JsonPath and the anchor is set later via set_anchor().
@@ -44,15 +44,13 @@ class JsonPath(Expr):
 
     def __repr__(self) -> str:
         # else "R": the anchor is RELATIVE_PATH_ROOT
-        return (f'{str(self._anchor) if self._anchor is not None else "R"}'
-            f'{"." if isinstance(self.path_elements[0], str) else ""}{self._json_path()}')
+        return (
+            f'{str(self._anchor) if self._anchor is not None else "R"}'
+            f'{"." if isinstance(self.path_elements[0], str) else ""}{self._json_path()}'
+        )
 
     def _as_dict(self) -> dict:
-        path_elements = [
-            [el.start, el.stop, el.step] if isinstance(el, slice)
-            else el
-            for el in self.path_elements
-        ]
+        path_elements = [[el.start, el.stop, el.step] if isinstance(el, slice) else el for el in self.path_elements]
         return {'path_elements': path_elements, 'scope_idx': self.scope_idx, **super()._as_dict()}
 
     @classmethod
@@ -61,11 +59,7 @@ class JsonPath(Expr):
         assert 'scope_idx' in d
         assert len(components) <= 1
         anchor = components[0] if len(components) == 1 else None
-        path_elements = [
-            slice(el[0], el[1], el[2]) if isinstance(el, list)
-            else el
-            for el in d['path_elements']
-        ]
+        path_elements = [slice(el[0], el[1], el[2]) if isinstance(el, list) else el for el in d['path_elements']]
         return cls(anchor, path_elements, d['scope_idx'])
 
     @property
@@ -114,7 +108,7 @@ class JsonPath(Expr):
         anchor_name = self._anchor.default_column_name() if self._anchor is not None else ''
         ret_name = f'{anchor_name}.{self._json_path()}'
 
-        def cleanup_char(s : str) -> str:
+        def cleanup_char(s: str) -> str:
             if s == '.':
                 return '_'
             elif s == '*':
@@ -125,7 +119,7 @@ class JsonPath(Expr):
                 return ''
 
         clean_name = ''.join(map(cleanup_char, ret_name))
-        clean_name = clean_name.lstrip('_') # remove leading underscore
+        clean_name = clean_name.lstrip('_')  # remove leading underscore
         if clean_name == '':
             clean_name = None
 
@@ -144,9 +138,9 @@ class JsonPath(Expr):
         *two* rows (each containing col val 0), not a single row with [0, 0].
         We need to use a workaround: retrieve the entire dict, then use jmespath to extract the path correctly.
         """
-        #path_str = '$.' + '.'.join(self.path_elements)
-        #assert isinstance(self._anchor(), ColumnRef)
-        #return sql.func.jsonb_path_query(self._anchor().col.sa_col, path_str)
+        # path_str = '$.' + '.'.join(self.path_elements)
+        # assert isinstance(self._anchor(), ColumnRef)
+        # return sql.func.jsonb_path_query(self._anchor().col.sa_col, path_str)
         return None
 
     def _json_path(self) -> str:

pixeltable/exprs/literal.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 import datetime
 from typing import Any, Optional
 
-import sqlalchemy as sql
 import numpy as np
+import sqlalchemy as sql
 
 import pixeltable.type_system as ts
 from pixeltable.env import Env
@@ -65,9 +65,8 @@ class Literal(Expr):
         return super()._id_attrs() + [('val', self.val)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
-        # we need to return something here so that we can generate a Where clause for predicates
-        # that involve literals (like Where c > 0)
-        return sql.sql.expression.literal(self.val)
+        # Return a sql object so that constants can participate in SQL expressions
+        return sql.sql.expression.literal(self.val, type_=self.col_type.to_sa_type())
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         # this will be called, even though sql_expr() does not return None
@@ -89,11 +88,8 @@ class Literal(Expr):
         else:
             return {'val': self.val, **super()._as_dict()}
 
-    def _as_constant(self) -> Any:
-        return self.val
-
-    def is_constant(self) -> bool:
-        return True
+    def as_literal(self) -> Optional[Literal]:
+        return self
 
     @classmethod
     def _from_dict(cls, d: dict, components: list[Expr]) -> Literal:

pixeltable/exprs/method_ref.py

@@ -19,6 +19,7 @@ class MethodRef(Expr):
     When a `MethodRef` is called, it returns a `FunctionCall` with the base expression as the first argument.
     The effective arity of a `MethodRef` is one less than the arity of the underlying `Function`.
     """
+
     # TODO: Should this even be an `Expr`? It can't actually be evaluated directly (it has to be first
     #   converted to a `FunctionCall` by binding any remaining parameters).
 

pixeltable/exprs/object_ref.py

@@ -18,6 +18,7 @@ class ObjectRef(Expr):
     Reference to an intermediate result, such as the "scope variable" produced by a JsonMapper.
     The object is generated/materialized elsewhere and establishes a new scope.
     """
+
     def __init__(self, scope: ExprScope, owner: JsonMapper):
         # TODO: do we need an Unknown type after all?
         super().__init__(ts.JsonType())  # JsonType: this could be anything
@@ -40,4 +41,3 @@ class ObjectRef(Expr):
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         # this will be called, but the value has already been materialized elsewhere
         pass
-

pixeltable/exprs/row_builder.py

@@ -13,7 +13,9 @@ import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
 import pixeltable.func as func
 import pixeltable.utils as utils
+from pixeltable.env import Env
 from pixeltable.utils.media_store import MediaStore
+
 from .data_row import DataRow
 from .expr import Expr
 from .expr_set import ExprSet
@@ -32,7 +34,9 @@ class ExecProfile:
             per_call_time = self.eval_time[i] / self.eval_count[i]
             calls_per_row = self.eval_count[i] / num_rows
             multiple_str = f'({calls_per_row}x)' if calls_per_row > 1 else ''
-            print(f'{self.row_builder.unique_exprs[i]}: {utils.print_perf_counter_delta(per_call_time)} {multiple_str}')
+            Env.get().console_logger.info(
+                f'{self.row_builder.unique_exprs[i]}: {utils.print_perf_counter_delta(per_call_time)} {multiple_str}'
+            )
 
 
 @dataclass
@@ -40,6 +44,7 @@ class ColumnSlotIdx:
     """Info for how to locate materialized column in DataRow
     TODO: can this be integrated into RowBuilder directly?
     """
+
     col: catalog.Column
     slot_idx: int
 
@@ -50,6 +55,7 @@ class RowBuilder:
     For ColumnRefs to unstored iterator columns:
     - in order for them to be executable, we also record the iterator args and pass them to the ColumnRef
     """
+
     unique_exprs: ExprSet
     next_slot_idx: int
     input_expr_slot_idxs: set[int]
@@ -83,14 +89,13 @@ class RowBuilder:
     @dataclass
     class EvalCtx:
         """Context for evaluating a set of target exprs"""
+
         slot_idxs: list[int]  # slot idxs of exprs needed to evaluate target exprs; does not contain duplicates
         exprs: list[Expr]  # exprs corresponding to slot_idxs
         target_slot_idxs: list[int]  # slot idxs of target exprs; might contain duplicates
         target_exprs: list[Expr]  # exprs corresponding to target_slot_idxs
 
-    def __init__(
-            self, output_exprs: Sequence[Expr], columns: Sequence[catalog.Column], input_exprs: Iterable[Expr]
-    ):
+    def __init__(self, output_exprs: Sequence[Expr], columns: Sequence[catalog.Column], input_exprs: Iterable[Expr]):
         """
         Args:
             output_exprs: list of Exprs to be evaluated
@@ -106,10 +111,12 @@ class RowBuilder:
         self.input_expr_slot_idxs = {e.slot_idx for e in unique_input_exprs}
 
         resolve_cols = set(columns)
-        self.output_exprs = ExprSet([
-            self._record_unique_expr(e.copy().resolve_computed_cols(resolve_cols=resolve_cols), recursive=True)
-            for e in output_exprs
-        ])
+        self.output_exprs = ExprSet(
+            [
+                self._record_unique_expr(e.copy().resolve_computed_cols(resolve_cols=resolve_cols), recursive=True)
+                for e in output_exprs
+            ]
+        )
 
         # if init(columns):
         # - we are creating table rows and need to record columns for create_table_row()
@@ -119,6 +126,7 @@ class RowBuilder:
         #   * for write-validated columns, we need to create validating ColumnRefs
         #   * further references to that column (eg, computed cols) need to resolve to the validating ColumnRef
         from .column_ref import ColumnRef
+
         self.table_columns: list[ColumnSlotIdx] = []
         self.input_exprs = ExprSet()
         validating_colrefs: dict[Expr, Expr] = {}  # key: non-validating colref, value: corresp. validating colref
@@ -133,7 +141,8 @@ class RowBuilder:
             else:
                 # record a ColumnRef so that references to this column resolve to the same slot idx
                 perform_validation = (
-                    None if not col.col_type.is_media_type()
+                    None
+                    if not col.col_type.is_media_type()
                     else col.media_validation == catalog.MediaValidation.ON_WRITE
                 )
                 expr = ColumnRef(col, perform_validation=perform_validation)
@@ -184,10 +193,11 @@ class RowBuilder:
 
         # determine transitive dependencies for the purpose of exception propagation
         # (list of set of slot_idxs, indexed by slot_idx)
-        #self.dependents = np.zeros((self.num_materialized, self.num_materialized), dtype=bool)
+        # self.dependents = np.zeros((self.num_materialized, self.num_materialized), dtype=bool)
         self.dependencies = np.zeros((self.num_materialized, self.num_materialized), dtype=bool)
         exc_dependencies: list[set[int]] = [set() for _ in range(self.num_materialized)]
         from .column_property_ref import ColumnPropertyRef
+
         for expr in self.unique_exprs:
             if expr.slot_idx in self.input_expr_slot_idxs:
                 # this is input and therefore doesn't depend on other exprs
@@ -204,8 +214,8 @@ class RowBuilder:
         self.dependents = self.dependencies.T
         self.transitive_dependents = np.zeros((self.num_materialized, self.num_materialized), dtype=bool)
         for i in reversed(range(self.num_materialized)):
-            self.transitive_dependents[i] = (
-                self.dependents[i] | np.any(self.transitive_dependents[self.dependents[i]], axis=0)
+            self.transitive_dependents[i] = self.dependents[i] | np.any(
+                self.transitive_dependents[self.dependents[i]], axis=0
             )
 
         self._exc_dependents = [set() for _ in range(self.num_materialized)]
@@ -228,6 +238,7 @@ class RowBuilder:
 
     def set_conn(self, conn: sql.engine.Connection) -> None:
         from .function_call import FunctionCall
+
         for expr in self.unique_exprs:
             if isinstance(expr, FunctionCall) and isinstance(expr.fn, func.QueryTemplateFunction):
                 expr.fn.set_conn(conn)
@@ -352,8 +363,11 @@ class RowBuilder:
         target_slot_idxs = [e.slot_idx for e in targets]
         ctx_slot_idxs = [e.slot_idx for e in dependencies]
         return self.EvalCtx(
-            slot_idxs=ctx_slot_idxs, exprs=[self.unique_exprs[slot_idx] for slot_idx in ctx_slot_idxs],
-            target_slot_idxs=target_slot_idxs, target_exprs=targets)
+            slot_idxs=ctx_slot_idxs,
+            exprs=[self.unique_exprs[slot_idx] for slot_idx in ctx_slot_idxs],
+            target_slot_idxs=target_slot_idxs,
+            target_exprs=targets,
+        )
 
     def set_exc(self, data_row: DataRow, slot_idx: int, exc: Exception) -> None:
         """Record an exception in data_row and propagate it to dependents"""
@@ -362,7 +376,7 @@ class RowBuilder:
             data_row.set_exc(slot_idx, exc)
 
     def eval(
-            self, data_row: DataRow, ctx: EvalCtx, profile: Optional[ExecProfile] = None, ignore_errors: bool = False
+        self, data_row: DataRow, ctx: EvalCtx, profile: Optional[ExecProfile] = None, ignore_errors: bool = False
     ) -> None:
         """
         Populates the slots in data_row given in ctx.
@@ -387,7 +401,8 @@ class RowBuilder:
                 if not ignore_errors:
                     input_vals = [data_row[d.slot_idx] for d in expr.dependencies()]
                     raise excs.ExprEvalError(
-                        expr, f'expression {expr}', data_row.get_exc(expr.slot_idx), exc_tb, input_vals, 0) from exc
+                        expr, f'expression {expr}', data_row.get_exc(expr.slot_idx), exc_tb, input_vals, 0
+                    ) from exc
 
     def create_table_row(self, data_row: DataRow, exc_col_ids: set[int]) -> tuple[dict[str, Any], int]:
         """Create a table row from the slots that have an output column assigned

pixeltable/exprs/rowid_ref.py

@@ -22,9 +22,14 @@ class RowidRef(Expr):
     _from_dict()/init() is called, which is why this class effectively has two separate paths for construction
     (with and without a TableVersion).
     """
+
     def __init__(
-            self, tbl: catalog.TableVersion, idx: int,
-            tbl_id: Optional[UUID] = None, normalized_base_id: Optional[UUID] = None):
+        self,
+        tbl: catalog.TableVersion,
+        idx: int,
+        tbl_id: Optional[UUID] = None,
+        normalized_base_id: Optional[UUID] = None,
+    ):
         super().__init__(ts.IntType(nullable=False))
         self.tbl = tbl
         if tbl is not None:
@@ -48,12 +53,16 @@ class RowidRef(Expr):
         return str(self)
 
     def _equals(self, other: RowidRef) -> bool:
-        return self.normalized_base_id == other.normalized_base_id \
+        return (
+            self.normalized_base_id == other.normalized_base_id
             and self.rowid_component_idx == other.rowid_component_idx
+        )
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() +\
-            [('normalized_base_id', self.normalized_base_id), ('idx', self.rowid_component_idx)]
+        return super()._id_attrs() + [
+            ('normalized_base_id', self.normalized_base_id),
+            ('idx', self.rowid_component_idx),
+        ]
 
     def __repr__(self) -> str:
         # check if this is the pos column of a component view

pixeltable/exprs/similarity_expr.py

@@ -14,11 +14,10 @@ from .sql_element_cache import SqlElementCache
 
 
 class SimilarityExpr(Expr):
-
     def __init__(self, col_ref: ColumnRef, item: Any, idx_name: Optional[str] = None):
         super().__init__(ts.FloatType())
         item_expr = Expr.from_object(item)
-        if item_expr is None or not(item_expr.col_type.is_string_type() or item_expr.col_type.is_image_type()):
+        if item_expr is None or not (item_expr.col_type.is_string_type() or item_expr.col_type.is_image_type()):
             raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not a {type(item)}')
         assert item_expr.col_type.is_string_type() or item_expr.col_type.is_image_type()
 
@@ -27,6 +26,7 @@ class SimilarityExpr(Expr):
         # determine index to use
         idx_info = col_ref.col.get_idx_info()
         from pixeltable import index
+
         embedding_idx_info = {
             info.name: info for info in idx_info.values() if isinstance(info.idx, index.EmbeddingIndex)
         }
@@ -38,7 +38,8 @@ class SimilarityExpr(Expr):
             if idx_name is None:
                 raise excs.Error(
                     f'Column {col_ref.col.name!r} has multiple indices; use the index name to disambiguate: '
-                    f'`{col_ref.col.name}.similarity(..., idx=<name>)`')
+                    f'`{col_ref.col.name}.similarity(..., idx=<name>)`'
+                )
             self.idx_info = embedding_idx_info[idx_name]
         else:
             self.idx_info = next(iter(embedding_idx_info.values()))
@@ -48,11 +49,13 @@ class SimilarityExpr(Expr):
         if item_expr.col_type.is_string_type() and idx.string_embed is None:
             raise excs.Error(
                 f'Embedding index {self.idx_info.name!r} on column {self.idx_info.col.name!r} does not have a '
-                f"string embedding and does not support string queries")
+                f'string embedding and does not support string queries'
+            )
         if item_expr.col_type.is_image_type() and idx.image_embed is None:
             raise excs.Error(
                 f'Embedding index {self.idx_info.name!r} on column {self.idx_info.col.name!r} does not have an '
-                f"image embedding and does not support image queries")
+                f'image embedding and does not support image queries'
+            )
         self.id = self._create_id()
 
     def __repr__(self) -> str:
@@ -66,9 +69,10 @@ class SimilarityExpr(Expr):
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         if not isinstance(self.components[1], Literal):
-             raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
+            raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
         item = self.components[1].val
         from pixeltable import index
+
         assert isinstance(self.idx_info.idx, index.EmbeddingIndex)
         return self.idx_info.idx.similarity_clause(self.idx_info.val_col, item)
 
@@ -77,6 +81,7 @@ class SimilarityExpr(Expr):
             raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
         item = self.components[1].val
         from pixeltable import index
+
         assert isinstance(self.idx_info.idx, index.EmbeddingIndex)
         return self.idx_info.idx.order_by_clause(self.idx_info.val_col, item, is_asc)
 

pixeltable/exprs/sql_element_cache.py

@@ -1,4 +1,4 @@
-from typing import Iterable, Union, Optional, cast
+from typing import Iterable, Optional, Union, cast
 
 import sqlalchemy as sql
 

pixeltable/exprs/type_cast.py

@@ -1,10 +1,12 @@
-from typing import Any, Optional
+from typing import Any, Optional, Union
 
 import sqlalchemy as sql
 
+import pixeltable.exprs as exprs
 import pixeltable.type_system as ts
 
 from .expr import DataRow, Expr
+from .literal import Literal
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
 
@@ -14,21 +16,19 @@ class TypeCast(Expr):
     An `Expr` that represents a type conversion from an underlying `Expr` to
     a specified `ColumnType`.
     """
+
     def __init__(self, underlying: Expr, new_type: ts.ColumnType):
         super().__init__(new_type)
         self.components: list[Expr] = [underlying]
         self.id: Optional[int] = self._create_id()
 
-    @property
-    def _underlying(self):
-        return self.components[0]
-
     def _equals(self, other: 'TypeCast') -> bool:
         # `TypeCast` has no properties beyond those captured by `Expr`.
         return True
 
-    def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('new_type', self.col_type)]
+    @property
+    def _op1(self) -> Expr:
+        return self.components[0]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         """
@@ -38,9 +38,24 @@ class TypeCast(Expr):
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
-        original_val = data_row[self._underlying.slot_idx]
+        original_val = data_row[self._op1.slot_idx]
         data_row[self.slot_idx] = self.col_type.create_literal(original_val)
 
+    def as_literal(self) -> Optional[Literal]:
+        op1_lit = self._op1.as_literal()
+        if op1_lit is None:
+            return None
+        if not (
+            self.col_type.is_numeric_type() and (op1_lit.col_type.is_numeric_type() or op1_lit.col_type.is_bool_type())
+        ):
+            return None
+
+        op1_val = op1_lit.val
+        if self.col_type.is_int_type():
+            return Literal(int(op1_val), self.col_type)
+        elif self.col_type.is_float_type():
+            return Literal(float(op1_val), self.col_type)
+        return None
 
     def _as_dict(self) -> dict:
         return {'new_type': self.col_type.as_dict(), **super()._as_dict()}
@@ -52,4 +67,4 @@ class TypeCast(Expr):
         return cls(components[0], ts.ColumnType.from_dict(d['new_type']))
 
     def __repr__(self) -> str:
-        return f'{self._underlying}.astype({self.col_type._to_str(as_schema=True)})'
+        return f'{self._op1}.astype({self.col_type._to_str(as_schema=True)})'

pixeltable/ext/__init__.py

@@ -5,6 +5,7 @@ have dependencies whose future support is unclear.
 """
 
 from pixeltable.utils.code import local_public_names
+
 from . import functions
 
 __all__ = local_public_names(__name__)

pixeltable/ext/functions/__init__.py

@@ -1,4 +1,5 @@
 from pixeltable.utils.code import local_public_names
+
 from . import whisperx, yolox
 
 __all__ = local_public_names(__name__)

pixeltable/ext/functions/whisperx.py

@@ -15,7 +15,7 @@ def transcribe(
     model: str,
     compute_type: Optional[str] = None,
     language: Optional[str] = None,
-    chunk_size: int = 30
+    chunk_size: int = 30,
 ) -> dict:
     """
     Transcribe an audio file using WhisperX.
@@ -44,7 +44,7 @@ def transcribe(
         Add a computed column that applies the model `tiny.en` to an existing Pixeltable column `tbl.audio`
         of the table `tbl`:
 
-        >>> tbl['result'] = transcribe(tbl.audio, model='tiny.en')
+        >>> tbl.add_computed_column(result=transcribe(tbl.audio, model='tiny.en'))
     """
     import torch
     import whisperx  # type: ignore[import-untyped]