pixeltable 0.3.12__py3-none-any.whl → 0.3.13__py3-none-any.whl

pixeltable/__init__.py

@@ -24,32 +24,7 @@ from .globals import (
     tool,
     tools,
 )
-from .type_system import (
-    Array,
-    ArrayType,
-    Audio,
-    AudioType,
-    Bool,
-    BoolType,
-    ColumnType,
-    Document,
-    DocumentType,
-    Float,
-    FloatType,
-    Image,
-    ImageType,
-    Int,
-    IntType,
-    Json,
-    JsonType,
-    Required,
-    String,
-    StringType,
-    Timestamp,
-    TimestampType,
-    Video,
-    VideoType,
-)
+from .type_system import Array, Audio, Bool, Document, Float, Image, Int, Json, Required, String, Timestamp, Video
 
 # This import must go last to avoid circular imports.
 from . import ext, functions, io, iterators  # isort: skip

pixeltable/__version__.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced during build.
-__version__ = '0.3.12'
-__version_tuple__ = (0, 3, 12)
+__version__ = '0.3.13'
+__version_tuple__ = (0, 3, 13)

pixeltable/catalog/insertable_table.py

@@ -228,3 +228,14 @@ class InsertableTable(Table):
         """
         with Env.get().begin_xact():
             return self._tbl_version.get().delete(where=where)
+
+    @property
+    def _base_table(self) -> Optional['Table']:
+        return None
+
+    @property
+    def _effective_base_versions(self) -> list[Optional[int]]:
+        return []
+
+    def _table_descriptor(self) -> str:
+        return f'Table {self._path()!r}'

pixeltable/catalog/table.py

@@ -109,7 +109,7 @@ class Table(SchemaObject):
         self._check_is_dropped()
         with env.Env.get().begin_xact():
             md = super().get_metadata()
-            md['base'] = self._base._path() if self._base is not None else None
+            md['base'] = self._base_table._path() if self._base_table is not None else None
             md['schema'] = self._schema
             md['is_replica'] = self._tbl_version.get().is_replica
             md['version'] = self._version
@@ -255,28 +255,27 @@ class Table(SchemaObject):
         return {c.name: c.col_type for c in self._tbl_version_path.columns()}
 
     @property
-    def _base(self) -> Optional['Table']:
-        """
-        The base table of this `Table`. If this table is a view, returns the `Table`
-        from which it was derived. Otherwise, returns `None`.
-        """
-        if self._tbl_version_path.base is None:
-            return None
-        base_id = self._tbl_version_path.base.tbl_version.id
-        return catalog.Catalog.get().get_table_by_id(base_id)
+    @abc.abstractmethod
+    def _base_table(self) -> Optional['Table']:
+        """The base's Table instance"""
+        ...
 
     @property
-    def _bases(self) -> list['Table']:
-        """
-        The ancestor list of bases of this table, starting with its immediate base.
-        """
+    def _base_tables(self) -> list['Table']:
+        """The ancestor list of bases of this table, starting with its immediate base."""
         bases = []
-        base = self._base
+        base = self._base_table
         while base is not None:
             bases.append(base)
-            base = base._base
+            base = base._base_table
         return bases
 
+    @property
+    @abc.abstractmethod
+    def _effective_base_versions(self) -> list[Optional[int]]:
+        """The effective versions of the ancestor bases, starting with its immediate base."""
+        ...
+
     @property
     def _comment(self) -> str:
         return self._tbl_version.get().comment
@@ -300,7 +299,7 @@ class Table(SchemaObject):
         Constructs a list of descriptors for this table that can be pretty-printed.
         """
         helper = DescriptionHelper()
-        helper.append(self._title_descriptor())
+        helper.append(self._table_descriptor())
         helper.append(self._col_descriptor())
         idxs = self._index_descriptor()
         if not idxs.empty:
@@ -312,14 +311,8 @@ class Table(SchemaObject):
             helper.append(f'COMMENT: {self._comment}')
         return helper
 
-    def _title_descriptor(self) -> str:
-        title: str
-        if self._base is None:
-            title = f'Table\n{self._path()!r}'
-        else:
-            title = f'View\n{self._path()!r}'
-            title += f'\n(of {self.__bases_to_desc()})'
-        return title
+    @abc.abstractmethod
+    def _table_descriptor(self) -> str: ...
 
     def _col_descriptor(self, columns: Optional[list[str]] = None) -> pd.DataFrame:
         return pd.DataFrame(
@@ -332,14 +325,6 @@ class Table(SchemaObject):
             if columns is None or col.name in columns
         )
 
-    def __bases_to_desc(self) -> str:
-        bases = self._bases
-        assert len(bases) >= 1
-        if len(bases) <= 2:
-            return ', '.join(repr(b._path()) for b in bases)
-        else:
-            return f'{bases[0]._path()!r}, ..., {bases[-1]._path()!r}'
-
     def _index_descriptor(self, columns: Optional[list[str]] = None) -> pd.DataFrame:
         from pixeltable import index
 
@@ -373,9 +358,9 @@ class Table(SchemaObject):
         """
         self._check_is_dropped()
         if getattr(builtins, '__IPYTHON__', False):
-            from IPython.display import display
+            from IPython.display import Markdown, display
 
-            display(self._repr_html_())
+            display(Markdown(self._repr_html_()))
         else:
             print(repr(self))
 

pixeltable/catalog/view.py

@@ -267,3 +267,34 @@ class View(Table):
 
     def delete(self, where: Optional[exprs.Expr] = None) -> UpdateStatus:
         raise excs.Error(f'{self._display_name()} {self._name!r}: cannot delete from view')
+
+    @property
+    def _base_table(self) -> Optional['Table']:
+        # if this is a pure snapshot, our tbl_version_path only reflects the base (there is no TableVersion instance
+        # for the snapshot itself)
+        base_id = self._tbl_version.id if self._snapshot_only else self._tbl_version_path.base.tbl_version.id
+        return catalog.Catalog.get().get_table_by_id(base_id)
+
+    @property
+    def _effective_base_versions(self) -> list[Optional[int]]:
+        effective_versions = [tv.effective_version for tv in self._tbl_version_path.get_tbl_versions()]
+        if self._snapshot_only:
+            return effective_versions
+        else:
+            return effective_versions[1:]
+
+    def _table_descriptor(self) -> str:
+        display_name = 'Snapshot' if self._snapshot_only else 'View'
+        result = [f'{display_name} {self._path()!r}']
+        bases_descrs: list[str] = []
+        for base, effective_version in zip(self._base_tables, self._effective_base_versions):
+            if effective_version is None:
+                bases_descrs.append(f'{base._path()!r}')
+            else:
+                base_descr = f'{base._path()}:{effective_version}'
+                bases_descrs.append(f'{base_descr!r}')
+        result.append(f' (of {", ".join(bases_descrs)})')
+
+        if self._tbl_version.get().predicate is not None:
+            result.append(f'\nWhere: {self._tbl_version.get().predicate!s}')
+        return ''.join(result)

pixeltable/dataframe.py

@@ -513,9 +513,9 @@ class DataFrame:
                 (select list, where clause, ...) vertically.
         """
         if getattr(builtins, '__IPYTHON__', False):
-            from IPython.display import display
+            from IPython.display import Markdown, display
 
-            display(self._repr_html_())
+            display(Markdown(self._repr_html_()))
         else:
             print(repr(self))
 

pixeltable/exceptions.py

@@ -1,4 +1,3 @@
-from dataclasses import dataclass
 from types import TracebackType
 from typing import TYPE_CHECKING, Any
 
@@ -10,7 +9,6 @@ class Error(Exception):
     pass
 
 
-@dataclass
 class ExprEvalError(Exception):
     expr: 'exprs.Expr'
     expr_msg: str
@@ -19,6 +17,26 @@ class ExprEvalError(Exception):
     input_vals: list[Any]
     row_num: int
 
+    def __init__(
+        self,
+        expr: 'exprs.Expr',
+        expr_msg: str,
+        exc: Exception,
+        exc_tb: TracebackType,
+        input_vals: list[Any],
+        row_num: int,
+    ) -> None:
+        exct = type(exc)
+        super().__init__(
+            f'Expression evaluation failed with an error of type `{exct.__module__}.{exct.__qualname__}`:\n{expr}'
+        )
+        self.expr = expr
+        self.expr_msg = expr_msg
+        self.exc = exc
+        self.exc_tb = exc_tb
+        self.input_vals = input_vals
+        self.row_num = row_num
+
 
 class PixeltableWarning(Warning):
     pass

pixeltable/exec/expr_eval/evaluators.py

@@ -208,10 +208,6 @@ class FnCallEvaluator(Evaluator):
             _logger.debug(f'Evaluated slot {self.fn_call.slot_idx} in {end_ts - start_ts}')
             self.dispatcher.dispatch([call_args.row], self.exec_ctx)
         except Exception as exc:
-            import anthropic
-
-            if isinstance(exc, anthropic.RateLimitError):
-                _logger.debug(f'RateLimitError: {exc}')
             _, _, exc_tb = sys.exc_info()
             call_args.row.set_exc(self.fn_call.slot_idx, exc)
             self.dispatcher.dispatch_exc(call_args.rows, self.fn_call.slot_idx, exc_tb, self.exec_ctx)

pixeltable/exec/expr_eval/expr_eval_node.py

@@ -282,7 +282,6 @@ class ExprEvalNode(ExecNode):
 
                 if self.exc_event.is_set():
                     # we got an exception that we need to propagate through __iter__()
-                    _logger.debug(f'Propagating exception {self.error}')
                     if isinstance(self.error, excs.ExprEvalError):
                         raise self.error from self.error.exc
                     else:

pixeltable/exec/sql_node.py

@@ -424,6 +424,7 @@ class SqlAggregationNode(SqlNode):
     """
 
     group_by_items: Optional[list[exprs.Expr]]
+    input_cte: Optional[sql.CTE]
 
     def __init__(
         self,
@@ -440,13 +441,13 @@ class SqlAggregationNode(SqlNode):
             group_by_items: list of expressions to group by
             limit: max number of rows to return: None = no limit
         """
-        _, input_col_map = input.to_cte()
+        self.input_cte, input_col_map = input.to_cte()
         sql_elements = exprs.SqlElementCache(input_col_map)
         super().__init__(None, row_builder, select_list, sql_elements)
         self.group_by_items = group_by_items
 
     def _create_stmt(self) -> sql.Select:
-        stmt = super()._create_stmt()
+        stmt = super()._create_stmt().select_from(self.input_cte)
         if self.group_by_items is not None:
             sql_group_by_items = [self.sql_elements.get(e) for e in self.group_by_items]
             assert all(e is not None for e in sql_group_by_items)

pixeltable/func/udf.py

@@ -262,7 +262,7 @@ def from_table(
     """
     from pixeltable import exprs
 
-    ancestors = [tbl, *tbl._bases]
+    ancestors = [tbl, *tbl._base_tables]
     ancestors.reverse()  # We must traverse the ancestors in order from base to derived
 
     subst: dict[exprs.Expr, exprs.Expr] = {}

pixeltable/functions/__init__.py

@@ -5,6 +5,7 @@ from pixeltable.utils.code import local_public_names
 from . import (
     anthropic,
     audio,
+    bedrock,
     deepseek,
     fireworks,
     gemini,

pixeltable/functions/anthropic.py

@@ -112,7 +112,7 @@ async def messages(
         to an existing Pixeltable column `tbl.prompt` of the table `tbl`:
 
         >>> msgs = [{'role': 'user', 'content': tbl.prompt}]
-        ... tbl.add_computed_column(response= messages(msgs, model='claude-3-haiku-20240307'))
+        ... tbl.add_computed_column(response=messages(msgs, model='claude-3-haiku-20240307'))
     """
 
     # it doesn't look like count_tokens() actually exists in the current version of the library

pixeltable/functions/bedrock.py

@@ -0,0 +1,130 @@
+import logging
+from typing import TYPE_CHECKING, Any, Optional
+
+import pixeltable as pxt
+from pixeltable import env, exprs
+from pixeltable.func import Tools
+from pixeltable.utils.code import local_public_names
+
+if TYPE_CHECKING:
+    from botocore.client import BaseClient
+
+_logger = logging.getLogger('pixeltable')
+
+
+@env.register_client('bedrock')
+def _() -> 'BaseClient':
+    import boto3
+
+    return boto3.client(service_name='bedrock-runtime')
+
+
+# boto3 typing is weird; type information is dynamically defined, so the best we can do for the static checker is `Any`
+def _bedrock_client() -> Any:
+    return env.Env.get().get_client('bedrock')
+
+
+@pxt.udf
+def converse(
+    messages: list[dict[str, Any]],
+    *,
+    model_id: str,
+    system: Optional[list[dict[str, Any]]] = None,
+    inference_config: Optional[dict] = None,
+    additional_model_request_fields: Optional[dict] = None,
+    tool_config: Optional[list[dict]] = None,
+) -> dict:
+    """
+    Generate a conversation response.
+
+    Equivalent to the AWS Bedrock `converse` API endpoint.
+    For additional details, see: <https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference.html>
+
+    __Requirements:__
+
+    - `pip install boto3`
+
+    Args:
+        messages: Input messages.
+        model_id: The model that will complete your prompt.
+        system: An optional system prompt.
+        inference_config: Base inference parameters to use.
+        additional_model_request_fields: Additional inference parameters to use.
+
+    For details on the optional parameters, see:
+    <https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference.html>
+
+    Returns:
+        A dictionary containing the response and other metadata.
+
+    Examples:
+        Add a computed column that applies the model `anthropic.claude-3-haiku-20240307-v1:0`
+        to an existing Pixeltable column `tbl.prompt` of the table `tbl`:
+
+        >>> msgs = [{'role': 'user', 'content': [{'text': tbl.prompt}]}]
+        ... tbl.add_computed_column(response=messages(msgs, model_id='anthropic.claude-3-haiku-20240307-v1:0'))
+    """
+
+    kwargs: dict[str, Any] = {'messages': messages, 'modelId': model_id}
+
+    if system is not None:
+        kwargs['system'] = system
+    if inference_config is not None:
+        kwargs['inferenceConfig'] = inference_config
+    if additional_model_request_fields is not None:
+        kwargs['additionalModelRequestFields'] = additional_model_request_fields
+
+    if tool_config is not None:
+        tool_config_ = {
+            'tools': [
+                {
+                    'toolSpec': {
+                        'name': tool['name'],
+                        'description': tool['description'],
+                        'inputSchema': {
+                            'json': {
+                                'type': 'object',
+                                'properties': tool['parameters']['properties'],
+                                'required': tool['required'],
+                            }
+                        },
+                    }
+                }
+                for tool in tool_config
+            ]
+        }
+        kwargs['toolConfig'] = tool_config_
+
+    return _bedrock_client().converse(**kwargs)
+
+
+def invoke_tools(tools: Tools, response: exprs.Expr) -> exprs.InlineDict:
+    """Converts an Anthropic response dict to Pixeltable tool invocation format and calls `tools._invoke()`."""
+    return tools._invoke(_bedrock_response_to_pxt_tool_calls(response))
+
+
+@pxt.udf
+def _bedrock_response_to_pxt_tool_calls(response: dict) -> Optional[dict]:
+    if response.get('stopReason') != 'tool_use':
+        return None
+
+    pxt_tool_calls: dict[str, list[dict[str, Any]]] = {}
+    for message in response['output']['message']['content']:
+        if 'toolUse' in message:
+            tool_call = message['toolUse']
+            tool_name = tool_call['name']
+            if tool_name not in pxt_tool_calls:
+                pxt_tool_calls[tool_name] = []
+            pxt_tool_calls[tool_name].append({'args': tool_call['input']})
+
+    if len(pxt_tool_calls) == 0:
+        return None
+
+    return pxt_tool_calls
+
+
+__all__ = local_public_names(__name__)
+
+
+def __dir__() -> list[str]:
+    return __all__

pixeltable/functions/huggingface.py

@@ -13,6 +13,7 @@ import PIL.Image
 
 import pixeltable as pxt
 import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
 from pixeltable import env
 from pixeltable.func import Batch
 from pixeltable.functions.util import normalize_image_mode, resolve_torch_device
@@ -61,14 +62,14 @@ def sentence_transformer(
 
 
 @sentence_transformer.conditional_return_type
-def _(model_id: str) -> pxt.ArrayType:
+def _(model_id: str) -> ts.ArrayType:
     try:
         from sentence_transformers import SentenceTransformer
 
         model = _lookup_model(model_id, SentenceTransformer)
-        return pxt.ArrayType((model.get_sentence_embedding_dimension(),), dtype=pxt.FloatType(), nullable=False)
+        return ts.ArrayType((model.get_sentence_embedding_dimension(),), dtype=ts.FloatType(), nullable=False)
     except ImportError:
-        return pxt.ArrayType((None,), dtype=pxt.FloatType(), nullable=False)
+        return ts.ArrayType((None,), dtype=ts.FloatType(), nullable=False)
 
 
 @pxt.udf
@@ -199,14 +200,14 @@ def _(image: Batch[PIL.Image.Image], *, model_id: str) -> Batch[pxt.Array[(None,
 
 
 @clip.conditional_return_type
-def _(model_id: str) -> pxt.ArrayType:
+def _(model_id: str) -> ts.ArrayType:
     try:
         from transformers import CLIPModel
 
         model = _lookup_model(model_id, CLIPModel.from_pretrained)
-        return pxt.ArrayType((model.config.projection_dim,), dtype=pxt.FloatType(), nullable=False)
+        return ts.ArrayType((model.config.projection_dim,), dtype=ts.FloatType(), nullable=False)
     except ImportError:
-        return pxt.ArrayType((None,), dtype=pxt.FloatType(), nullable=False)
+        return ts.ArrayType((None,), dtype=ts.FloatType(), nullable=False)
 
 
 @pxt.udf(batch_size=4)

pixeltable/functions/image.py

@@ -16,6 +16,7 @@ from typing import Optional
 import PIL.Image
 
 import pixeltable as pxt
+import pixeltable.type_system as ts
 from pixeltable.exprs import Expr
 from pixeltable.utils.code import local_public_names
 
@@ -88,10 +89,10 @@ def convert(self: PIL.Image.Image, mode: str) -> PIL.Image.Image:
 
 
 @convert.conditional_return_type
-def _(self: Expr, mode: str) -> pxt.ColumnType:
+def _(self: Expr, mode: str) -> ts.ColumnType:
     input_type = self.col_type
-    assert isinstance(input_type, pxt.ImageType)
-    return pxt.ImageType(size=input_type.size, mode=mode, nullable=input_type.nullable)
+    assert isinstance(input_type, ts.ImageType)
+    return ts.ImageType(size=input_type.size, mode=mode, nullable=input_type.nullable)
 
 
 # Image.crop()
@@ -108,14 +109,12 @@ def crop(self: PIL.Image.Image, box: tuple[int, int, int, int]) -> PIL.Image.Ima
 
 
 @crop.conditional_return_type
-def _(self: Expr, box: tuple[int, int, int, int]) -> pxt.ColumnType:
+def _(self: Expr, box: tuple[int, int, int, int]) -> ts.ColumnType:
     input_type = self.col_type
-    assert isinstance(input_type, pxt.ImageType)
+    assert isinstance(input_type, ts.ImageType)
     if (isinstance(box, (list, tuple))) and len(box) == 4 and all(isinstance(x, int) for x in box):
-        return pxt.ImageType(
-            size=(box[2] - box[0], box[3] - box[1]), mode=input_type.mode, nullable=input_type.nullable
-        )
-    return pxt.ImageType(mode=input_type.mode, nullable=input_type.nullable)  # we can't compute the size statically
+        return ts.ImageType(size=(box[2] - box[0], box[3] - box[1]), mode=input_type.mode, nullable=input_type.nullable)
+    return ts.ImageType(mode=input_type.mode, nullable=input_type.nullable)  # we can't compute the size statically
 
 
 # Image.getchannel()
@@ -134,10 +133,10 @@ def getchannel(self: PIL.Image.Image, channel: int) -> PIL.Image.Image:
 
 
 @getchannel.conditional_return_type
-def _(self: Expr) -> pxt.ColumnType:
+def _(self: Expr) -> ts.ColumnType:
     input_type = self.col_type
-    assert isinstance(input_type, pxt.ImageType)
-    return pxt.ImageType(size=input_type.size, mode='L', nullable=input_type.nullable)
+    assert isinstance(input_type, ts.ImageType)
+    return ts.ImageType(size=input_type.size, mode='L', nullable=input_type.nullable)
 
 
 @pxt.udf(is_method=True)
@@ -183,10 +182,10 @@ def resize(self: PIL.Image.Image, size: tuple[int, int]) -> PIL.Image.Image:
 
 
 @resize.conditional_return_type
-def _(self: Expr, size: tuple[int, int]) -> pxt.ColumnType:
+def _(self: Expr, size: tuple[int, int]) -> ts.ColumnType:
     input_type = self.col_type
-    assert isinstance(input_type, pxt.ImageType)
-    return pxt.ImageType(size=size, mode=input_type.mode, nullable=input_type.nullable)
+    assert isinstance(input_type, ts.ImageType)
+    return ts.ImageType(size=size, mode=input_type.mode, nullable=input_type.nullable)
 
 
 # Image.rotate()
@@ -237,7 +236,7 @@ def transpose(self: PIL.Image.Image, method: int) -> PIL.Image.Image:
 @rotate.conditional_return_type
 @effect_spread.conditional_return_type
 @transpose.conditional_return_type
-def _(self: Expr) -> pxt.ColumnType:
+def _(self: Expr) -> ts.ColumnType:
     return self.col_type
 
 

pixeltable/functions/mistralai.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING, Optional, TypeVar, Union
 import numpy as np
 
 import pixeltable as pxt
+import pixeltable.type_system as ts
 from pixeltable.env import Env, register_client
 from pixeltable.func.signature import Batch
 from pixeltable.utils.code import local_public_names
@@ -176,9 +177,9 @@ async def embeddings(input: Batch[str], *, model: str) -> Batch[pxt.Array[(None,
 
 
 @embeddings.conditional_return_type
-def _(model: str) -> pxt.ArrayType:
+def _(model: str) -> ts.ArrayType:
     dimensions = _embedding_dimensions_cache.get(model)  # `None` if unknown model
-    return pxt.ArrayType((dimensions,), dtype=pxt.FloatType())
+    return ts.ArrayType((dimensions,), dtype=ts.FloatType())
 
 
 _T = TypeVar('_T')

pixeltable/functions/openai.py

@@ -21,6 +21,7 @@ import numpy as np
 import PIL
 
 import pixeltable as pxt
+import pixeltable.type_system as ts
 from pixeltable import env, exprs
 from pixeltable.func import Batch, Tools
 from pixeltable.utils.code import local_public_names
@@ -666,13 +667,13 @@ async def embeddings(
 
 
 @embeddings.conditional_return_type
-def _(model: str, dimensions: Optional[int] = None) -> pxt.ArrayType:
+def _(model: str, dimensions: Optional[int] = None) -> ts.ArrayType:
     if dimensions is None:
         if model not in _embedding_dimensions_cache:
             # TODO: find some other way to retrieve a sample
-            return pxt.ArrayType((None,), dtype=pxt.FloatType(), nullable=False)
+            return ts.ArrayType((None,), dtype=ts.FloatType(), nullable=False)
         dimensions = _embedding_dimensions_cache.get(model)
-    return pxt.ArrayType((dimensions,), dtype=pxt.FloatType(), nullable=False)
+    return ts.ArrayType((dimensions,), dtype=ts.FloatType(), nullable=False)
 
 
 #####################################
@@ -738,17 +739,17 @@ async def image_generations(
 
 
 @image_generations.conditional_return_type
-def _(size: Optional[str] = None) -> pxt.ImageType:
+def _(size: Optional[str] = None) -> ts.ImageType:
     if size is None:
-        return pxt.ImageType(size=(1024, 1024))
+        return ts.ImageType(size=(1024, 1024))
     x_pos = size.find('x')
     if x_pos == -1:
-        return pxt.ImageType()
+        return ts.ImageType()
     try:
         width, height = int(size[:x_pos]), int(size[x_pos + 1 :])
     except ValueError:
-        return pxt.ImageType()
-    return pxt.ImageType(size=(width, height))
+        return ts.ImageType()
+    return ts.ImageType(size=(width, height))
 
 
 #####################################

pixeltable/functions/together.py

@@ -16,6 +16,7 @@ import tenacity
 
 import pixeltable as pxt
 import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
 from pixeltable import env
 from pixeltable.func import Batch
 from pixeltable.utils.code import local_public_names
@@ -225,12 +226,12 @@ async def embeddings(input: Batch[str], *, model: str) -> Batch[pxt.Array[(None,
 
 
 @embeddings.conditional_return_type
-def _(model: str) -> pxt.ArrayType:
+def _(model: str) -> ts.ArrayType:
     if model not in _embedding_dimensions_cache:
         # TODO: find some other way to retrieve a sample
-        return pxt.ArrayType((None,), dtype=pxt.FloatType())
+        return ts.ArrayType((None,), dtype=ts.FloatType())
     dimensions = _embedding_dimensions_cache[model]
-    return pxt.ArrayType((dimensions,), dtype=pxt.FloatType())
+    return ts.ArrayType((dimensions,), dtype=ts.FloatType())
 
 
 @pxt.udf(resource_pool='request-rate:together:images')

pixeltable/io/datarows.py

@@ -3,13 +3,14 @@ from __future__ import annotations
 from typing import Any, Iterable, Optional, Union
 
 import pixeltable as pxt
+import pixeltable.type_system as ts
 from pixeltable import exceptions as excs
 
 
 def _infer_schema_from_rows(
     rows: Iterable[dict[str, Any]], schema_overrides: dict[str, Any], primary_key: list[str]
-) -> dict[str, pxt.ColumnType]:
-    schema: dict[str, pxt.ColumnType] = {}
+) -> dict[str, ts.ColumnType]:
+    schema: dict[str, ts.ColumnType] = {}
     cols_with_nones: set[str] = set()
 
     for n, row in enumerate(rows):
@@ -23,7 +24,7 @@ def _infer_schema_from_rows(
             elif value is not None:
                 # If `key` is not in `schema_overrides`, then we infer its type from the data.
                 # The column type will always be nullable by default.
-                col_type = pxt.ColumnType.infer_literal_type(value, nullable=col_name not in primary_key)
+                col_type = ts.ColumnType.infer_literal_type(value, nullable=col_name not in primary_key)
                 if col_type is None:
                     raise excs.Error(
                         f'Could not infer type for column `{col_name}`; the value in row {n} '

pixeltable/io/label_studio.py

@@ -11,7 +11,7 @@ import label_studio_sdk  # type: ignore[import-untyped]
 import PIL.Image
 from requests.exceptions import HTTPError
 
-import pixeltable as pxt
+import pixeltable.type_system as ts
 from pixeltable import Column, Table, env, exceptions as excs
 from pixeltable.config import Config
 from pixeltable.exprs import ColumnRef, DataRow, Expr
@@ -89,21 +89,21 @@ class LabelStudioProject(Project):
     def __project_config(self) -> '_LabelStudioConfig':
         return self.__parse_project_config(self.project_params['label_config'])
 
-    def get_export_columns(self) -> dict[str, pxt.ColumnType]:
+    def get_export_columns(self) -> dict[str, ts.ColumnType]:
         """
         The data keys and preannotation fields specified in this Label Studio project.
         """
         return self.__project_config.export_columns
 
-    def get_import_columns(self) -> dict[str, pxt.ColumnType]:
+    def get_import_columns(self) -> dict[str, ts.ColumnType]:
         """
         Always contains a single entry:
 
         ```
-        {"annotations": pxt.JsonType(nullable=True)}
+        {"annotations": ts.JsonType(nullable=True)}
         ```
         """
-        return {ANNOTATIONS_COLUMN: pxt.JsonType(nullable=True)}
+        return {ANNOTATIONS_COLUMN: ts.JsonType(nullable=True)}
 
     def sync(self, t: Table, export_data: bool, import_data: bool) -> SyncStatus:
         _logger.info(
@@ -412,8 +412,8 @@ class LabelStudioProject(Project):
             # TODO(aaron-siegel): Simplify this once propagation is properly implemented in batch_update
             ancestor = t
             while local_annotations_col not in ancestor._tbl_version.get().cols:
-                assert ancestor._base is not None
-                ancestor = ancestor._base
+                assert ancestor._base_table is not None
+                ancestor = ancestor._base_table
             update_status = ancestor.batch_update(updates)
             env.Env.get().console_logger.info(f'Updated annotation(s) from {len(updates)} task(s) in {self}.')
             return SyncStatus(pxt_rows_updated=update_status.num_rows, num_excs=update_status.num_excs)
@@ -577,10 +577,10 @@ class LabelStudioProject(Project):
             else:
                 local_annotations_column = next(k for k, v in col_mapping.items() if v == ANNOTATIONS_COLUMN)
             if local_annotations_column not in t._schema:
-                t.add_columns({local_annotations_column: pxt.JsonType(nullable=True)})
+                t.add_columns({local_annotations_column: ts.JsonType(nullable=True)})
 
         resolved_col_mapping = cls.validate_columns(
-            t, config.export_columns, {ANNOTATIONS_COLUMN: pxt.JsonType(nullable=True)}, col_mapping
+            t, config.export_columns, {ANNOTATIONS_COLUMN: ts.JsonType(nullable=True)}, col_mapping
         )
 
         # Perform some additional validation
@@ -649,7 +649,7 @@ class LabelStudioProject(Project):
 @dataclass(frozen=True)
 class _DataKey:
     name: Optional[str]  # The 'name' attribute of the data key; may differ from the field name
-    column_type: pxt.ColumnType
+    column_type: ts.ColumnType
 
 
 @dataclass(frozen=True)
@@ -673,18 +673,18 @@ class _LabelStudioConfig:
                 )
 
     @property
-    def export_columns(self) -> dict[str, pxt.ColumnType]:
+    def export_columns(self) -> dict[str, ts.ColumnType]:
         data_key_cols = {key_id: key_info.column_type for key_id, key_info in self.data_keys.items()}
-        rl_cols = {name: pxt.JsonType() for name in self.rectangle_labels}
+        rl_cols = {name: ts.JsonType() for name in self.rectangle_labels}
         return {**data_key_cols, **rl_cols}
 
 
 ANNOTATIONS_COLUMN = 'annotations'
 _PAGE_SIZE = 100  # This is the default used in the LS SDK
 _LS_TAG_MAP = {
-    'header': pxt.StringType(),
-    'text': pxt.StringType(),
-    'image': pxt.ImageType(),
-    'video': pxt.VideoType(),
-    'audio': pxt.AudioType(),
+    'header': ts.StringType(),
+    'text': ts.StringType(),
+    'image': ts.ImageType(),
+    'video': ts.VideoType(),
+    'audio': ts.AudioType(),
 }

pixeltable/io/pandas.py

@@ -8,6 +8,7 @@ from pandas.api.types import is_datetime64_any_dtype, is_extension_array_dtype
 
 import pixeltable as pxt
 import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
 
 
 def import_pandas(
@@ -119,15 +120,15 @@ def _df_check_primary_key_values(df: pd.DataFrame, primary_key: list[str]) -> No
 
 
 def df_infer_schema(
-    df: pd.DataFrame, schema_overrides: dict[str, pxt.ColumnType], primary_key: list[str]
-) -> dict[str, pxt.ColumnType]:
+    df: pd.DataFrame, schema_overrides: dict[str, ts.ColumnType], primary_key: list[str]
+) -> dict[str, ts.ColumnType]:
     """
     Infers a Pixeltable schema from a Pandas DataFrame.
 
     Returns:
         A tuple containing a Pixeltable schema and a list of primary key column names.
     """
-    pd_schema: dict[str, pxt.ColumnType] = {}
+    pd_schema: dict[str, ts.ColumnType] = {}
     for pd_name, pd_dtype in zip(df.columns, df.dtypes):
         if pd_name in schema_overrides:
             pxt_type = schema_overrides[pd_name]
@@ -138,7 +139,7 @@ def df_infer_schema(
     return pd_schema
 
 
-def __pd_dtype_to_pxt_type(pd_dtype: DtypeObj, nullable: bool) -> Optional[pxt.ColumnType]:
+def __pd_dtype_to_pxt_type(pd_dtype: DtypeObj, nullable: bool) -> Optional[ts.ColumnType]:
     """
     Determines a pixeltable ColumnType from a pandas dtype
 
@@ -146,21 +147,21 @@ def __pd_dtype_to_pxt_type(pd_dtype: DtypeObj, nullable: bool) -> Optional[pxt.C
         pd_dtype: A pandas dtype object
 
     Returns:
-        pxt.ColumnType: A pixeltable ColumnType
+        ts.ColumnType: A pixeltable ColumnType
     """
     # Pandas extension arrays / types (Int64, boolean, string[pyarrow], etc.) are not directly
     # compatible with NumPy dtypes
     # The timezone-aware datetime64[ns, tz=] dtype is a pandas extension dtype
     if is_datetime64_any_dtype(pd_dtype):
-        return pxt.TimestampType(nullable=nullable)
+        return ts.TimestampType(nullable=nullable)
     if is_extension_array_dtype(pd_dtype):
         return None
     # Most other pandas dtypes are directly NumPy compatible
     assert isinstance(pd_dtype, np.dtype)
-    return pxt.ArrayType.from_np_dtype(pd_dtype, nullable)
+    return ts.ArrayType.from_np_dtype(pd_dtype, nullable)
 
 
-def __pd_coltype_to_pxt_type(pd_dtype: DtypeObj, data_col: pd.Series, nullable: bool) -> pxt.ColumnType:
+def __pd_coltype_to_pxt_type(pd_dtype: DtypeObj, data_col: pd.Series, nullable: bool) -> ts.ColumnType:
     """
     Infers a Pixeltable type based on a pandas dtype.
     """
@@ -176,12 +177,12 @@ def __pd_coltype_to_pxt_type(pd_dtype: DtypeObj, data_col: pd.Series, nullable:
 
         if len(data_col) == 0:
             # No non-null values; default to FloatType (the Pandas type of an all-NaN column)
-            return pxt.FloatType(nullable=nullable)
+            return ts.FloatType(nullable=nullable)
 
-        inferred_type = pxt.ColumnType.infer_common_literal_type(data_col)
+        inferred_type = ts.ColumnType.infer_common_literal_type(data_col)
         if inferred_type is None:
             # Fallback on StringType if everything else fails
-            return pxt.StringType(nullable=nullable)
+            return ts.StringType(nullable=nullable)
         else:
             return inferred_type.copy(nullable=nullable)
 
@@ -189,7 +190,7 @@ def __pd_coltype_to_pxt_type(pd_dtype: DtypeObj, data_col: pd.Series, nullable:
 
 
 def _df_row_to_pxt_row(
-    row: tuple[Any, ...], schema: dict[str, pxt.ColumnType], col_mapping: Optional[dict[str, str]]
+    row: tuple[Any, ...], schema: dict[str, ts.ColumnType], col_mapping: Optional[dict[str, str]]
 ) -> dict[str, Any]:
     """Convert a row to insertable format"""
     pxt_row: dict[str, Any] = {}

pixeltable/io/table_data_conduit.py

@@ -15,6 +15,7 @@ from pyarrow.parquet import ParquetDataset
 
 import pixeltable as pxt
 import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
 from pixeltable.io.pandas import _df_check_primary_key_values, _df_row_to_pxt_row, df_infer_schema
 from pixeltable.utils import parse_local_file_path
 
@@ -72,6 +73,11 @@ class TableDataConduit:
     def check_source_format(self) -> None:
         assert self.source_format is None or TableDataConduitFormat.is_valid(self.source_format)
 
+    def __post_init__(self) -> None:
+        """If no extra_fields were provided, initialize to empty dict"""
+        if self.extra_fields is None:
+            self.extra_fields = {}
+
     @classmethod
     def is_rowdata_structure(cls, d: TableDataSource) -> bool:
         if not isinstance(d, list) or len(d) == 0:
@@ -83,7 +89,7 @@ class TableDataConduit:
 
     def normalize_pxt_schema_types(self) -> None:
         for name, coltype in self.pxt_schema.items():
-            self.pxt_schema[name] = pxt.ColumnType.normalize_type(coltype)
+            self.pxt_schema[name] = ts.ColumnType.normalize_type(coltype)
 
     def infer_schema(self) -> dict[str, Any]:
         raise NotImplementedError
@@ -393,7 +399,7 @@ class HFTableDataConduit(TableDataConduit):
                         f'Column name `{self.column_name_for_split}` already exists in dataset schema;'
                         f'provide a different `column_name_for_split`'
                     )
-                self.src_schema[self.column_name_for_split] = pxt.StringType(nullable=True)
+                self.src_schema[self.column_name_for_split] = ts.StringType(nullable=True)
 
             inferred_schema, inferred_pk, self.source_column_map = normalize_schema_names(
                 self.src_schema, self.src_pk, self.src_schema_overrides, True

pixeltable/metadata/converters/convert_19.py

@@ -3,7 +3,7 @@ from typing import Any, Optional
 
 import sqlalchemy as sql
 
-import pixeltable as pxt
+import pixeltable.type_system as ts
 from pixeltable.metadata import register_converter, schema
 from pixeltable.metadata.converters.util import convert_table_md
 
@@ -34,7 +34,7 @@ def __update_timestamp_literals(k: Any, v: Any) -> Optional[tuple[Any, Any]]:
         # timestamp literal, which (in version 19) is stored in the DB as a naive datetime.
         # We convert it to an aware datetime, stored in UTC.
         assert v['_classname'] == 'Literal'
-        assert v['val_t'] == pxt.ColumnType.Type.TIMESTAMP.name
+        assert v['val_t'] == ts.ColumnType.Type.TIMESTAMP.name
         assert isinstance(v['val'], str)
         dt = datetime.datetime.fromisoformat(v['val'])
         assert dt.tzinfo is None  # In version 19 all timestamps are naive

pixeltable/share/packager.py

@@ -78,7 +78,7 @@ class TablePackager:
             json.dump(self.md, fp)
         self.iceberg_catalog = sqlite_catalog(self.tmp_dir / 'warehouse')
         with Env.get().begin_xact():
-            ancestors = (self.table, *self.table._bases)
+            ancestors = (self.table, *self.table._base_tables)
             for t in ancestors:
                 _logger.info(f"Exporting table '{t._path}'.")
                 self.__export_table(t)

{pixeltable-0.3.12.dist-info → pixeltable-0.3.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pixeltable
-Version: 0.3.12
+Version: 0.3.13
 Summary: AI Data Infrastructure: Declarative, Multimodal, and Incremental
 License: Apache-2.0
 Keywords: data-science,machine-learning,database,ai,computer-vision,chatbot,ml,artificial-intelligence,feature-engineering,multimodal,mlops,feature-store,vector-database,llm,genai

{pixeltable-0.3.12.dist-info → pixeltable-0.3.13.dist-info}/RECORD

@@ -1,23 +1,23 @@
-pixeltable/__init__.py,sha256=Z0MfZlFI062slLkXfKM-LBwnU5mzDXL1rH590cZGZmo,1673
-pixeltable/__version__.py,sha256=8uFR7F1FvhAJZVB_O7-LoYs_kNA6FS4Knmjr_gvBaUE,114
+pixeltable/__init__.py,sha256=TYbL_db8k7i-xQ3G6BhywWJujwl0SyZ_i3rtO_ETtgU,1435
+pixeltable/__version__.py,sha256=PktX7ox0r5NrPEx5hjV3DTlFGMm-MthCIgxmYxRRvTQ,114
 pixeltable/catalog/__init__.py,sha256=rQmjveID4bk6NI4Ql09lGsZ0K0HVE2l1yqKAveipHzc,558
 pixeltable/catalog/catalog.py,sha256=7aS-p3Y1ArYqi2gvD57bF-VC0eGvOkeZ4HCKFUNQK7Y,48756
 pixeltable/catalog/column.py,sha256=i_KJVRvjR9Dh4tPrdf9Fg7IBGcKLYiOJKngSVBLgMCA,10800
 pixeltable/catalog/dir.py,sha256=HFemOf67Nfw13EOpQsR_UgzP2L1w4LDfw2009DrSK0Y,2063
 pixeltable/catalog/globals.py,sha256=7fNUs67D18PZ1ZajcGz7KQOV6tuXEcYLSrePzgmDkRw,4036
-pixeltable/catalog/insertable_table.py,sha256=Ote3E1kcOQ5SJOKrwRSqiKsjEujht9Vi_KO3dwd_0k8,8582
+pixeltable/catalog/insertable_table.py,sha256=JVDeUWH9HsqAUYjweennhfrfgS5iBnEniCX_Ft7b8Is,8843
 pixeltable/catalog/named_function.py,sha256=vZ-j7P4HugWh9OmUzBMwyRYvO3tQn9jWyJz_1stPavU,1210
 pixeltable/catalog/path.py,sha256=gk8TIlO_7Jpji5mAN0dUNvHmvU0uneTHeB_qCTWnszQ,2529
 pixeltable/catalog/schema_object.py,sha256=6OxJTfT1NOivL1sbg8opf4DTGvGCLqqkuuS4Xo8ESJU,1806
-pixeltable/catalog/table.py,sha256=pXKfC1fgLV8qdWK8zSRJSsr3-OQxPKZAPaO_rgO7wEc,65442
+pixeltable/catalog/table.py,sha256=CsNPB13gpLD2ap4leM-Jc0NZLJWB7yjFHs_AY0_zJ7A,64920
 pixeltable/catalog/table_version.py,sha256=iVZnJ0CfNk4i2oiGppb2ZqShStG509_nFkyrR3jOLwo,61490
 pixeltable/catalog/table_version_handle.py,sha256=LYJFTdRssPu4uOBPbP93wKqXygJXr3Gwdc9wHzzZRag,1654
 pixeltable/catalog/table_version_path.py,sha256=_g9knGenpMOlhaK8DZa8iLz5CorsMcbnFqTLnvaUkYM,6653
-pixeltable/catalog/view.py,sha256=iwqj9E-AxPK52XqyCjltbEU14dnImhFbvWpRoysjXr0,11579
+pixeltable/catalog/view.py,sha256=ZtfNoAMeqcKB7MoPfzPPRQJvniCIrYxQjqs5KI3xXog,13033
 pixeltable/config.py,sha256=gnRI4G9GE7mQJDcMcn8JsEzYk8oKVfHB-BwoLRWnRDo,3971
-pixeltable/dataframe.py,sha256=4RnQtRVJSWNzpJPQued9lyXSU3FW1Zeul502WCOxDQk,49585
+pixeltable/dataframe.py,sha256=dAR4-iLkcu8AllvP85_17u5PankzBOdm2Zanp6JR0iY,49605
 pixeltable/env.py,sha256=uQ8LZG-KU96Jhgs0wAUOn0rrj1ouAeliavnJPgvDx_Q,36250
-pixeltable/exceptions.py,sha256=NuFY2WtkQpLfLHT_J70kOw9Tr0kEDkkgo-u7As4Gaq4,410
+pixeltable/exceptions.py,sha256=eI2f4oXqv678_fDOxeYOTPE_EF1CMX3pwCqtJvN8i7s,926
 pixeltable/exec/__init__.py,sha256=m4AF2kzFtsTRUevupgWs8er0oJQisCR9ROW7ZJlL3dw,509
 pixeltable/exec/aggregation_node.py,sha256=C6gdQqCwg2Cio0bFbtGBhvjMMc4ADBjljnLwMVwdrLQ,4090
 pixeltable/exec/cache_prefetch_node.py,sha256=j8ThRGNAeP47A02MgMF0ViZdD6ZYJgTY8dbNubxQbW0,12135
@@ -26,14 +26,14 @@ pixeltable/exec/data_row_batch.py,sha256=EAB15JRhXbWIe91x1J5N5lFiMXzjB8NGTFjZsBD
 pixeltable/exec/exec_context.py,sha256=jKeLStfkjwCKKAooC-7a7qZUnZU5O0_JQhanhVerV9c,984
 pixeltable/exec/exec_node.py,sha256=WIN1sBEBNS7TlBk5QpHsDUCZUUdcvs6Os_Bxq2HoWdo,4077
 pixeltable/exec/expr_eval/__init__.py,sha256=sQThSEByK_DLfB-_-18RFhpARx49cSXYEkpCDyi0vQI,61
-pixeltable/exec/expr_eval/evaluators.py,sha256=NiFhqAdKKXfWZC4qoaxUEfW8Dfa4XtbSXjSVuYwuAd4,17009
-pixeltable/exec/expr_eval/expr_eval_node.py,sha256=KJO-Z9jLVITc-m1oIlZ3Tf5wm02OPFHC4yQx49UfcHU,19050
+pixeltable/exec/expr_eval/evaluators.py,sha256=AJkuleKhEz_8W6F3dcjTbWyKfv4IzpTh3cvQ3--OkRg,16865
+pixeltable/exec/expr_eval/expr_eval_node.py,sha256=bPPrOQhCbjuWsZCEEKvi-tehF2rz54os6TfXcjj8W1Q,18977
 pixeltable/exec/expr_eval/globals.py,sha256=fFrj2O53TgHDfVF8dgnyn1fPLi4ZHQuylewf5aHMwYk,7752
 pixeltable/exec/expr_eval/row_buffer.py,sha256=YY0thdlMNNReEOTyPp36xKPeMeXSZ0VrI9bJsXgo7sU,2744
 pixeltable/exec/expr_eval/schedulers.py,sha256=tAvCQKa1q0x7y7cdnGcTGbeku8QcoKH1GkgSm8ktOnM,17000
 pixeltable/exec/in_memory_data_node.py,sha256=csw_4qyOKsvqgIiqX6IMDw6wi2pqnHwLgoE_77j7Pck,3594
 pixeltable/exec/row_update_node.py,sha256=zU0eSyn81-vRrjAMOadRqU8luTshnPUtIbS7npyLBKY,2798
-pixeltable/exec/sql_node.py,sha256=4UmnUP50sCNRZ1eCtRauoKdosPL7tlJqnqXZI_w1u90,19752
+pixeltable/exec/sql_node.py,sha256=HxCJlzkJSYbmMVskZJihoaP2GYIZsiFUvFXxNm6MZLs,19826
 pixeltable/exprs/__init__.py,sha256=AxSMjKNavCT9F6vBaNR-nwX2iupAI5hbMb5hEj65Tfk,1096
 pixeltable/exprs/arithmetic_expr.py,sha256=sZPao0qdFWbrDx0eiAVxw1wGHJXZ5ZoCpQaScysBldE,7333
 pixeltable/exprs/array_slice.py,sha256=8Zv0E2RghdJi1Mbk0kKtOz2ccGQuXwLLb6R9v1jk7hA,2180
@@ -76,26 +76,27 @@ pixeltable/func/globals.py,sha256=5Wo4GPxYgHRRk5nvV0h_lAthKSalxKvj5n1p-uMPR0U,15
 pixeltable/func/query_template_function.py,sha256=QN_HGyBErDwdwpsI63caohsjo9usoN6WTEERG6NDtP4,7913
 pixeltable/func/signature.py,sha256=0PI6xdhLgwy9-GMkzkm7GlsBnsNMiS9aoNI9LWXwvN0,13700
 pixeltable/func/tools.py,sha256=DIfkOEj9Bp797Ew014_4YJePoUW40fQ6mvbCeg0FBR0,5721
-pixeltable/func/udf.py,sha256=anBoJUAjUa46_SbZuIVLRpRCmW_D9Ce1UeV0NyeWR3Y,13213
-pixeltable/functions/__init__.py,sha256=egLhhTusyiP9GkwImx8wT4nwO-eTxkmSPJ7NEn8TFmw,555
-pixeltable/functions/anthropic.py,sha256=-NYawpiNJkYrZLvF1MA6JxlQBId0sNTNKnuw-tF9XKY,9324
+pixeltable/func/udf.py,sha256=qQfaX1O3ZhUvSgiNnitW7nRKnZFJ5yu_Fj9ioqQgjqg,13219
+pixeltable/functions/__init__.py,sha256=3RZbfHlaOx6NkSMZU6wTZ3dsqErxmUJUFF0X4EbxQvY,568
+pixeltable/functions/anthropic.py,sha256=oTiXMfy3MupBInGRFEVkp-pHu06gF1ezJjEM2ypyvXw,9323
 pixeltable/functions/audio.py,sha256=7bsm4igQEW7RYSrSevwqaUOqyEnvBbPbJ8c-VknDl1E,657
+pixeltable/functions/bedrock.py,sha256=lTCFHjYunF3minBGWcjXR90yJ8resFjXr4niyKhfxms,4217
 pixeltable/functions/deepseek.py,sha256=KYIa-UJJUTOt9cCfmP6k6nM4MpKm1MBU8F-jWk3CycY,3827
 pixeltable/functions/fireworks.py,sha256=k0vUXxeeNYWfL_tdLgF9c-vOilr0g2tTeLkAL9SJ6ws,4972
 pixeltable/functions/gemini.py,sha256=vr1mBZDcDI1GNLp8pKVcQmUEbV9P0L0HRInE78rA4Ok,2952
 pixeltable/functions/globals.py,sha256=_u4A2aOWJGEzlA2Q2qr5p-ubA9paiCnkmC_oP908Qt0,5374
-pixeltable/functions/huggingface.py,sha256=EDOR4ADKPI9vPYAxu2nE-n3DAfk97odAK1z2C9BwYLQ,20534
-pixeltable/functions/image.py,sha256=UgUzA8GWsYtA3yyq_Ypx8pyksQwAihZTflR8g6jgk20,13971
+pixeltable/functions/huggingface.py,sha256=KM1OH0Jt6XWF2jfpHb6rGhi1mV-AQNYAsHAyQfzW4qw,20560
+pixeltable/functions/image.py,sha256=IKXljMma-uU88efptC3F4aywau7DYcD-Nqd3YpmRNRw,13971
 pixeltable/functions/json.py,sha256=Pkqkhf_1ot6RL2JB9Kw6NQAj0-nVn1eSfeHpdq5vr1M,770
 pixeltable/functions/llama_cpp.py,sha256=uf7WSZIhKDa492snnQv5ojGVLNdBWvuw0Ou3Mch1c_I,3874
 pixeltable/functions/math.py,sha256=SnAdjL7FIyEju2k3gEpk2ywn5zMmk7yGzD48JtTCX_0,1554
-pixeltable/functions/mistralai.py,sha256=ZQeGNCFNRhh7KZ5d0C7mabY2hRl9c-vOQUH5zvunmDs,6241
+pixeltable/functions/mistralai.py,sha256=yZge5T385RoiFGXEZ6OhwWHj0JnsZ8tN8Jb3VkfDmXc,6274
 pixeltable/functions/ollama.py,sha256=AmkP532HwWeTyWkTnHm_hIk0CFjzV5MwCCPnM9Kb7KM,4231
-pixeltable/functions/openai.py,sha256=1KLOwKrNGUFwJImMe1iDKnZg4Q3rB_eEnK3I73u-774,29233
+pixeltable/functions/openai.py,sha256=aDh1L2mBbSlrM8c1Rbh2QsCnmBESItLqzZ-frdgb05k,29259
 pixeltable/functions/replicate.py,sha256=SLMPNi44QMa16TVTImZRkNMXXyRZ0mmpnK6P5uXQE0k,2467
 pixeltable/functions/string.py,sha256=ToLodCr1MRVaLhzaUe5NbGNYHR9ENNpmKztSstkz5O4,20201
 pixeltable/functions/timestamp.py,sha256=0zp4urJagCcNLfJE0ltTCft-J9qs2C716TmRngKYaa0,9171
-pixeltable/functions/together.py,sha256=GBQKJz2AUs-KDIU25-_Yyp76X5z-ZKXKq3geQbi1ebw,9983
+pixeltable/functions/together.py,sha256=ufg0RehEoQEqBy9EHSKY4N3ZNT5O__cwDS0Ll467eLk,10014
 pixeltable/functions/util.py,sha256=lVya13gcao8T34OGX7zy1cglQPNwaBbSBw57bVPyHNs,745
 pixeltable/functions/video.py,sha256=rrKYGCEm-oJVQnjiNbEjDykusAtaQDLrYFNqv8Twwcw,6948
 pixeltable/functions/vision.py,sha256=_a0wY3akkVhWnnxlq__1VzSLylytlNadpNOOPOwSfLk,15393
@@ -106,15 +107,15 @@ pixeltable/index/base.py,sha256=jrE2Sack14_o_oFWkQf_qdDCSQ85SCZLcJX4GhU_JaY,1527
 pixeltable/index/btree.py,sha256=m4eUk8jVG5h2VW_IcsmWG4GN-FFk0uFHyDF6FSw_gbM,2299
 pixeltable/index/embedding_index.py,sha256=W-PO-ytmh1UTSZHDIGMJiVInwQUR5WGouEvFwVF39e4,11552
 pixeltable/io/__init__.py,sha256=Yjq13pBCBoaZv-OkIY2XSusVOC5b6cB5C6NbgJq5H1g,620
-pixeltable/io/datarows.py,sha256=6JGt5AqLvBx1fYwfMvRwVBRaOBsBLurXHhV6B22ZBPQ,6055
+pixeltable/io/datarows.py,sha256=p1UGxQOTjqI6kgQNAa3aj8TkylcNDtaGBTorOg_Pk84,6088
 pixeltable/io/external_store.py,sha256=5gHSHLi-pPWHJ4OtVtY2vxrcbLG899hNMEcLvBfvYqI,16719
 pixeltable/io/fiftyone.py,sha256=v0r28bIk2I0TRP5DfVHtBIUa4DpIJDK5sgExxOmHZ_w,6882
 pixeltable/io/globals.py,sha256=Z8ww-Pcm59ql1tvame8z0Mu1thIy5BPbW-TswGRXt4s,11368
 pixeltable/io/hf_datasets.py,sha256=VbQvRaUqmiKiIUeek_yf3-uAXlPRxpB62bUUQRQ_A_c,5356
-pixeltable/io/label_studio.py,sha256=Q-SacWYox0g8lBVWl8IxVrZhYE6NeR29aB_Iwc6GDyg,31252
-pixeltable/io/pandas.py,sha256=IeIOb_HOhARFlG112u6SqoXp4xd8Z6QlG1ADGGZcyp4,8453
+pixeltable/io/label_studio.py,sha256=uB-LReXf1l2OMuzJEENxJP-0C14r14VEmsIulK8Yr3s,31261
+pixeltable/io/pandas.py,sha256=IoY73ohdW3wMyxx8PpWYa9YJML6RqFpXCAR1-ceI64E,8477
 pixeltable/io/parquet.py,sha256=ezWHy5XnErEt4EmYDYQHrmIQLXrYChA26qVwiPoBfRQ,7672
-pixeltable/io/table_data_conduit.py,sha256=QUA94tsXAC2ak3axSoQEcxSGyNFR0VJz4gl9t43eFbQ,22987
+pixeltable/io/table_data_conduit.py,sha256=gdjr82HxJpDfH55xmbIUCX5V-Hkaj6Kmo25NESKChtk,23205
 pixeltable/io/utils.py,sha256=YMfhpqMitWz1PhXJGkCNOgNtEM1AZ55S0zXVhljC5kY,4260
 pixeltable/iterators/__init__.py,sha256=bU4EmbX85J1URmRw6G71f2I77b1ctqngEOwDmRB3T0w,455
 pixeltable/iterators/audio.py,sha256=wSVGdL5GeO3uY_lU-pNlY49E5dExIaJWY6oaXm-MnSU,9150
@@ -132,7 +133,7 @@ pixeltable/metadata/converters/convert_15.py,sha256=wKTdBt8p9GlUM3yBZFX-37J0c0_x
 pixeltable/metadata/converters/convert_16.py,sha256=9sRigN4h3UHEurV1zAwO8AwE_ERkvxNVTUPFiV9h4MU,493
 pixeltable/metadata/converters/convert_17.py,sha256=LmE8uAk2yPRN5Ddk8I_KOZjUGBKSUe-s-PoJl9ltWEE,878
 pixeltable/metadata/converters/convert_18.py,sha256=SylkXMoBPXwKEmUV72ah_5xSGNNLPWwib3km0tUE-68,1461
-pixeltable/metadata/converters/convert_19.py,sha256=9weimsB_U-rSWzALzKRCNdW_6fQ2mcq1IaiSDYSpn7k,2026
+pixeltable/metadata/converters/convert_19.py,sha256=NfU9Z6svr-x0UwVhjj1NTIZxV0QaDttGv9SIB4v_j0U,2036
 pixeltable/metadata/converters/convert_20.py,sha256=M6w3FuJypRsqUUX3K1b5sTKaQcOug6asosMfnhbUv_c,2746
 pixeltable/metadata/converters/convert_21.py,sha256=w35qzY6EfxBap3r_WEdXKTmtczsGV9KKfBOR18Ivl84,1095
 pixeltable/metadata/converters/convert_22.py,sha256=rQu4kCyCI0UguU2D4fJK8YqS-01DnOTs6H0Puzu_TV8,591
@@ -153,7 +154,7 @@ pixeltable/metadata/schema.py,sha256=EKmx29vfQo3eGD2uCJW_lPalPialSb2oUSBGTyewduE
 pixeltable/plan.py,sha256=s2wS4DIBzr19QlGCJNdPVZ_Od1FVJpTGEb7opNbHtHM,43260
 pixeltable/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pixeltable/share/__init__.py,sha256=zTJtLn0F7-5DgSIpxUvFQPO2LP7AOw9xjEaD30RH62U,58
-pixeltable/share/packager.py,sha256=mDVfOkkkc2rWEfLX35vKBuUkYQenkTKT6MhkqqXNj6U,11110
+pixeltable/share/packager.py,sha256=OZzrsnzfTUqkF4t1-ZMIsXmutqCCMFRlG4MDwRcP9Ik,11116
 pixeltable/share/publish.py,sha256=pnldL8_k71Ta9Mn_KDothhizB83Nm8Q3IsESmr9gg3k,4643
 pixeltable/store.py,sha256=G1kCi4rEFg__driaB0fGRQ8dip2YPO83bZtwXqhwoOg,22668
 pixeltable/type_system.py,sha256=xGRgz6tQzmBDZ3Lvzq7vTfD1WDJg-pa7UUMw1vv0PeE,52378
@@ -176,8 +177,8 @@ pixeltable/utils/pytorch.py,sha256=rrqXn6KVXmABEPGLjjq3qYINfCCv9SbpfPFmSx9KyGQ,3
 pixeltable/utils/s3.py,sha256=pxip2MlCqd2Qon2dzJXzfxvwtZyc-BAsjAnLL4J_OXY,587
 pixeltable/utils/sql.py,sha256=Sa4Lh-VGe8GToU5W7DRiWf2lMl9B6saPqemiT0ZdHEc,806
 pixeltable/utils/transactional_directory.py,sha256=OFKmu90oP7KwBAljwjnzP_w8euGdAXob3y4Nx9SCNHA,1357
-pixeltable-0.3.12.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pixeltable-0.3.12.dist-info/METADATA,sha256=x0ONNIBctMVl4Ir9bnLJxwSYs-a9gCdNzYldkYGu4vU,20629
-pixeltable-0.3.12.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-pixeltable-0.3.12.dist-info/entry_points.txt,sha256=ToOd-pRgG7AitEBgYoBCRRB4-KVDQ0pj_9T4a1LgwA4,97
-pixeltable-0.3.12.dist-info/RECORD,,
+pixeltable-0.3.13.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pixeltable-0.3.13.dist-info/METADATA,sha256=B0_JugfJxEKMaDJk0vcOEvczsCkEkQWWib78X11zazE,20629
+pixeltable-0.3.13.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+pixeltable-0.3.13.dist-info/entry_points.txt,sha256=ToOd-pRgG7AitEBgYoBCRRB4-KVDQ0pj_9T4a1LgwA4,97
+pixeltable-0.3.13.dist-info/RECORD,,

{pixeltable-0.3.12.dist-info → pixeltable-0.3.13.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any