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

pixeltable/__version__.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced during build.
-__version__ = "0.3.1"
-__version_tuple__ = (0, 3, 1)
+__version__ = "0.3.2"
+__version_tuple__ = (0, 3, 2)

pixeltable/catalog/insertable_table.py

@@ -68,7 +68,7 @@ class InsertableTable(Table):
             cat.tbls[tbl._id] = tbl
 
             _logger.info(f'Created table `{name}`, id={tbl_version.id}')
-            print(f'Created table `{name}`.')
+            Env.get().console_logger.info(f'Created table `{name}`.')
             return tbl
 
     def get_metadata(self) -> dict[str, Any]:
@@ -134,7 +134,7 @@ class InsertableTable(Table):
             f'Inserted {status.num_rows} row{"" if status.num_rows == 1 else "s"} '
             f'with {status.num_excs} error{"" if status.num_excs == 1 else "s"}{cols_with_excs_str}.'
         )
-        print(msg)
+        Env.get().console_logger.info(msg)
         _logger.info(f'InsertableTable {self._name}: {msg}')
         FileCache.get().emit_eviction_warnings()
         return status
@@ -164,7 +164,7 @@ class InsertableTable(Table):
                     row[col_name] = checked_val
                 except TypeError as e:
                     msg = str(e)
-                    raise excs.Error(f'Error in column {col.name}: {msg[0].lower() + msg[1:]}\nRow: {row}')
+                    raise excs.Error(f'Error in column {col.name}: {msg[0].lower() + msg[1:]}\nRow: {row}') from e
 
     def delete(self, where: Optional['pxt.exprs.Expr'] = None) -> UpdateStatus:
         """Delete rows in this table.

pixeltable/catalog/table.py

@@ -1345,7 +1345,7 @@ class Table(SchemaObject):
             raise excs.Error(f'Table `{self._name}` already has an external store with that name: {store.name}')
         _logger.info(f'Linking external store `{store.name}` to table `{self._name}`')
         self._tbl_version.link_external_store(store)
-        print(f'Linked external store `{store.name}` to table `{self._name}`.')
+        env.Env.get().console_logger.info(f'Linked external store `{store.name}` to table `{self._name}`.')
 
     def unlink_external_stores(
             self,
@@ -1381,7 +1381,7 @@ class Table(SchemaObject):
 
         for store in stores:
             self._tbl_version.unlink_external_store(store, delete_external_data=delete_external_data)
-            print(f'Unlinked external store from table `{self._name}`: {store}')
+            env.Env.get().console_logger.info(f'Unlinked external store from table `{self._name}`: {store}')
 
     def sync(
             self,

pixeltable/catalog/table_version.py

@@ -532,7 +532,7 @@ class TableVersion:
             f'Added {status.num_rows} column value{"" if status.num_rows == 1 else "s"} '
             f'with {status.num_excs} error{"" if status.num_excs == 1 else "s"}.'
         )
-        print(msg)
+        Env.get().console_logger.info(msg)
         _logger.info(f'Columns {[col.name for col in cols]}: {msg}')
         return status
 

pixeltable/catalog/view.py

@@ -156,7 +156,7 @@ class View(Table):
                 plan, num_values_per_row = Planner.create_view_load_plan(view._tbl_version_path)
                 num_rows, num_excs, cols_with_excs = tbl_version.store_tbl.insert_rows(
                     plan, session.connection(), v_min=tbl_version.version)
-                print(f'Created view `{name}` with {num_rows} rows, {num_excs} exceptions.')
+                Env.get().console_logger.info(f'Created view `{name}` with {num_rows} rows, {num_excs} exceptions.')
 
             session.commit()
             cat = Catalog.get()

pixeltable/env.py

@@ -18,7 +18,8 @@ import uuid
 import warnings
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Type
+from sys import stdout
+from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 import pixeltable_pgserver
@@ -28,6 +29,7 @@ from tqdm import TqdmWarning
 
 import pixeltable.exceptions as excs
 from pixeltable import metadata
+from pixeltable.utils.console_output import ConsoleLogger, ConsoleMessageFilter, ConsoleOutputHandler, map_level
 from pixeltable.utils.http_server import make_server
 
 if TYPE_CHECKING:
@@ -67,6 +69,7 @@ class Env:
     _httpd: Optional[http.server.HTTPServer]
     _http_address: Optional[str]
     _logger: logging.Logger
+    _console_logger: ConsoleLogger
     _default_log_level: int
     _logfilename: Optional[str]
     _log_to_stdout: bool
@@ -92,6 +95,8 @@ class Env:
         cls._instance = env
 
     def __init__(self):
+        assert self._instance is None, 'Env is a singleton; use Env.get() to access the instance'
+
         self._home = None
         self._media_dir = None  # computed media files
         self._file_cache_dir = None  # cached media files with external URL
@@ -231,6 +236,10 @@ class Env:
         else:
             return False
 
+    @property
+    def console_logger(self) -> ConsoleLogger:
+        return self._console_logger
+
     def _set_up(self, echo: bool = False, reinit_db: bool = False) -> None:
         if self._initialized:
             return
@@ -288,6 +297,14 @@ class Env:
             warnings.simplefilter('ignore', category=UserWarning)
             warnings.simplefilter('ignore', category=FutureWarning)
 
+        # Set verbose level for user visible console messages
+        verbosity = map_level(self._config.get_int_value('verbosity'))
+        stdout_handler = ConsoleOutputHandler(stream=stdout)
+        stdout_handler.setLevel(verbosity)
+        stdout_handler.addFilter(ConsoleMessageFilter())
+        self._logger.addHandler(stdout_handler)
+        self._console_logger = ConsoleLogger(self._logger)
+
         # configure _logger to log to a file
         self._logfilename = datetime.datetime.now().strftime('%Y%m%d_%H%M%S') + '.log'
         fh = logging.FileHandler(self._log_dir / self._logfilename, mode='w')
@@ -361,7 +378,7 @@ class Env:
             schema.base_metadata.create_all(self._sa_engine)
             metadata.create_system_info(self._sa_engine)
 
-        print(f'Connected to Pixeltable database at: {self.db_url}')
+        self.console_logger.info(f'Connected to Pixeltable database at: {self.db_url}')
 
         # we now have a home directory and db; start other services
         self._set_up_runtime()

pixeltable/exec/expr_eval/evaluators.py

@@ -32,8 +32,7 @@ class DefaultExprEvaluator(Evaluator):
     def schedule(self, rows: list[exprs.DataRow], slot_idx: int) -> None:
         assert self.e.slot_idx >= 0
         task = asyncio.create_task(self.eval(rows))
-        self.dispatcher.tasks.add(task)
-        task.add_done_callback(self.dispatcher.done_cb)
+        self.dispatcher.register_task(task)
 
     async def eval(self, rows: list[exprs.DataRow]) -> None:
         rows_with_excs: set[int] = set()  # records idxs into rows
@@ -134,8 +133,7 @@ class FnCallEvaluator(Evaluator):
                     scheduler.submit(batched_call_args)
                 else:
                     task = asyncio.create_task(self.eval_batch(batched_call_args))
-                    self.dispatcher.tasks.add(task)
-                    task.add_done_callback(self.dispatcher.done_cb)
+                    self.dispatcher.register_task(task)
 
         elif self.fn.is_async:
             if self.fn_call.resource_pool is not None:
@@ -147,14 +145,12 @@ class FnCallEvaluator(Evaluator):
                 # create one task per call
                 for item in rows_call_args:
                     task = asyncio.create_task(self.eval_async(item))
-                    self.dispatcher.tasks.add(task)
-                    task.add_done_callback(self.dispatcher.done_cb)
+                    self.dispatcher.register_task(task)
 
         else:
             # create a single task for all rows
             task = asyncio.create_task(self.eval(rows_call_args))
-            self.dispatcher.tasks.add(task)
-            task.add_done_callback(self.dispatcher.done_cb)
+            self.dispatcher.register_task(task)
 
     def _queued_call_args_iter(self) -> Iterator[FnCallArgs]:
         while not self.call_args_queue.empty():
@@ -241,5 +237,4 @@ class FnCallEvaluator(Evaluator):
             return
         batched_call_args = self._create_batch_call_args(list(self._queued_call_args_iter()))
         task = asyncio.create_task(self.eval_batch(batched_call_args))
-        self.dispatcher.tasks.add(task)
-        task.add_done_callback(self.dispatcher.done_cb)
+        self.dispatcher.register_task(task)

pixeltable/exec/expr_eval/expr_eval_node.py

@@ -391,7 +391,11 @@ class ExprEvalNode(ExecNode):
             _logger.debug(f'Scheduling {len(ready_rows)} rows for slot {slot_idx}')
             self.slot_evaluators[slot_idx].schedule(ready_rows, slot_idx)
 
-    def done_cb(self, t: asyncio.Task) -> None:
+    def register_task(self, t: asyncio.Task) -> None:
+        self.tasks.add(t)
+        t.add_done_callback(self._done_cb)
+
+    def _done_cb(self, t: asyncio.Task) -> None:
         self.tasks.discard(t)
         # end the main loop if we had an unhandled exception
         try:

pixeltable/exec/expr_eval/globals.py

@@ -59,11 +59,10 @@ class Dispatcher(Protocol):
     """
     Row dispatcher used by Evaluators/Schedulers for post-processing after slot materialization and for task management.
 
-    Task management: all tasks need to be recorded in tasks and have done_cb registered with add_done_callback()
+    Task management: all tasks need to be registered via register_task()
     Exceptions: evaluators/schedulers need to check exc_event prior to starting long-running (non-interruptible)
         computations
     """
-    tasks: set[asyncio.Task]
     row_builder: exprs.RowBuilder
     exc_event: asyncio.Event
     schedulers: dict[str, Scheduler]  # key: resource pool id
@@ -76,8 +75,8 @@ class Dispatcher(Protocol):
         """Propagates exception in slot_with_exc to all dependent slots and dispatches the rest; does not block"""
         ...
 
-    def done_cb(self, f: asyncio.Task) -> None:
-        """Callback for task completion; does not block"""
+    def register_task(self, f: asyncio.Task) -> None:
+        """Register task with dispatcher for subsequent cleanup; does not block"""
         ...
 
 

pixeltable/exec/expr_eval/schedulers.py

@@ -62,8 +62,7 @@ class RateLimitsScheduler(Scheduler):
         self.queue = asyncio.PriorityQueue()
         self.dispatcher = dispatcher
         self.loop_task = asyncio.create_task(self._main_loop())
-        self.dispatcher.tasks.add(self.loop_task)
-        self.loop_task.add_done_callback(self.dispatcher.done_cb)
+        self.dispatcher.register_task(self.loop_task)
         self.pool_info = None  # initialized in _main_loop by the first request
         self.est_usage = {}
         self.num_in_flight = 0
@@ -79,6 +78,19 @@ class RateLimitsScheduler(Scheduler):
     def submit(self, item: FnCallArgs) -> None:
         self.queue.put_nowait(self.QueueItem(item, 0))
 
+    def _set_pool_info(self) -> None:
+        """Initialize pool_info with the RateLimitsInfo for the resource pool, if available"""
+        if self.pool_info is not None:
+            return
+        self.pool_info = env.Env.get().get_resource_pool_info(self.resource_pool, None)
+        if self.pool_info is None:
+            return
+        assert isinstance(self.pool_info, env.RateLimitsInfo)
+        assert hasattr(self.pool_info, 'get_request_resources')
+        sig = inspect.signature(self.pool_info.get_request_resources)
+        self.get_request_resources_param_names = [p.name for p in sig.parameters.values()]
+        self.est_usage = {r: 0 for r in self._resources}
+
     async def _main_loop(self) -> None:
         item: Optional[RateLimitsScheduler.QueueItem] = None
         while True:
@@ -95,15 +107,7 @@ class RateLimitsScheduler(Scheduler):
                 item = None
                 # if this was the first request, it created the pool_info
                 if self.pool_info is None:
-                    self.pool_info = env.Env.get().get_resource_pool_info(self.resource_pool, None)
-                    if self.pool_info is None:
-                        # we still don't have rate limits, wait for the next request
-                        continue
-                    assert isinstance(self.pool_info, env.RateLimitsInfo)
-                    assert hasattr(self.pool_info, 'get_request_resources')
-                    sig = inspect.signature(self.pool_info.get_request_resources)
-                    self.get_request_resources_param_names = [p.name for p in sig.parameters.values()]
-                    self.est_usage = {r: 0 for r in self._resources}
+                    self._set_pool_info()
                 continue
 
             # check rate limits
@@ -149,8 +153,7 @@ class RateLimitsScheduler(Scheduler):
             _logger.debug(f'creating task for {self.resource_pool}')
             self.num_in_flight += 1
             task = asyncio.create_task(self._exec(item.request, item.num_retries, is_task=True))
-            self.dispatcher.tasks.add(task)
-            task.add_done_callback(self.dispatcher.done_cb)
+            self.dispatcher.register_task(task)
             item = None
 
     @property
@@ -206,10 +209,15 @@ class RateLimitsScheduler(Scheduler):
 
             self.dispatcher.dispatch(request.rows)
         except Exception as exc:
+            _logger.debug(f'scheduler {self.resource_pool}: exception in slot {request.fn_call.slot_idx}: {exc}')
+            if  self.pool_info is None:
+                # our pool info should be available at this point
+                self._set_pool_info()
             if num_retries < self.MAX_RETRIES and self.pool_info is not None:
                 retry_delay = self.pool_info.get_retry_delay(exc)
                 if retry_delay is not None:
                     self.total_retried += 1
+                    _logger.debug(f'scheduler {self.resource_pool}: retrying in {retry_delay} seconds')
                     await asyncio.sleep(retry_delay)
                     self.queue.put_nowait(self.QueueItem(request, num_retries + 1))
                     return

pixeltable/exprs/row_builder.py

@@ -8,13 +8,13 @@ from uuid import UUID
 
 import numpy as np
 import sqlalchemy as sql
-
 import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
 import pixeltable.func as func
 import pixeltable.utils as utils
 from pixeltable.utils.media_store import MediaStore
 from .data_row import DataRow
+from pixeltable.env import Env
 from .expr import Expr
 from .expr_set import ExprSet
 
@@ -32,7 +32,7 @@ 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

pixeltable/functions/anthropic.py

@@ -137,6 +137,11 @@ async def messages(
         if not tool_choice['parallel_tool_calls']:
             tool_choice_['disable_parallel_tool_use'] = True
 
+    # make sure the pool info exists prior to making the request
+    resource_pool_id = f'rate-limits:anthropic:{model}'
+    rate_limits_info = env.Env.get().get_resource_pool_info(resource_pool_id, AnthropicRateLimitsInfo)
+    assert isinstance(rate_limits_info, env.RateLimitsInfo)
+
     # TODO: timeouts should be set system-wide and be user-configurable
     from anthropic.types import MessageParam
 
@@ -178,9 +183,6 @@ async def messages(
     if retry_after_str is not None:
         _logger.debug(f'retry-after: {retry_after_str}')
 
-    resource_pool_id = f'rate-limits:anthropic:{model}'
-    rate_limits_info = env.Env.get().get_resource_pool_info(resource_pool_id, AnthropicRateLimitsInfo)
-    assert isinstance(rate_limits_info, env.RateLimitsInfo)
     rate_limits_info.record(
         requests=(requests_limit, requests_remaining, requests_reset),
         input_tokens=(input_tokens_limit, input_tokens_remaining, input_tokens_reset),

pixeltable/functions/openai.py

@@ -113,7 +113,17 @@ class OpenAIRateLimitsInfo(env.RateLimitsInfo):
         super().__init__(get_request_resources)
         import openai
         self.retryable_errors = (
-            openai.RateLimitError, openai.APITimeoutError, openai.UnprocessableEntityError, openai.InternalServerError
+            # ConnectionError: we occasionally see this error when the AsyncConnectionPool is trying to close
+            # expired connections
+            # (AsyncConnectionPool._close_expired_connections() fails with ConnectionError when executing
+            # 'await connection.aclose()', which is potentially a bug in AsyncConnectionPool)
+            openai.APIConnectionError,
+
+            # the following errors are retryable according to OpenAI's API documentation
+            openai.RateLimitError,
+            openai.APITimeoutError,
+            openai.UnprocessableEntityError,
+            openai.InternalServerError,
         )
 
     def get_retry_delay(self, exc: Exception) -> Optional[float]:
@@ -400,6 +410,11 @@ async def chat_completions(
     if tool_choice is not None and not tool_choice['parallel_tool_calls']:
         extra_body = {'parallel_tool_calls': False}
 
+    # make sure the pool info exists prior to making the request
+    resource_pool = _resource_pool(model)
+    rate_limits_info = env.Env.get().get_resource_pool_info(
+        resource_pool, lambda: OpenAIRateLimitsInfo(_chat_completions_get_request_resources))
+
     # cast(Any, ...): avoid mypy errors
     result = await _async_openai_client().chat.completions.with_raw_response.create(
         messages=messages,
@@ -423,10 +438,7 @@ async def chat_completions(
         extra_body=extra_body,
     )
 
-    resource_pool = _resource_pool(model)
     requests_info, tokens_info = _get_header_info(result.headers)
-    rate_limits_info = env.Env.get().get_resource_pool_info(resource_pool, lambda: OpenAIRateLimitsInfo(
-        _chat_completions_get_request_resources))
     rate_limits_info.record(requests=requests_info, tokens=tokens_info)
 
     return json.loads(result.text)
@@ -523,13 +535,13 @@ async def embeddings(
         >>> tbl['embed'] = embeddings(tbl.text, model='text-embedding-3-small')
     """
     _logger.debug(f'embeddings: batch_size={len(input)}')
+    resource_pool = _resource_pool(model)
+    rate_limits_info = env.Env.get().get_resource_pool_info(
+        resource_pool, lambda: OpenAIRateLimitsInfo(_embeddings_get_request_resources))
     result = await _async_openai_client().embeddings.with_raw_response.create(
         input=input, model=model, dimensions=_opt(dimensions), user=_opt(user), encoding_format='float'
     )
-    resource_pool = _resource_pool(model)
     requests_info, tokens_info = _get_header_info(result.headers)
-    rate_limits_info = env.Env.get().get_resource_pool_info(
-        resource_pool, lambda: OpenAIRateLimitsInfo(_embeddings_get_request_resources))
     rate_limits_info.record(requests=requests_info, tokens=tokens_info)
     return [np.array(data['embedding'], dtype=np.float64) for data in json.loads(result.content)['data']]
 

pixeltable/globals.py

@@ -606,8 +606,7 @@ def create_dir(path_str: str, if_exists: Literal['error', 'ignore', 'replace', '
         dir = catalog.Dir(dir_record.id, parent._id, path.name)
         cat.paths[path] = dir
         session.commit()
-        _logger.info(f'Created directory `{path_str}`.')
-        print(f'Created directory `{path_str}`.')
+        Env.get().console_logger.info(f'Created directory `{path_str}`.')
         return dir
 
 def drop_dir(path_str: str, force: bool = False, if_not_exists: Literal['error', 'ignore'] = 'error') -> None:

pixeltable/io/hf_datasets.py

@@ -13,7 +13,7 @@ from pixeltable import exceptions as excs
 if typing.TYPE_CHECKING:
     import datasets  # type: ignore[import-untyped]
 
-_logger = logging.getLogger(__name__)
+_logger = logging.getLogger('pixeltable')
 
 # use 100MB as the batch size limit for loading a huggingface dataset into pixeltable.
 # The primary goal is to bound memory use, regardless of dataset size.

pixeltable/io/label_studio.py

@@ -230,7 +230,7 @@ class LabelStudioProject(Project):
                 self.project.create_predictions(predictions)
                 tasks_created += 1
 
-        print(f'Created {tasks_created} new task(s) in {self}.')
+        env.Env.get().console_logger.info(f'Created {tasks_created} new task(s) in {self}.')
 
         sync_status = SyncStatus(external_rows_created=tasks_created)
 
@@ -330,7 +330,7 @@ class LabelStudioProject(Project):
         if len(page) > 0:
             self.project.import_tasks(page)
 
-        print(f'Created {tasks_created} new task(s) and updated {tasks_updated} existing task(s) in {self}.')
+        env.Env.get().console_logger.info(f'Created {tasks_created} new task(s) and updated {tasks_updated} existing task(s) in {self}.')
 
         sync_status = SyncStatus(external_rows_created=tasks_created, external_rows_updated=tasks_updated)
 
@@ -363,7 +363,7 @@ class LabelStudioProject(Project):
 
         if len(tasks_to_delete) > 0:
             self.project.delete_tasks(tasks_to_delete)
-            print(f'Deleted {len(tasks_to_delete)} tasks(s) in {self} that are no longer present in Pixeltable.')
+            env.Env.get().console_logger.info(f'Deleted {len(tasks_to_delete)} tasks(s) in {self} that are no longer present in Pixeltable.')
 
         # Remove them from the `existing_tasks` dict so that future updates are applied correctly
         for rowid in deleted_rowids:
@@ -406,7 +406,7 @@ class LabelStudioProject(Project):
                 assert ancestor._base is not None
                 ancestor = ancestor._base
             update_status = ancestor.batch_update(updates)
-            print(f'Updated annotation(s) from {len(updates)} task(s) in {self}.')
+            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)
         else:
             return SyncStatus.empty()
@@ -529,7 +529,7 @@ class LabelStudioProject(Project):
         """
         title = self.project_title
         _label_studio_client().delete_project(self.project_id)
-        print(f'Deleted Label Studio project: {title}')
+        env.Env.get().console_logger.info(f'Deleted Label Studio project: {title}')
 
     def __eq__(self, other) -> bool:
         return isinstance(other, LabelStudioProject) and self.project_id == other.project_id

pixeltable/io/parquet.py

@@ -23,7 +23,7 @@ if typing.TYPE_CHECKING:
     import pyarrow as pa
     import pixeltable as pxt
 
-_logger = logging.getLogger(__name__)
+_logger = logging.getLogger('pixeltable')
 
 
 def _write_batch(value_batch: dict[str, deque], schema: pa.Schema, output_path: Path) -> None:

pixeltable/metadata/__init__.py

@@ -47,7 +47,8 @@ def upgrade_md(engine: sql.engine.Engine) -> None:
         while md_version < VERSION:
             if md_version not in converter_cbs:
                 raise RuntimeError(f'No metadata converter for version {md_version}')
-            print(f'Converting metadata from version {md_version} to {md_version + 1}')
+            from pixeltable.env import Env
+            Env.get().console_logger.info(f'Converting metadata from version {md_version} to {md_version + 1}')
             converter_cbs[md_version](engine)
             md_version += 1
         # update system info

pixeltable/type_system.py

@@ -793,12 +793,19 @@ class JsonType(ColumnType):
 
 
 class ArrayType(ColumnType):
-    def __init__(self, shape: tuple[Union[int, None], ...], dtype: ColumnType, nullable: bool = False):
+
+    shape: Optional[tuple[Optional[int], ...]]
+    pxt_dtype: Optional[ColumnType]
+    dtype: Optional[ColumnType.Type]
+
+    def __init__(self, shape: Optional[tuple[Optional[int], ...]] = None, dtype: Optional[ColumnType] = None, nullable: bool = False):
         super().__init__(self.Type.ARRAY, nullable=nullable)
+        assert shape is None or dtype is not None, (shape, dtype)  # cannot specify a shape without a dtype
+        assert dtype is None or dtype.is_int_type() or dtype.is_float_type() or dtype.is_bool_type() or dtype.is_string_type()
+
         self.shape = shape
-        assert dtype.is_int_type() or dtype.is_float_type() or dtype.is_bool_type() or dtype.is_string_type()
-        self.pxt_dtype = dtype
-        self.dtype = dtype._type
+        self.pxt_dtype = dtype  # we need this for copy() and __str__()
+        self.dtype = None if dtype is None else dtype._type
 
     def copy(self, nullable: bool) -> ColumnType:
         return ArrayType(self.shape, self.pxt_dtype, nullable=nullable)
@@ -812,28 +819,38 @@ class ArrayType(ColumnType):
     def supertype(self, other: ColumnType) -> Optional[ArrayType]:
         if not isinstance(other, ArrayType):
             return None
+        super_dtype = self.Type.supertype(self.dtype, other.dtype, self.common_supertypes)
+        if super_dtype is None:
+            # if the dtypes are incompatible, then the supertype is a fully general array
+            return ArrayType(nullable=(self.nullable or other.nullable))
+        super_shape: Optional[tuple[Optional[int], ...]]
         if len(self.shape) != len(other.shape):
-            return None
-        base_type = self.Type.supertype(self.dtype, other.dtype, self.common_supertypes)
-        if base_type is None:
-            return None
-        shape = [n1 if n1 == n2 else None for n1, n2 in zip(self.shape, other.shape)]
-        return ArrayType(tuple(shape), self.make_type(base_type), nullable=(self.nullable or other.nullable))
+            super_shape = None
+        else:
+            super_shape = tuple(n1 if n1 == n2 else None for n1, n2 in zip(self.shape, other.shape))
+        return ArrayType(super_shape, self.make_type(super_dtype), nullable=(self.nullable or other.nullable))
 
     def _as_dict(self) -> dict:
         result = super()._as_dict()
-        result.update(shape=list(self.shape), dtype=self.dtype.value)
+        shape_as_list = None if self.shape is None else list(self.shape)
+        dtype_value = None if self.dtype is None else self.dtype.value
+        result.update(shape=shape_as_list, dtype=dtype_value)
         return result
 
     def _to_base_str(self) -> str:
+        if self.shape is None and self.dtype is None:
+            return 'Array'
+        if self.shape is None:
+            return f'Array[{self.pxt_dtype}]'
+        assert self.dtype is not None
         return f'Array[{self.shape}, {self.pxt_dtype}]'
 
     @classmethod
     def _from_dict(cls, d: dict) -> ColumnType:
         assert 'shape' in d
         assert 'dtype' in d
-        shape = tuple(d['shape'])
-        dtype = cls.make_type(cls.Type(d['dtype']))
+        shape = None if d['shape'] is None else tuple(d['shape'])
+        dtype = None if d['dtype'] is None else cls.make_type(cls.Type(d['dtype']))
         return cls(shape, dtype, nullable=d['nullable'])
 
     @classmethod
@@ -855,18 +872,30 @@ class ArrayType(ColumnType):
     def is_valid_literal(self, val: np.ndarray) -> bool:
         if not isinstance(val, np.ndarray):
             return False
-        if len(val.shape) != len(self.shape):
+
+        # If a dtype is specified, check that there's a match
+        if self.dtype is not None and not np.issubdtype(val.dtype, self.numpy_dtype()):
             return False
-        # check that the shapes are compatible
-        for n1, n2 in zip(val.shape, self.shape):
-            if n1 is None:
-                return False
-            if n2 is None:
-                # wildcard
-                continue
-            if n1 != n2:
+
+        # If no dtype is specified, we still need to check that the dtype is one of the supported types
+        if self.dtype is None and not any(
+            np.issubdtype(val.dtype, ndtype) for ndtype in [np.int64, np.float32, np.bool_, np.str_]
+        ):
+            return False
+
+        # If a shape is specified, check that there's a match
+        if self.shape is not None:
+            if len(val.shape) != len(self.shape):
                 return False
-        return np.issubdtype(val.dtype, self.numpy_dtype())
+            # check that the shapes are compatible
+            for n1, n2 in zip(val.shape, self.shape):
+                assert n1 is not None  # `val` must have a concrete shape
+                if n2 is None:
+                    continue  # wildcard
+                if n1 != n2:
+                    return False
+
+        return True
 
     def _to_json_schema(self) -> dict[str, Any]:
         return {
@@ -878,9 +907,17 @@ class ArrayType(ColumnType):
         if not isinstance(val, np.ndarray):
             raise TypeError(f'Expected numpy.ndarray, got {val.__class__.__name__}')
         if not self.is_valid_literal(val):
-            raise TypeError((
-                f'Expected ndarray({self.shape}, dtype={self.numpy_dtype()}), '
-                f'got ndarray({val.shape}, dtype={val.dtype})'))
+            if self.shape is not None:
+                raise TypeError(
+                    f'Expected numpy.ndarray({self.shape}, dtype={self.numpy_dtype()}), '
+                    f'got numpy.ndarray({val.shape}, dtype={val.dtype})'
+                )
+            elif self.dtype is not None:
+                raise TypeError(
+                    f'Expected numpy.ndarray of dtype {self.numpy_dtype()}, got numpy.ndarray of dtype {val.dtype}'
+                )
+            else:
+                raise TypeError(f'Unsupported dtype for numpy.ndarray: {val.dtype}')
 
     def _create_literal(self, val: Any) -> Any:
         if isinstance(val, (list, tuple)):
@@ -892,7 +929,9 @@ class ArrayType(ColumnType):
     def to_sa_type(self) -> sql.types.TypeEngine:
         return sql.LargeBinary()
 
-    def numpy_dtype(self) -> np.dtype:
+    def numpy_dtype(self) -> Optional[np.dtype]:
+        if self.dtype is None:
+            return None
         if self.dtype == self.Type.INT:
             return np.dtype(np.int64)
         if self.dtype == self.Type.FLOAT:
@@ -901,7 +940,7 @@ class ArrayType(ColumnType):
             return np.dtype(np.bool_)
         if self.dtype == self.Type.STRING:
             return np.dtype(np.str_)
-        assert False
+        assert False, self.dtype
 
 
 class ImageType(ColumnType):
@@ -1174,6 +1213,8 @@ class Array(np.ndarray, _PxtType):
         params = item if isinstance(item, tuple) else (item,)
         shape: Optional[tuple] = None
         dtype: Optional[ColumnType] = None
+        if not any(isinstance(param, (type, _AnnotatedAlias)) for param in params):
+            raise TypeError('Array type parameter must include a dtype.')
         for param in params:
             if isinstance(param, tuple):
                 if not all(n is None or (isinstance(n, int) and n >= 1) for n in param):
@@ -1181,21 +1222,17 @@ class Array(np.ndarray, _PxtType):
                 if shape is not None:
                     raise TypeError(f'Duplicate Array type parameter: {param}')
                 shape = param
-            elif isinstance(param, type) or isinstance(param, _AnnotatedAlias):
+            elif isinstance(param, (type, _AnnotatedAlias)):
                 if dtype is not None:
                     raise TypeError(f'Duplicate Array type parameter: {param}')
                 dtype = ColumnType.normalize_type(param, allow_builtin_types=False)
             else:
                 raise TypeError(f'Invalid Array type parameter: {param}')
-        if shape is None:
-            raise TypeError('Array type is missing parameter: shape')
-        if dtype is None:
-            raise TypeError('Array type is missing parameter: dtype')
         return typing.Annotated[np.ndarray, ArrayType(shape=shape, dtype=dtype, nullable=False)]
 
     @classmethod
     def as_col_type(cls, nullable: bool) -> ColumnType:
-        raise TypeError('Array type cannot be used without specifying shape and dtype')
+        return ArrayType(nullable=nullable)
 
 
 class Image(PIL.Image.Image, _PxtType):

pixeltable/utils/arrow.py

@@ -1,4 +1,3 @@
-import logging
 from typing import Any, Iterator, Optional, Union
 
 import numpy as np
@@ -6,11 +5,7 @@ import pyarrow as pa
 import datetime
 
 import pixeltable.type_system as ts
-from pixeltable.env import Env
 
-_tz_def = Env().get().default_time_zone
-
-_logger = logging.getLogger(__name__)
 
 _pa_to_pt: dict[pa.DataType, ts.ColumnType] = {
     pa.string(): ts.StringType(nullable=True),

pixeltable/utils/console_output.py

@@ -0,0 +1,41 @@
+import logging
+
+def map_level(verbosity: int) -> int:
+    """
+        Map verbosity level to logging level.
+        0 - minimum logging - warn and above
+        1 - default logging - info and above
+        2 - more logging - debug and above
+    Args:
+
+    Returns:
+        Logging level as integer
+    """
+    if verbosity == 0:
+        return logging.WARN
+    if verbosity == 1:
+        return logging.INFO
+    if verbosity == 2:
+        return logging.DEBUG
+    return logging.INFO
+
+class ConsoleOutputHandler(logging.StreamHandler):
+    def __init__(self, stream):
+        super().__init__(stream)
+
+    def emit(self, record):
+        if record.msg.endswith('\n'):
+            self.stream.write(record.msg)
+        else:
+            self.stream.write(record.msg + '\n')
+
+class ConsoleMessageFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        if hasattr(record, 'user_visible') and record.user_visible:
+            return True
+        return False
+
+class ConsoleLogger(logging.LoggerAdapter):
+    def __init__(self, logger:logging.Logger):
+        super().__init__(logger, extra={'user_visible' : True})
+

pixeltable/utils/filecache.py

@@ -239,4 +239,4 @@ class FileCache:
 
     def debug_print(self) -> None:
         for entry in self.cache.values():
-            print(f'CacheEntry: tbl_id={entry.tbl_id}, col_id={entry.col_id}, size={entry.size}')
+            _logger.debug(f'CacheEntry: tbl_id={entry.tbl_id}, col_id={entry.col_id}, size={entry.size}')

{pixeltable-0.3.1.dist-info → pixeltable-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixeltable
-Version: 0.3.1
+Version: 0.3.2
 Summary: AI Data Infrastructure: Declarative, Multimodal, and Incremental
 Home-page: https://pixeltable.com/
 License: Apache-2.0
@@ -27,6 +27,7 @@ Requires-Dist: av (>=10.0.0)
 Requires-Dist: beautifulsoup4 (>=4.0.0,<5.0.0)
 Requires-Dist: cloudpickle (>=2.2.1,<3.0.0)
 Requires-Dist: ftfy (>=6.2.0,<7.0.0)
+Requires-Dist: httpcore (>=1.0.3)
 Requires-Dist: httpx (>=0.27)
 Requires-Dist: jinja2 (>=3.1.3,<4.0.0)
 Requires-Dist: jmespath (>=1.0.1,<2.0.0)

{pixeltable-0.3.1.dist-info → pixeltable-0.3.2.dist-info}/RECORD

@@ -1,21 +1,21 @@
 pixeltable/__init__.py,sha256=c-Z21TqJUbzGQKsO4CS4lVFwWlZnVhpIR94cL6RNmDo,1411
-pixeltable/__version__.py,sha256=zVI6ltlHGwKITzBi4TSc2jGBnWUb4mnqjF_PYoGqTuw,112
+pixeltable/__version__.py,sha256=Ftdd_iaB0tNUSNnDBsJFrHIR6gBXSgcgIbcjGk_8ds4,112
 pixeltable/catalog/__init__.py,sha256=u8Ods4ncTY7DI5w0jyHVC0QDVDLHAy8Rqia3qsM5OH8,517
 pixeltable/catalog/catalog.py,sha256=tyDyI5wQw7vV6_FChrp9qgGCRClcjiSdW3eygYT0p9s,7849
 pixeltable/catalog/column.py,sha256=ezeKoGl6aBTzSZBihDA6vdETcvyCguAD4OsmrxWs73A,9595
 pixeltable/catalog/dir.py,sha256=-dV0-gn5GfqRmVIJbuUBOXqPuNLDm219cud_kBTNzuk,1203
 pixeltable/catalog/globals.py,sha256=VgcmwtKYYDQtvtHShVde52n4FzGBtAIFYxoS-WD7OBw,3242
-pixeltable/catalog/insertable_table.py,sha256=hOsdYhkhtRcDOrRkweIGFUfjweWF3fLUErkUTlGYoSU,7172
+pixeltable/catalog/insertable_table.py,sha256=VgZ6C0l_NI1orCqeZF_lOC5RZnie36_bQSx3y6SRtW4,7227
 pixeltable/catalog/named_function.py,sha256=cWf9WxAagSY9uqE7mM0IwWSsDOvQUkJlcHlGqgVciJg,1225
 pixeltable/catalog/path.py,sha256=QgccEi_QOfaKt8YsR2zLtd_z7z7QQkU_1kprJFi2SPQ,1677
 pixeltable/catalog/path_dict.py,sha256=V7YQM0QhUWr4FbgUiDUIweGbmMJr687QCm2p614Xrs0,6473
 pixeltable/catalog/schema_object.py,sha256=NUE6Fx6Km0UUJ6WcE9mOgL2UQCLBMQjINQLp_mljzKA,2382
-pixeltable/catalog/table.py,sha256=Gqb1tT9l8oB5eeeFuj45fy0_1fdCqizmRWvyjFH-U9Y,62404
-pixeltable/catalog/table_version.py,sha256=wuvFYbr6WrwhDWC202tUIgF8T61P69WOtduBUDq5EsI,58601
+pixeltable/catalog/table.py,sha256=DbCX6H1xZL3raytoMrii0ceZiwD_X4FhkUw-1Djuaf0,62460
+pixeltable/catalog/table_version.py,sha256=Ue_iByiT9JdPl_QwXnwq93Nd71Z_w0BHlRjugOLSI60,58625
 pixeltable/catalog/table_version_path.py,sha256=CczGbcz5ESq663arreri_p4chMZHozgG6k3y-ajkJN4,5787
-pixeltable/catalog/view.py,sha256=qUjou_z_YwKTqTIRUY4Q3JxWUEiKvl2pDi7DNOnw4fw,10709
+pixeltable/catalog/view.py,sha256=hzTzS2jtrE8fyI5IeCKlmUQl_w-xE0C0fslmdBOBBZU,10733
 pixeltable/dataframe.py,sha256=KrAB-l_qdArlT3pnlSH69k0mqs0AK2wFhQ4V_7Wcjyw,48639
-pixeltable/env.py,sha256=VMS4Kj-RVEeFgmLzuQ2sFRQFtG4dLRbBZ9VzVzvO7hk,34993
+pixeltable/env.py,sha256=J0e2dN42O6u1N67sg4OIyBKcElbSueQWdRFBC_8LFRY,35776
 pixeltable/exceptions.py,sha256=NuFY2WtkQpLfLHT_J70kOw9Tr0kEDkkgo-u7As4Gaq4,410
 pixeltable/exec/__init__.py,sha256=E_ub_ftAJVebEmKHZs47egeJqMfAbbx4SS1l7jR-Nd0,489
 pixeltable/exec/aggregation_node.py,sha256=iE3UHHW0IbkHsY7kYJAg6m1UKyKUu2_tJuzgL_rQUVE,4038
@@ -25,11 +25,11 @@ pixeltable/exec/data_row_batch.py,sha256=5WhdS3ahtCP3wROw4NPJjtvaQUAWKwyN1rHKbfd
 pixeltable/exec/exec_context.py,sha256=-FbfYLcGOL7mviru5dE1A7x4YxLbdKoXBHN3OSbqbcg,1084
 pixeltable/exec/exec_node.py,sha256=qDp63PFlMQUVwav0JIjuP0r0BH9EwW7s_NgqFE_Zn20,3735
 pixeltable/exec/expr_eval/__init__.py,sha256=t0o2T7MxfH09TI7KlzxEjPUySejn2vkK06LC8t4FjsQ,41
-pixeltable/exec/expr_eval/evaluators.py,sha256=HtcrWivzoGWzpEAYRgyKvFRGVKq4rMO-QpK7fZq4fE8,11349
-pixeltable/exec/expr_eval/expr_eval_node.py,sha256=37c5eevFMAvvYmSbqzcO4Wjxouy3R5a5vSnLLjifeic,19786
-pixeltable/exec/expr_eval/globals.py,sha256=UAlOAOJNHw4sJ3CXXk2Gh0qhOxEm2cGtNlkvvvebx1g,3895
+pixeltable/exec/expr_eval/evaluators.py,sha256=Zb_TW_VLiicVSVZjbmU4eSDzuzO37J6VIvmLZo5fjPY,11061
+pixeltable/exec/expr_eval/expr_eval_node.py,sha256=XSddV59hHkhUGKeRYgbviY5GcB0p61Y9qzIvBcdwpXM,19911
+pixeltable/exec/expr_eval/globals.py,sha256=q3WBI5HRBxgg2msrqcZhuh1oZ_KkI4i1MzICjePGIwM,3856
 pixeltable/exec/expr_eval/row_buffer.py,sha256=Wjc6ZklxSW4-sCAMEGIzESII1uuC6Urzmq6JeUO3ALA,2737
-pixeltable/exec/expr_eval/schedulers.py,sha256=MqO0r5TaQhywozpRPL87S8YwZmKEc8sdEerX2LHDaCY,10962
+pixeltable/exec/expr_eval/schedulers.py,sha256=_Tq_JglwcAI_rvhDgWm0tVH2eBPCOsHctoZaK-jiFlo,11257
 pixeltable/exec/in_memory_data_node.py,sha256=CwuwkA2xdyApMfPfSQamlLdbb-IQn7R7zeBBJiI8I7g,3479
 pixeltable/exec/row_update_node.py,sha256=MEvI3Yzw6YcUDTufSNVNVtyG83Hj6zHzEI9fvKtAgRQ,2859
 pixeltable/exec/sql_node.py,sha256=vMHNHzhrlk2Ej58vMZzk7hYAeHFHlBtkLwYZsOVn3CQ,19573
@@ -54,7 +54,7 @@ pixeltable/exprs/json_path.py,sha256=UTf3VUcyEmEBJs6yU4kONGcZ8fy1o6mIe9MlntnUd6M
 pixeltable/exprs/literal.py,sha256=Nhh-fXYMqGL4Tfm2YiFUd4ALMjzG7nJ2H4jHZe9XS1Y,4394
 pixeltable/exprs/method_ref.py,sha256=3O_uFMP6wWGiwJWri8on-47EVl-QD3AiAc7hXJMADxs,2615
 pixeltable/exprs/object_ref.py,sha256=GVg6uxZnKwFVTC0kouJq-wMFP-gUPb_ld_syHrsGMdE,1283
-pixeltable/exprs/row_builder.py,sha256=hpvmQyBie5pRtOkMKQu0xCxB18EK8iw_aUbtxYlzWcs,19862
+pixeltable/exprs/row_builder.py,sha256=hR-lpd9BDsPesJQ_02Mh0NB3Kou8ELIUnchGI1e--vg,19916
 pixeltable/exprs/rowid_ref.py,sha256=iNBZ0wIhBAGkGCrNP9UQ2FeK8OajVX-eI4dtDA_bfHU,4401
 pixeltable/exprs/similarity_expr.py,sha256=GhiopGxN3wu5MOEqfWN4PNbqgSszg2VIC1_bqVPpm3Q,4333
 pixeltable/exprs/sql_element_cache.py,sha256=8i9ZslKWKTd1lUN7JvwRtQ-PFD1QMi5LBYdwcGA2-p0,1364
@@ -76,7 +76,7 @@ pixeltable/func/signature.py,sha256=wWf07OawOwDmqZOjUPgHJHAhAQ-fd61PGBx82aWLBgA,
 pixeltable/func/tools.py,sha256=7OAHVb9KbmcPtfMWsbKAoRu3kx-_japSTE-hgRQJefM,5988
 pixeltable/func/udf.py,sha256=p7imgwk7S03q3lHZxqAZUKr63XSeSsrD8kWTbwOLQWo,8882
 pixeltable/functions/__init__.py,sha256=C7Okwst3JdhzwIFWXhyJ3F0EHKGKor2R8dRMvQ3y6Us,428
-pixeltable/functions/anthropic.py,sha256=rSgMWmR2YVRfrdbbAPY5OvKkbyV1DHBJIHFGdDwVnP4,8800
+pixeltable/functions/anthropic.py,sha256=tAMImdf-L6ZBnHGbX98uM5VuPkiwxzDAjdMZsY26lPI,8866
 pixeltable/functions/audio.py,sha256=7213nTnqKJ6vM9kalaoJ283OwX5SGEJN10vDhaRNZ6E,644
 pixeltable/functions/fireworks.py,sha256=qwFC_eIaDs-glxyJ_IVXaNGkpgPzeRsQ_SdpzueBxq0,2605
 pixeltable/functions/gemini.py,sha256=0aqsDpxI0AgeWu6zXQxtFbp3nhhuwXqzulZyot6UKdg,2613
@@ -88,7 +88,7 @@ pixeltable/functions/llama_cpp.py,sha256=1awALuAXVpQH64l7vQlM8gvxLDix4c1-6DV3nG5
 pixeltable/functions/math.py,sha256=WPoH9zD9_GdwvBs-FSC3Sqb70gOPNouhPcBZABsuLwI,1541
 pixeltable/functions/mistralai.py,sha256=GpxtT-a8ltx1kQC8XTJRflxkh-17VhzzFTkxqIUsba8,5494
 pixeltable/functions/ollama.py,sha256=z-g0cCJ-WMf6RI3SXIVVbbOlrWNR8nxGTyzET1rratU,4320
-pixeltable/functions/openai.py,sha256=Sh2zqwW72CYiMoyEELLpY1fwTmxuLGnAQbtEkmTac4c,24030
+pixeltable/functions/openai.py,sha256=kXIhIMB2wNrrUO81H7ycy30avhgRApKepnkhE3C4uxA,24606
 pixeltable/functions/replicate.py,sha256=j8ZedScOMInmHWmriQSUOviw6tp8gQr-W6n21PNNL2g,2188
 pixeltable/functions/string.py,sha256=VqzhVildxTt_XblW89Kl5Zd6MVOU71eaX2LTMY5jkUg,20366
 pixeltable/functions/timestamp.py,sha256=KOm5eVF51PqOCTqwq8cKCAEJNWMgu2xN_yTtGf7yixU,9095
@@ -97,7 +97,7 @@ pixeltable/functions/util.py,sha256=GgKTzCjvzUQNjWtSObTkfxkvJ9GVUOzKimY45WhE25M,
 pixeltable/functions/video.py,sha256=12jnOdU0G-Hk42rJx-S5QC77-bDkUflkxfkjej8n5pM,6702
 pixeltable/functions/vision.py,sha256=MEgkNp-4tUUeQS05VEJBrMgQFM48aNsNlksfAl9rH7w,15494
 pixeltable/functions/whisper.py,sha256=f2wqRd0n9jSBqRZN3W93UaetiAHtbsK0j9jXR2j2kkQ,2913
-pixeltable/globals.py,sha256=9UfD7FOn71dbzPZjV-LxzhxXBhwPcpLt46J0_RVPynk,33899
+pixeltable/globals.py,sha256=7gYQdZs685OwJm1W49g4LlRdrhzhKTSU_DpJr_MRaXg,33866
 pixeltable/index/__init__.py,sha256=XBwetNQQwnz0fiKwonOKhyy_U32l_cjt77kNvEIdjWs,102
 pixeltable/index/base.py,sha256=zo0YvJI3oXiK6hZJztB36ZftKKhLfO75Zq3t-PeQA6M,1556
 pixeltable/index/btree.py,sha256=JFerLyyLoBaD0FSF_jJ6iJFBVa-z_et--KdNR02xjRg,2264
@@ -106,17 +106,17 @@ pixeltable/io/__init__.py,sha256=j3qDyGO1ejLce-UzIncK3eRqyOCLoOlDqClecMBSJGc,563
 pixeltable/io/external_store.py,sha256=H1jt7MDn464QRgBvU-PmcPcFlo3EZBCG7fKWEZXOfyc,16676
 pixeltable/io/fiftyone.py,sha256=hH-FahW6BuMQY8lGa2atnNnJto_pK8kWrP_y_EMsq6g,6965
 pixeltable/io/globals.py,sha256=9S9wnlIAuhZq7eC_GklTM_UX0UATK9fEagk8-SRCeXQ,17794
-pixeltable/io/hf_datasets.py,sha256=o5fqm2CJAjhFd3z-NYGxN0jM1tfrp4szuUX0TGnyNRY,8316
-pixeltable/io/label_studio.py,sha256=Yx2ES_Y32eZA8JvJ1k17tSU0GiRTcU0_R116c7RCbZo,31091
+pixeltable/io/hf_datasets.py,sha256=1_NRn1748OT69UlBpnb_AWkEitEHrYiRO4vbJ7XwdQw,8320
+pixeltable/io/label_studio.py,sha256=RtupR5mtql0NUHnoocCdfOhYfO6ienS9_lhEztx6ECU,31231
 pixeltable/io/pandas.py,sha256=7eHg7wnAfRA9eBk4iC0iSSVTKOM59Ne4pXokKWdt3dY,9793
-pixeltable/io/parquet.py,sha256=bvwTRIKhS99M3bAcAP63jnh5-R6Qww1SrYBGWjZvN1g,8800
+pixeltable/io/parquet.py,sha256=3n-4XgCVS8-V3fph_meyDOrvz-f_a-7WbvKMTEfYNUY,8804
 pixeltable/iterators/__init__.py,sha256=qA9cJTwPO3gk-7y8mUXw2anWSbnUAVGwzl52SxiUjNU,398
 pixeltable/iterators/base.py,sha256=ZC0ZvXL4iw6AmT8cu-Mdx-T2UG9nmJYV1C6LK4efAfw,1669
 pixeltable/iterators/document.py,sha256=e5EMUAW4f5SqfC5mRN7Oo2E3gw_vcMSzq2707NVLByU,20254
 pixeltable/iterators/image.py,sha256=7eJupbyLEl_q4bemEozL8WgTgkxjl-DYnSXyHTQ7Rck,3628
 pixeltable/iterators/string.py,sha256=NG_fWc_GAITDfzl6MvrDOMrSoMcZdMZf6hPQztCSatE,1305
 pixeltable/iterators/video.py,sha256=anedQpSOnjYhHLa8UiEx-6ROagb14rpXh9am8oTriUg,9382
-pixeltable/metadata/__init__.py,sha256=S99VPq09bEYI7nF6HQ55Fyp9bJ0TUhk9L9gsOQi5XT4,2209
+pixeltable/metadata/__init__.py,sha256=7Ep8e48O7sLiNxarTF_kDunRn7maaj7tTBYUPC76VnI,2276
 pixeltable/metadata/converters/convert_10.py,sha256=J1_r7LNNAWTdb042AwqFpJ4sEB-i4qhUdk5iOjcZk34,719
 pixeltable/metadata/converters/convert_12.py,sha256=Ci-qyZW1gqci-8wnjeOB5afdq7KTuN-hVSV9OqSPx8g,162
 pixeltable/metadata/converters/convert_13.py,sha256=yFR6lD3pOrZ46ZQBFKYvxiIYa7rRxh46Bsq7yiCBNak,1356
@@ -138,14 +138,15 @@ pixeltable/metadata/schema.py,sha256=H9t51cbhXOhNu9Xog2VTjZlkTCx4cjQAlwOXi3HSd2E
 pixeltable/plan.py,sha256=DgzP5kDmBooaUioZ0KBlSUcx_jpqy456CnbDRVzFBJM,41501
 pixeltable/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pixeltable/store.py,sha256=-A7oRGHDpvhUZzx68QSde0t2NvUjeM1rOw9KdwukQ9s,22497
-pixeltable/type_system.py,sha256=nR004iZjvA5BIBSXsBXaHbpUPbddtiUCUzB0To1Bakw,48115
+pixeltable/type_system.py,sha256=t7IOdQj90vBriJiexuSkmx-RSbzZYoijmX9FqYC778s,50019
 pixeltable/utils/__init__.py,sha256=UYlrf6TIWJT0g-Hac0b34-dEk478B5Qx8dGco34YlIk,439
-pixeltable/utils/arrow.py,sha256=iuZhueel1FT_3UDAMITFXxodLB7w8TrUpsMpie3IDXg,3991
+pixeltable/utils/arrow.py,sha256=Fb6dLTC7jiTMH6l2UoVlrcnoIbe-mJH2zmpBFIjajKo,3866
 pixeltable/utils/coco.py,sha256=WCUyoj0dTyJFbPB7frEQUvY92SlEPxQ068r-3QAwROE,7285
 pixeltable/utils/code.py,sha256=AOw1u2r8_DQXpX-lxJhyHWARGrCRDXOJHFVgKOi54Uc,1231
+pixeltable/utils/console_output.py,sha256=SB4ibt43-HqIUkv3SR93xyEcu8WhjwPSpMlAs6xyejc,1145
 pixeltable/utils/description_helper.py,sha256=P-8EE2pRFP8s3coe73frgV68yt4Dp3saErCUehMxKUw,3759
 pixeltable/utils/documents.py,sha256=pytTYY167wYc1rGaDd9HPK6GOrz1ML78eAD3hIHrG68,2930
-pixeltable/utils/filecache.py,sha256=6HKQdItqSSTQvj2HkSJulyhfBedi4PgC7umwxXGOVG8,10637
+pixeltable/utils/filecache.py,sha256=kgRf5tlNZN642wrYIf5qpUMSA8ULHmnoIrvhkR0MwYU,10645
 pixeltable/utils/formatter.py,sha256=5E_gDg11ClFI-5SthwkiqyE3hAok3JHDj4OSK9cJklM,9257
 pixeltable/utils/http_server.py,sha256=xYPTvmYrkUpKfOaLDq08D-eHswkcgDf4qAt76ZFH6lM,2411
 pixeltable/utils/media_store.py,sha256=YwvTjbVqC_aLbDvLuqnDSL8xeIVMZcmzp0ANuM6uMbw,3092
@@ -153,8 +154,8 @@ pixeltable/utils/pytorch.py,sha256=6RvOCjy_QV4gc-aht-3d0zoASkuv-warfpl87vgmuKw,3
 pixeltable/utils/s3.py,sha256=huA5hxDGkPIu18zWet76o0FsO7Vbtp-iPmnOzCe-MvA,586
 pixeltable/utils/sql.py,sha256=j_tj0h4ffm-DhUIJbvGphxrVyBKlNTwDKqWGhRQ5_PY,795
 pixeltable/utils/transactional_directory.py,sha256=UGzCrGtLR3hEEf8sYGuWBzLVFAEQml3vdIavigWeTBM,1349
-pixeltable-0.3.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pixeltable-0.3.1.dist-info/METADATA,sha256=tRC6nn3plpwtLqC5TZsNDfDRB9SCj2NyNJIvzK6kWMA,19370
-pixeltable-0.3.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pixeltable-0.3.1.dist-info/entry_points.txt,sha256=ToOd-pRgG7AitEBgYoBCRRB4-KVDQ0pj_9T4a1LgwA4,97
-pixeltable-0.3.1.dist-info/RECORD,,
+pixeltable-0.3.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pixeltable-0.3.2.dist-info/METADATA,sha256=-8DaK2FpbjMasYQkI49akVlIuoPnhMWA0lKLQ_5Ww-o,19404
+pixeltable-0.3.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+pixeltable-0.3.2.dist-info/entry_points.txt,sha256=ToOd-pRgG7AitEBgYoBCRRB4-KVDQ0pj_9T4a1LgwA4,97
+pixeltable-0.3.2.dist-info/RECORD,,