pixeltable 0.2.16__py3-none-any.whl → 0.2.18__py3-none-any.whl

pixeltable/exprs/json_path.py

@@ -9,6 +9,12 @@ import pixeltable
 import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
+from .data_row import DataRow
+from .expr import Expr
+from .globals import print_slice
+from .json_mapper import JsonMapper
+from .row_builder import RowBuilder
+from .sql_element_cache import SqlElementCache
 
 from .data_row import DataRow
 from .expr import Expr
@@ -140,7 +146,7 @@ class JsonPath(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('path_elements', self.path_elements)]
 
-    def sql_expr(self) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
         """
         Postgres appears to have a bug: jsonb_path_query('{a: [{b: 0}, {b: 1}]}', '$.a.b') returns
         *two* rows (each containing col val 0), not a single row with [0, 0].

pixeltable/exprs/literal.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
 import datetime
-from typing import Optional, List, Any, Dict, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import sqlalchemy as sql
 
-import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
+from pixeltable.env import Env
+
 from .data_row import DataRow
 from .expr import Expr
 from .row_builder import RowBuilder
+from .sql_element_cache import SqlElementCache
 
 
 class Literal(Expr):
@@ -22,6 +24,15 @@ class Literal(Expr):
             if col_type is None:
                 raise TypeError(f'Not a valid literal: {val}')
         super().__init__(col_type)
+        if isinstance(val, datetime.datetime):
+            # Normalize the datetime to UTC: all timestamps are stored as UTC (both in the database and in literals)
+            if val.tzinfo is None:
+                # We have a naive datetime. Modify it to use the configured default time zone
+                default_tz = Env.get().default_time_zone
+                if default_tz is not None:
+                    val = val.replace(tzinfo=default_tz)
+            # Now convert to UTC
+            val = val.astimezone(datetime.timezone.utc)
         self.val = val
         self.id = self._create_id()
 
@@ -29,17 +40,24 @@ class Literal(Expr):
         return 'Literal'
 
     def __str__(self) -> str:
-        if self.col_type.is_string_type() or self.col_type.is_timestamp_type():
+        if self.col_type.is_string_type():
             return f"'{self.val}'"
+        if self.col_type.is_timestamp_type():
+            assert isinstance(self.val, datetime.datetime)
+            default_tz = Env.get().default_time_zone
+            return f"'{self.val.astimezone(default_tz).isoformat()}'"
         return str(self.val)
 
+    def __repr__(self) -> str:
+        return f'Literal({self.val!r})'
+
     def _equals(self, other: Literal) -> bool:
         return self.val == other.val
 
     def _id_attrs(self) -> List[Tuple[str, Any]]:
         return super()._id_attrs() + [('val', self.val)]
 
-    def sql_expr(self) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
         # 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)
@@ -52,7 +70,12 @@ class Literal(Expr):
         # For some types, we need to explictly record their type, because JSON does not know
         # how to interpret them unambiguously
         if self.col_type.is_timestamp_type():
-            return {'val': self.val.isoformat(), 'val_t': self.col_type._type.name, **super()._as_dict()}
+            assert isinstance(self.val, datetime.datetime)
+            assert self.val.tzinfo == datetime.timezone.utc  # Must be UTC in a literal
+            # Convert to ISO format in UTC (in keeping with the principle: all timestamps are
+            # stored as UTC in the database)
+            encoded_val = self.val.isoformat()
+            return {'val': encoded_val, 'val_t': self.col_type._type.name, **super()._as_dict()}
         else:
             return {'val': self.val, **super()._as_dict()}
 
@@ -61,6 +84,10 @@ class Literal(Expr):
         assert 'val' in d
         if 'val_t' in d:
             val_t = d['val_t']
+            # Currently the only special-cased literal type is TIMESTAMP
             assert val_t == ts.ColumnType.Type.TIMESTAMP.name
-            return cls(datetime.datetime.fromisoformat(d['val']))
-        return cls(d['val'])
+            dt = datetime.datetime.fromisoformat(d['val'])
+            assert dt.tzinfo == datetime.timezone.utc  # Must be UTC in the database
+            return cls(dt)
+        else:
+            return cls(d['val'])

pixeltable/exprs/method_ref.py

@@ -2,12 +2,12 @@ from typing import Any, Optional
 
 import sqlalchemy as sql
 
-import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
 from pixeltable.exprs import Expr, FunctionCall
-from pixeltable.func import FunctionRegistry, CallableFunction
+from pixeltable.func import FunctionRegistry
 from .data_row import DataRow
 from .row_builder import RowBuilder
+from .sql_element_cache import SqlElementCache
 
 
 class MethodRef(Expr):
@@ -53,7 +53,7 @@ class MethodRef(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('method_name', self.method_name)]
 
-    def sql_expr(self) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:

pixeltable/exprs/object_ref.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple
-import copy
+
+from typing import Optional
 
 import sqlalchemy as sql
 
+import pixeltable.type_system as ts
+from .data_row import DataRow
 from .expr import Expr, ExprScope
 from .json_mapper import JsonMapper
-from .data_row import DataRow
 from .row_builder import RowBuilder
-import pixeltable.type_system as ts
+from .sql_element_cache import SqlElementCache
 
 
 class ObjectRef(Expr):
@@ -32,7 +33,7 @@ class ObjectRef(Expr):
     def _equals(self, other: ObjectRef) -> bool:
         return self.owner is other.owner
 
-    def sql_expr(self) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:

pixeltable/exprs/row_builder.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import sys
 import time
 from dataclasses import dataclass
-from typing import Optional, List, Any, Dict, Sequence, Tuple, Set
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, Tuple
 
 import sqlalchemy as sql
 
@@ -11,6 +11,7 @@ import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
 import pixeltable.func as func
 import pixeltable.utils as utils
+
 from .data_row import DataRow
 from .expr import Expr
 from .expr_set import ExprSet
@@ -22,7 +23,7 @@ class ExecProfile:
         self.eval_count = [0] * row_builder.num_materialized
         self.row_builder = row_builder
 
-    def print(self, num_rows: int) -> str:
+    def print(self, num_rows: int) -> None:
         for i in range(self.row_builder.num_materialized):
             if self.eval_count[i] == 0:
                 continue
@@ -57,7 +58,7 @@ class RowBuilder:
         target_exprs: List[Expr]  # exprs corresponding to target_slot_idxs
 
     def __init__(
-            self, output_exprs: Sequence[Expr], columns: Sequence[catalog.Column], input_exprs: Sequence[Expr]
+            self, output_exprs: Sequence[Expr], columns: Sequence[catalog.Column], input_exprs: Iterable[Expr]
     ):
         """
         Args:
@@ -96,7 +97,7 @@ class RowBuilder:
                 expr = ColumnRef(col)
                 expr = self._record_unique_expr(expr, recursive=False)
             self.add_table_column(col, expr.slot_idx)
-            self.output_exprs.append(expr)
+            self.output_exprs.add(expr)
 
         # default eval ctx: all output exprs
         self.default_eval_ctx = self.create_eval_ctx(list(self.output_exprs), exclude=unique_input_exprs)
@@ -193,7 +194,7 @@ class RowBuilder:
                 expr.components[i] = self._record_unique_expr(c, True)
         assert expr.slot_idx is None
         expr.slot_idx = self._next_slot_idx()
-        self.unique_exprs.append(expr)
+        self.unique_exprs.add(expr)
         return expr
 
     def _record_output_expr_id(self, e: Expr, output_expr_id: int) -> None:
@@ -227,18 +228,25 @@ class RowBuilder:
         # merge dependencies and convert to list
         return sorted(set().union(*[dependencies[i] for i in target_slot_idxs]))
 
-    def substitute_exprs(self, expr_list: list, remove_duplicates: bool = True) -> None:
-        """Substitutes exprs with their executable counterparts from unique_exprs and optionally removes duplicates"""
-        i = 0
-        unique_ids: set[int] = set()  # slot idxs within expr_list
-        while i < len(expr_list):
-            unique_expr = self.unique_exprs[expr_list[i]]
-            if unique_expr.slot_idx in unique_ids and remove_duplicates:
-                del expr_list[i]
-            else:
-                expr_list[i] = unique_expr
-                unique_ids.add(unique_expr.slot_idx)
-                i += 1
+    def set_slot_idxs(self, expr_list: Sequence[Expr], remove_duplicates: bool = True) -> None:
+        """
+        Recursively sets slot_idx in expr_list and its components
+
+        remove_duplicates == True: removes duplicates in-place
+        """
+        for e in expr_list:
+            self.__set_slot_idxs_aux(e)
+        if remove_duplicates:
+            deduped = list(ExprSet(expr_list))
+            expr_list[:] = deduped
+
+    def __set_slot_idxs_aux(self, e: Expr) -> None:
+        """Recursively sets slot_idx in e and its components"""
+        if e not in self.unique_exprs:
+            return
+        e.slot_idx = self.unique_exprs[e].slot_idx
+        for c in e.components:
+            self.__set_slot_idxs_aux(c)
 
     def get_dependencies(self, targets: List[Expr], exclude: Optional[List[Expr]] = None) -> List[Expr]:
         """

pixeltable/exprs/rowid_ref.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 from typing import Optional, List, Any, Dict, Tuple
+from .sql_element_cache import SqlElementCache
 from uuid import UUID
 
 import sqlalchemy as sql
@@ -72,7 +73,7 @@ class RowidRef(Expr):
         self.tbl = tbl.tbl_version
         self.tbl_id = self.tbl.id
 
-    def sql_expr(self) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
         tbl = self.tbl if self.tbl is not None else catalog.Catalog.get().tbl_versions[(self.tbl_id, None)]
         rowid_cols = tbl.store_tbl.rowid_columns()
         return rowid_cols[self.rowid_component_idx]

pixeltable/exprs/similarity_expr.py

@@ -1,4 +1,5 @@
 from typing import Optional, List, Any
+from .sql_element_cache import SqlElementCache
 
 import sqlalchemy as sql
 import PIL.Image
@@ -56,7 +57,7 @@ class SimilarityExpr(Expr):
     def __str__(self) -> str:
         return f'{self.components[0]}.similarity({self.components[1]})'
 
-    def sql_expr(self) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
         if not isinstance(self.components[1], Literal):
              raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
         item = self.components[1].val

pixeltable/exprs/sql_element_cache.py

@@ -0,0 +1,30 @@
+from typing import Iterable, Union, Optional
+
+import sqlalchemy as sql
+
+from .expr import Expr
+
+
+class SqlElementCache:
+    """Cache of sql.ColumnElements for exprs"""
+
+    cache: dict[int, Optional[sql.ColumnElement]]  # key: Expr.id
+
+    def __init__(self):
+        self.cache = {}
+
+    def get(self, e: Expr) -> Optional[sql.ColumnElement]:
+        """Returns the sql.ColumnElement for the given Expr, or None if Expr.to_sql() returns None."""
+        try:
+            return self.cache[e.id]
+        except KeyError:
+            pass
+        el = e.sql_expr(self)
+        self.cache[e.id] = el
+        return el
+
+    def contains(self, items: Union[Expr, Iterable[Expr]]) -> bool:
+        """Returns True if every item has a (non-None) sql.ColumnElement."""
+        if isinstance(items, Expr):
+            return self.get(items) is not None
+        return all(self.get(e) is not None for e in items)

pixeltable/exprs/type_cast.py

@@ -1,4 +1,3 @@
-import json
 from typing import Optional, Dict, List, Tuple, Any
 
 import sqlalchemy as sql
@@ -6,6 +5,7 @@ import sqlalchemy as sql
 import pixeltable.type_system as ts
 from .expr import DataRow, Expr
 from .row_builder import RowBuilder
+from .sql_element_cache import SqlElementCache
 
 
 class TypeCast(Expr):
@@ -29,9 +29,9 @@ class TypeCast(Expr):
     def _id_attrs(self) -> List[Tuple[str, Any]]:
         return super()._id_attrs() + [('new_type', self.col_type)]
 
-    def sql_expr(self) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
         """
-        `sql_expr` is unimplemented for now, in order to sidestep potentially thorny
+        sql_expr() is unimplemented for now, in order to sidestep potentially thorny
         questions about consistency of doing type conversions in both Python and Postgres.
         """
         return None

pixeltable/exprs/variable.py

@@ -6,6 +6,7 @@ import pixeltable.type_system as ts
 from .data_row import DataRow
 from .expr import Expr
 from .row_builder import RowBuilder
+from .sql_element_cache import SqlElementCache
 
 
 class Variable(Expr):
@@ -31,7 +32,7 @@ class Variable(Expr):
     def __str__(self) -> str:
         return self.name
 
-    def sql_expr(self) -> NoReturn:
+    def sql_expr(self, _: SqlElementCache) -> NoReturn:
         raise NotImplementedError()
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> NoReturn:

pixeltable/ext/functions/whisperx.py

@@ -1,9 +1,9 @@
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from pixeltable.utils.code import local_public_names
 
 if TYPE_CHECKING:
-    from whisperx.asr import FasterWhisperPipeline
+    from whisperx.asr import FasterWhisperPipeline  # type: ignore[import-untyped]
 
 import pixeltable as pxt
 
@@ -40,7 +40,7 @@ def transcribe(
         >>> tbl['result'] = transcribe(tbl.audio, model='tiny.en')
     """
     import torch
-    import whisperx
+    import whisperx  # type: ignore[import-untyped]
 
     device = 'cuda' if torch.cuda.is_available() else 'cpu'
     compute_type = compute_type or ('float16' if device == 'cuda' else 'int8')
@@ -60,7 +60,7 @@ def _lookup_model(model_id: str, device: str, compute_type: str) -> 'FasterWhisp
     return _model_cache[key]
 
 
-_model_cache = {}
+_model_cache: dict[tuple[str, str, str], 'FasterWhisperPipeline'] = {}
 
 
 __all__ = local_public_names(__name__)

pixeltable/ext/functions/yolox.py

@@ -1,10 +1,10 @@
 import logging
 from pathlib import Path
-from typing import Iterable, Iterator, TYPE_CHECKING
+from typing import TYPE_CHECKING, Iterable, Iterator
 from urllib.request import urlretrieve
 
-import PIL.Image
 import numpy as np
+import PIL.Image
 
 import pixeltable as pxt
 from pixeltable import env
@@ -14,8 +14,8 @@ from pixeltable.utils.code import local_public_names
 
 if TYPE_CHECKING:
     import torch
-    from yolox.exp import Exp
-    from yolox.models import YOLOX
+    from yolox.exp import Exp  # type: ignore[import-untyped]
+    from yolox.models import YOLOX  # type: ignore[import-untyped]
 
 _logger = logging.getLogger('pixeltable')
 
@@ -47,7 +47,7 @@ def yolox(images: Batch[PIL.Image.Image], *, model_id: str, threshold: float = 0
         >>> tbl['detections'] = yolox(tbl.image, model_id='yolox_m', threshold=0.8)
     """
     import torch
-    from yolox.utils import postprocess
+    from yolox.utils import postprocess  # type: ignore[import-untyped]
 
     model, exp = _lookup_model(model_id, 'cpu')
     image_tensors = list(_images_to_tensors(images, exp))
@@ -107,7 +107,7 @@ def yolo_to_coco(detections: dict) -> list:
 
 def _images_to_tensors(images: Iterable[PIL.Image.Image], exp: 'Exp') -> Iterator['torch.Tensor']:
     import torch
-    from yolox.data import ValTransform
+    from yolox.data import ValTransform  # type: ignore[import-untyped]
 
     _val_transform = ValTransform(legacy=False)
     for image in images:

pixeltable/func/aggregate_function.py

@@ -18,6 +18,7 @@ if TYPE_CHECKING:
 class Aggregator(abc.ABC):
     def update(self, *args: Any, **kwargs: Any) -> None:
         pass
+
     def value(self) -> Any:
         pass
 

pixeltable/func/function.py

@@ -5,10 +5,10 @@ import importlib
 import inspect
 from typing import Any, Callable, Dict, Optional, Tuple
 
+import sqlalchemy as sql
+
 import pixeltable
-import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
-
 from .globals import resolve_symbol
 from .signature import Signature
 
@@ -21,14 +21,29 @@ class Function(abc.ABC):
     via the member self_path.
     """
 
-    def __init__(self, signature: Signature, self_path: Optional[str] = None, is_method: bool = False, is_property: bool = False):
+    signature: Signature
+    self_path: Optional[str]
+    is_method: bool
+    is_property: bool
+    _conditional_return_type: Optional[Callable[..., ts.ColumnType]]
+
+    # Translates a call to this function with the given arguments to its SQLAlchemy equivalent.
+    # Overriden for specific Function instances via the to_sql() decorator. The override must accept the same
+    # parameter names as the original function. Each parameter is going to be of type sql.ColumnElement.
+    _to_sql: Callable[..., Optional[sql.ColumnElement]]
+
+
+    def __init__(
+        self, signature: Signature, self_path: Optional[str] = None, is_method: bool = False, is_property: bool = False
+    ):
         # Check that stored functions cannot be declared using `is_method` or `is_property`:
         assert not ((is_method or is_property) and self_path is None)
         self.signature = signature
         self.self_path = self_path  # fully-qualified path to self
         self.is_method = is_method
         self.is_property = is_property
-        self._conditional_return_type: Optional[Callable[..., ts.ColumnType]] = None
+        self._conditional_return_type = None
+        self._to_sql = self.__default_to_sql
 
     @property
     def name(self) -> str:
@@ -88,6 +103,15 @@ class Function(abc.ABC):
         """Execute the function with the given arguments and return the result."""
         pass
 
+    def to_sql(self, fn: Callable[..., Optional[sql.ColumnElement]]) -> Callable[..., Optional[sql.ColumnElement]]:
+        """Instance decorator for specifying the SQL translation of this function"""
+        self._to_sql = fn
+        return fn
+
+    def __default_to_sql(self, *args: Any, **kwargs: Any) -> Optional[sql.ColumnElement]:
+        """The default implementation of SQL translation, which provides no translation"""
+        return None
+
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, self.__class__):
             return False

pixeltable/functions/__init__.py

@@ -1,7 +1,9 @@
-from . import audio, fireworks, huggingface, image, json, openai, string, timestamp, together, video, vision
-from .globals import *
 from pixeltable.utils.code import local_public_names
 
+from . import (anthropic, audio, fireworks, huggingface, image, json, mistralai, openai, string, timestamp, together,
+               video, vision)
+from .globals import *
+
 __all__ = local_public_names(__name__, exclude=['globals']) + local_public_names(globals.__name__)
 
 

pixeltable/functions/anthropic.py

@@ -0,0 +1,107 @@
+"""
+Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs)
+that wrap various endpoints from the Anthropic API. In order to use them, you must
+first `pip install anthropic` and configure your Anthropic credentials, as described in
+the [Working with Anthropic](https://pixeltable.readme.io/docs/working-with-anthropic) tutorial.
+"""
+
+from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
+
+import tenacity
+
+import pixeltable as pxt
+from pixeltable import env
+from pixeltable.utils.code import local_public_names
+
+if TYPE_CHECKING:
+    import anthropic
+
+
+@env.register_client('anthropic')
+def _(api_key: str) -> 'anthropic.Anthropic':
+    import anthropic
+    return anthropic.Anthropic(api_key=api_key)
+
+
+def _anthropic_client() -> 'anthropic.Anthropic':
+    return env.Env.get().get_client('anthropic')
+
+
+def _retry(fn: Callable) -> Callable:
+    import anthropic
+    return tenacity.retry(
+        retry=tenacity.retry_if_exception_type(anthropic.RateLimitError),
+        wait=tenacity.wait_random_exponential(multiplier=1, max=60),
+        stop=tenacity.stop_after_attempt(20),
+    )(fn)
+
+
+@pxt.udf
+def messages(
+    messages: list[dict[str, str]],
+    *,
+    model: str,
+    max_tokens: int = 1024,
+    metadata: Optional[dict[str, Any]] = None,
+    stop_sequences: Optional[list[str]] = None,
+    system: Optional[str] = None,
+    temperature: Optional[float] = None,
+    tool_choice: Optional[list[dict]] = None,
+    tools: Optional[dict] = None,
+    top_k: Optional[int] = None,
+    top_p: Optional[float] = None,
+) -> dict:
+    """
+    Create a Message.
+
+    Equivalent to the Anthropic `messages` API endpoint.
+    For additional details, see: <https://docs.anthropic.com/en/api/messages>
+
+    __Requirements:__
+
+    - `pip install anthropic`
+
+    Args:
+        messages: Input messages.
+        model: The model that will complete your prompt.
+
+    For details on the other parameters, see: <https://docs.anthropic.com/en/api/messages>
+
+    Returns:
+        A dictionary containing the response and other metadata.
+
+    Examples:
+        Add a computed column that applies the model `claude-3-haiku-20240307`
+        to an existing Pixeltable column `tbl.prompt` of the table `tbl`:
+
+        >>> msgs = [{'role': 'user', 'content': tbl.prompt}]
+        ... tbl['response'] = messages(msgs, model='claude-3-haiku-20240307')
+    """
+    return _retry(_anthropic_client().messages.create)(
+        messages=messages,
+        model=model,
+        max_tokens=max_tokens,
+        metadata=_opt(metadata),
+        stop_sequences=_opt(stop_sequences),
+        system=_opt(system),
+        temperature=_opt(temperature),
+        tool_choice=_opt(tool_choice),
+        tools=_opt(tools),
+        top_k=_opt(top_k),
+        top_p=_opt(top_p),
+    ).dict()
+
+
+_T = TypeVar('_T')
+
+
+def _opt(arg: _T) -> Union[_T, 'anthropic.NotGiven']:
+    import anthropic
+    return arg if arg is not None else anthropic.NOT_GIVEN
+
+
+__all__ = local_public_names(__name__)
+
+
+def __dir__():
+    return __all__

pixeltable/functions/fireworks.py

@@ -12,7 +12,7 @@ from pixeltable import env
 from pixeltable.utils.code import local_public_names
 
 if TYPE_CHECKING:
-    import fireworks.client
+    import fireworks.client  # type: ignore[import-untyped]
 
 
 @env.register_client('fireworks')
@@ -60,7 +60,7 @@ def chat_completions(
         to an existing Pixeltable column `tbl.prompt` of the table `tbl`:
 
         >>> messages = [{'role': 'user', 'content': tbl.prompt}]
-        ... tbl['response'] = chat_completions(tbl.prompt, model='accounts/fireworks/models/mixtral-8x22b-instruct')
+        ... tbl['response'] = chat_completions(messages, model='accounts/fireworks/models/mixtral-8x22b-instruct')
     """
     kwargs = {'max_tokens': max_tokens, 'top_k': top_k, 'top_p': top_p, 'temperature': temperature}
     kwargs_not_none = {k: v for k, v in kwargs.items() if v is not None}

pixeltable/functions/globals.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union
+from typing import Optional, Union, Any
 
 import pixeltable.func as func
 import pixeltable.type_system as ts
@@ -25,6 +25,11 @@ class sum(func.Aggregator):
     def value(self) -> Union[int, float]:
         return self.sum
 
+# @sum.to_sql
+# def _(val: 'sqlalchemy.ColumnElements') -> Optional['sqlalchemy.ColumnElements']:
+#     import sqlalchemy as sql
+#     return sql.sql.functions.sum(val)
+
 
 @func.uda(update_types=[ts.IntType()], value_type=ts.IntType(), allows_window=True, requires_order_by=False)
 class count(func.Aggregator):

pixeltable/functions/huggingface.py

@@ -332,8 +332,8 @@ def _lookup_processor(model_id: str, create: Callable[[str], T]) -> T:
     return _processor_cache[key]
 
 
-_model_cache = {}
-_processor_cache = {}
+_model_cache: dict[tuple[str, Callable, Optional[str]], Any] = {}
+_processor_cache: dict[tuple[str, Callable], Any] = {}
 
 
 __all__ = local_public_names(__name__)