pixeltable 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

pixeltable/utils/parquet.py

@@ -0,0 +1,126 @@
+import json
+import PIL.Image
+import io
+import pyarrow.parquet as pq
+import pyarrow as pa
+import numpy as np
+from pathlib import Path
+from collections import deque
+
+from typing import List, Tuple, Any, Dict
+from pixeltable.utils.transactional_directory import transactional_directory
+
+def _write_batch(value_batch : Dict[str, deque], schema : pa.Schema, output_path : Path) -> None:
+    pydict = {}
+    for field in schema:
+        if isinstance(field.type, pa.FixedShapeTensorType):
+            stacked_arr = np.stack(value_batch[field.name])
+            pydict[field.name] = pa.FixedShapeTensorArray.from_numpy_ndarray(stacked_arr)
+        else:
+            pydict[field.name] = value_batch[field.name]
+
+    tab = pa.Table.from_pydict(pydict, schema=schema)
+    pq.write_table(tab, output_path)
+
+def save_parquet(df: 'pixeltable.DataFrame', dest_path: Path, partition_size_bytes: int = 100_000_000) -> None:
+    """
+        Internal method to stream dataframe data to parquet format.
+        Does not materialize the dataset to memory.
+
+        It preserves pixeltable type metadata in a json file, which would otherwise 
+        not be available in the parquet format.
+
+        Images are stored inline in a compressed format in their parquet file.
+    
+        Args:
+            df : dataframe to save.
+            dest_path : path to directory to save the parquet files to.
+            partition_size_bytes : maximum target size for each chunk. Default 100_000_000 bytes.
+    """
+    column_names = df.get_column_names()
+    column_types = df.get_column_types()
+
+    type_dict = {k: v.as_dict() for k, v in zip(column_names, column_types)}
+
+    arrow_schema = pa.schema([pa.field(name, column_types[i].to_arrow_type()) for i, name in enumerate(column_names)])
+    # store the changes atomically
+    with transactional_directory(dest_path) as temp_path:
+        # dump metadata json file so we can inspect what was the source of the parquet file later on.
+        json.dump(df._as_dict(), (temp_path / '.pixeltable.json').open('w')) # pylint: disable=protected-access
+        json.dump(type_dict, (temp_path / '.pixeltable.column_types.json').open('w')) # keep type metadata
+
+        batch_num = 0
+        current_value_batch : Dict[str, deque] = {k:deque() for k in column_names}
+        current_byte_estimate = 0
+
+        for data_row in df._exec(): # pylint: disable=protected-access
+            for (col_name, col_type, e) in zip(column_names, column_types, df._select_list_exprs): # pylint: disable=protected-access
+                val = data_row[e.slot_idx]
+                if val is None:
+                    current_value_batch[col_name].append(val)
+                    continue
+
+                assert val is not None
+                if col_type.is_image_type():
+                    # images get inlined into the parquet file
+                    if data_row.file_paths is not None and data_row.file_paths[e.slot_idx] is not None:
+                        # if there is a file, read directly to preserve information
+                        val = open(data_row.file_paths[e.slot_idx], 'rb').read()
+                    elif isinstance(val, PIL.Image.Image): 
+                        # if no file available, eg. bc it is computed, convert to png
+                        buf = io.BytesIO()
+                        val.save(buf, format='PNG')
+                        val = buf.getvalue()
+                    else:
+                        assert False, f'unknown image type {type(val)}'
+                    length = len(val)
+                elif col_type.is_string_type():
+                    length = len(val)
+                elif col_type.is_video_type():
+                    if data_row.file_paths is not None and data_row.file_paths[e.slot_idx] is not None:
+                        val = data_row.file_paths[e.slot_idx]
+                    else:
+                        assert False, f'unknown video type {type(val)}'
+                    length = len(val)
+                elif col_type.is_json_type():
+                    val = json.dumps(val)
+                    length = len(val)
+                elif col_type.is_array_type():
+                    length = val.nbytes
+                elif col_type.is_int_type():
+                    length = 8
+                elif col_type.is_float_type():
+                    length = 8
+                elif col_type.is_bool_type():
+                    length = 1
+                elif col_type.is_timestamp_type():
+                    length = 8
+                else:
+                    assert False, f'unknown type {col_type} for {col_name}'
+
+                current_value_batch[col_name].append(val)
+                current_byte_estimate += length
+            if current_byte_estimate > partition_size_bytes:
+                assert batch_num < 100_000, 'wrote too many parquet files, unclear ordering'
+                _write_batch(current_value_batch, arrow_schema,  temp_path / f'part-{batch_num:05d}.parquet')
+                batch_num += 1
+                current_value_batch = {k:deque() for k in column_names}
+                current_byte_estimate = 0
+
+        _write_batch(current_value_batch, arrow_schema, temp_path / f'part-{batch_num:05d}.parquet')
+
+def get_part_metadata(path : Path) -> List[Tuple[str, int]]:
+    """
+        Args:
+            path: path to directory containing parquet files.
+        Returns:
+            A list of (file_name, num_rows) tuples for the parquet files in file name order.
+    """
+    parts = sorted([f for f in path.iterdir() if f.suffix == '.parquet'])
+    rows_per_file = {}
+
+    for part in parts:
+        parquet_file = pq.ParquetFile(str(part))
+        rows_per_file[part] = parquet_file.metadata.num_rows
+
+    return [(file, num_rows) for file, num_rows in rows_per_file.items()]

pixeltable/utils/pytorch.py

@@ -0,0 +1,172 @@
+import io
+import pyarrow as pa
+import pyarrow.parquet as pq
+import torch
+import torch.utils.data
+import math
+from pathlib import Path
+import PIL.Image
+import json
+from typing import Dict, Tuple, Generator, Any
+import datetime
+
+from pixeltable.type_system import ColumnType
+from pixeltable.utils.parquet import get_part_metadata
+import numpy as np
+
+def _cumsum(lst):
+    acc = [0]
+    for x in lst:
+        acc.append(acc[-1] + x)
+    return acc
+
+class PixeltablePytorchDataset(torch.utils.data.IterableDataset):
+    """
+    PyTorch dataset interface for pixeltable data.
+    NB. This class must inherit from torch.utils.data.IterableDataset for it
+    to work with torch.utils.data.DataLoader.
+    """
+    def __init__(
+        self,
+        path: Path,
+        image_format: str,
+    ):
+        """
+        Args:
+            path: path to directory containing parquet files
+            image_format: 'np' or 'pt'. 'np' is RGB uint8 array,
+                        'pt' is result of torchvision.transforms.ToTensor()
+        """
+        super().__init__()
+
+        self.path = path
+        self.image_format = image_format
+        assert image_format in ["np", "pt"]
+        column_type_path = path / '.pixeltable.column_types.json'
+        assert column_type_path.exists(), f"missing {column_type_path}"
+        with column_type_path.open() as f:
+            column_types = json.load(f)
+        self.column_types = {k: ColumnType.from_dict(v) for k, v in column_types.items()}
+        self.part_metadata = get_part_metadata(self.path)
+        self._totals = _cumsum([x[1] for x in self.part_metadata])
+
+    def _get_start_position(self, row_start: int) -> Tuple[int, int]:
+        """
+        Returns the starting parquet file and row within that file for a given 'global' row number.
+        based on the individual sizes of each part
+        """
+        assert row_start >= self._totals[0]
+        assert row_start < self._totals[-1]
+
+        prev_acc = 0
+        for i, acc in enumerate(self._totals[1:], start=1):
+            if acc > row_start:
+                return (i - 1, row_start - prev_acc)
+            prev_acc = acc
+
+        assert False, "unreachable"
+
+    def _unmarshall(self, k: str, v: Any) -> Any:
+        if self.column_types[k].is_image_type():
+            assert isinstance(v, bytes)
+            im = PIL.Image.open(io.BytesIO(v))
+            arr = np.array(im) # will copy data to guarantee "WRITEABLE" flag assertion below.
+            assert arr.flags["WRITEABLE"]
+
+            if self.image_format == "np":
+                return arr
+
+            assert self.image_format == "pt"
+            import torchvision  # pylint: disable = import-outside-toplevel
+
+            # use arr instead of im in ToTensor() to guarantee array input
+            # to torch.from_numpy is writable. Using im is a suspected cause of
+            # https://github.com/pixeltable/pixeltable/issues/69
+            return torchvision.transforms.ToTensor()(arr)
+        elif self.column_types[k].is_json_type():
+            assert isinstance(v, str)
+            return json.loads(v)
+        elif self.column_types[k].is_array_type():
+            assert isinstance(v, np.ndarray)
+            # WRITEABLE is required for torch collate function, or undefined behavior
+            if not v.flags["WRITEABLE"]:
+                vout = v.copy()
+                assert vout.flags["WRITEABLE"]
+                return vout
+            else:
+                return v
+        elif self.column_types[k].is_timestamp_type():
+            # pytorch default collation only supports numeric types
+            assert isinstance(v, datetime.datetime)
+            return v.timestamp()
+        else:
+            assert not isinstance(v, np.ndarray) # all array outputs should be handled above
+            return v
+
+    def __iter__(self) -> Generator[Dict[str, Any], None, None]:
+        worker_info = torch.utils.data.get_worker_info()
+        if worker_info is None:  # single-process data loading, return the full iterator
+            start_row = 0
+            end_row = self._totals[-1]
+        else:  # in a worker process
+            num_workers = [
+                math.floor(self._totals[-1] / float(worker_info.num_workers))
+                for _ in range(worker_info.num_workers)
+            ]
+            assert self._totals[-1] - sum(num_workers) < worker_info.num_workers
+            for i in range(self._totals[-1] - sum(num_workers)):
+                num_workers[i] += 1
+
+            assert sum(num_workers) == self._totals[-1]
+            start_rows = _cumsum(num_workers)
+            start_row = start_rows[worker_info.id]
+            end_row = start_rows[worker_info.id + 1]
+
+        if start_row == end_row:
+            return iter([])  # type: ignore
+        else:
+            return self._iter_range(start_row, end_row)
+
+    def _iter_range(self, start_row : int, end_row : int) -> Generator[Dict[str, Any], None, None]:
+        (part_no, iter_start) = self._get_start_position(start_row)
+        total = end_row - start_row
+
+        acc = 0
+        part_pos = part_no
+        iter_pos = iter_start
+
+        def _to_column_dict(tab : pa.Table) -> Dict[str, Any]:
+            column_dict = {}
+            for k in tab.column_names:
+                if self.column_types[k].is_array_type():
+                    # treat array columns as numpy arrays to easily preserve numpy type
+                    column_dict[k] = tab.column(k).to_numpy()
+                else:
+                    # for the rest, use pydict to preserve python types
+                    column_dict[k] = tab.column(k).to_pylist()
+            return column_dict
+
+        tab: pa.Table = pq.read_table(self.path / self.part_metadata[part_no][0])
+        column_dict = _to_column_dict(tab)
+        assert tab.num_rows == self.part_metadata[part_no][1]
+
+        while True:
+            while iter_pos < tab.num_rows and acc < total:
+                next_tup = {}
+                for col_name, col_vals in column_dict.items():
+                    raw_val = col_vals[iter_pos]
+                    next_tup[col_name] = self._unmarshall(col_name, raw_val)
+
+                yield next_tup
+                acc += 1
+                iter_pos += 1
+
+            if acc == total:
+                break
+
+            # move on to next part
+            part_pos += 1
+            assert part_pos < len(self.part_metadata)
+            iter_pos = 0
+            tab = pq.read_table(self.path / self.part_metadata[part_pos][0])
+            column_dict = _to_column_dict(tab)

pixeltable/utils/s3.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+
+def get_client() -> Any:
+    import boto3
+    import botocore
+    try:
+        boto3.Session().get_credentials().get_frozen_credentials()
+        return boto3.client('s3')  # credentials are available
+    except AttributeError:
+        # No credentials available, use unsigned mode
+        config = botocore.config.Config(signature_version=botocore.UNSIGNED)
+        return boto3.client('s3', config=config)

pixeltable/utils/sql.py

@@ -0,0 +1,17 @@
+import logging
+
+import sqlalchemy as sql
+
+
+def log_stmt(logger: logging.Logger, stmt) -> None:
+    logger.debug(f'executing {str(stmt.compile(dialect=sql.dialects.postgresql.dialect()))}')
+
+def log_explain(logger: logging.Logger, stmt: sql.sql.ClauseElement, conn: sql.engine.Connection) -> None:
+    try:
+        # don't set dialect=Env.get().engine.dialect: x % y turns into x %% y, which results in a syntax error
+        stmt_str = str(stmt.compile(compile_kwargs={'literal_binds': True}))
+        explain_result = conn.execute(sql.text(f'EXPLAIN {stmt_str}'))
+        explain_str = '\n'.join([str(row) for row in explain_result])
+        logger.debug(f'SqlScanNode explain:\n{explain_str}')
+    except Exception as e:
+        logger.warning(f'EXPLAIN failed')

pixeltable/utils/transactional_directory.py

@@ -0,0 +1,35 @@
+import shutil
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Generator
+
+import pixeltable.exceptions as excs
+
+
+@contextmanager
+def transactional_directory(folder_path: Path) -> Generator[Path, Any, Any]:
+    """
+    Args:
+        folder_path: path to the folder we want to create
+
+    Yields:
+        A pathlib.Path to a hidden temporary folder, which can be used to accumulate changes.
+        If everything succeeds, the changes are committed via an atomic move operation upon exiting the 'with' block (os.replace)
+        If an exception occurred, no changes are visible in the original folder.
+
+    Example:
+        folder_path = pathlib.Path("path/to/folder")
+        with transactional_folder(folder_path) as temp_folder:
+            (temp_folder / "subfolder1").mkdir()
+            (temp_folder / "subfolder2").mkdir()
+    """
+    if folder_path.exists():
+        raise excs.Error(f"Folder {folder_path} already exists")
+
+    tmp_folder = folder_path.parent / f".tmp_{folder_path.name}"
+    # Remove the temporary folder if it already exists, eg if the previous run crashed
+    shutil.rmtree(str(tmp_folder), ignore_errors=True)
+    tmp_folder.mkdir(parents=True)
+    yield tmp_folder
+    # If everything succeeds, `commit' the changes by moving the temporary folder
+    tmp_folder.rename(folder_path)

pixeltable-0.2.1.dist-info/LICENSE

@@ -0,0 +1,18 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+
+   Copyright 2023 Marcel Kornacker
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pixeltable-0.2.1.dist-info/METADATA

@@ -0,0 +1,119 @@
+Metadata-Version: 2.1
+Name: pixeltable
+Version: 0.2.1
+Summary: Pixeltable: The Multimodal AI Data Plane
+Author: Marcel Kornacker
+Author-email: marcelk@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: av (>=10.0.0)
+Requires-Dist: cloudpickle (>=2.2.1,<3.0.0)
+Requires-Dist: jinja2 (>=3.1.3,<4.0.0)
+Requires-Dist: jmespath (>=1.0.1,<2.0.0)
+Requires-Dist: numpy (>=1.24.1,<2.0.0)
+Requires-Dist: opencv-python-headless (>=4.7.0.68,<5.0.0.0)
+Requires-Dist: pandas (>=1.5.3,<2.0.0)
+Requires-Dist: pgserver (==0.0.5)
+Requires-Dist: pgvector (>=0.2.1,<0.3.0)
+Requires-Dist: pillow (>=9.4.0,<10.0.0)
+Requires-Dist: psutil (>=5.9.5,<6.0.0)
+Requires-Dist: psycopg2-binary (>=2.9.5,<3.0.0)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: regex (>=2022.10.31,<2023.0.0)
+Requires-Dist: sqlalchemy-utils (>=0.41.1,<0.42.0)
+Requires-Dist: sqlalchemy[mypy] (>=2.0.23,<3.0.0)
+Requires-Dist: tqdm (>=4.64.1,<5.0.0)
+Description-Content-Type: text/markdown
+
+<img src="docs/pixeltable-banner.png" width="45%"/>
+
+# Pixeltable: The Multimodal AI Data Plane
+
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+&nbsp;&nbsp;
+![pytest status](https://github.com/pixeltable/pixeltable/actions/workflows/pytest.yml/badge.svg)
+
+Pixeltable is a Python library that lets AI engineers and data scientists focus on
+exploration, modeling, and app development without having to deal with the customary
+data plumbing.
+
+**Pixeltable redefines data infrastructure and workflow orchestration for AI development.**
+It brings together data storage, versioning, and indexing with orchestration and model
+versioning under a declarative table interface, with transformations, model inference,
+and custom logic represented as computed columns.
+<!--
+## Quick Start
+
+If you just want to play around with Pixeltable to see what it's capable of, the easiest way is to run
+the Pixeltable Basics tutorial in colab:
+
+<a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/docs/tutorials/pixeltable-basics.ipynb">
+  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
+</a>
+-->
+## Installation
+
+Pixeltable works with Python 3.9, 3.10, or 3.11 running on Linux or MacOS.
+
+```
+pip install pixeltable
+```
+
+To verify that it's working:
+
+```
+import pixeltable as pxt
+cl = pxt.Client()
+```
+
+For more detailed installation instructions, see the
+[Getting Started with Pixeltable](https://pixeltable.github.io/pixeltable/getting-started/)
+guide. Then, check out the
+[Pixeltable Basics](https://pixeltable.github.io/pixeltable/tutorials/pixeltable-basics/)
+tutorial for a tour of its most important features.
+
+## What problems does Pixeltable solve?
+
+Today’s solutions for AI app development require extensive custom coding and infrastructure
+plumbing. Tracking lineage and versions between and across data transformations, models, and
+deployment is cumbersome. Pixeltable is a replacement for traditional data plumbing, providing
+a unified plane for data, models, and orchestration. It removes the data plumbing overhead in
+building and productionizing AI applications.
+
+## Why should you use Pixeltable?
+
+- It gives you transparency and reproducibility
+    - All generated data is automatically recorded and versioned
+    - You will never need to re-run a workload because you lost track of the input data
+- It saves you money
+    - All data changes are automatically incremental
+    - You never need to re-run pipelines from scratch because you’re adding data
+- It integrates with any existing Python code or libraries
+    - Bring your ever-changing code and workloads
+    - You choose the models, tools, and AI practices (e.g., your embedding model for a vector index); Pixeltable orchestrates the data
+
+## Example Use Cases
+
+* Interact with video data at the frame level without having to think about frame extraction,
+intermediate file storage, or storage space explosion.
+* Augment your data incrementally and interactively with built-in functions and UDFs, such as
+image transformations, model inference, and visualizations, without having to think about data pipelines,
+incremental updates, or capturing function output.
+* Interact with all the data relevant to your AI application (video, images, documents, audio, structured data, JSON) through
+a simple dataframe-style API directly in Python. This includes:
+    * similarity search on embeddings, supported by high-dimensional vector indexing
+    * path expressions and transformations on JSON data
+    * PIL and OpenCV image operations
+    * assembling frames into videos
+* Perform keyword and image similarity search at the video frame level without having to worry about frame
+storage.
+* Access all Pixeltable-resident data directly as a PyTorch dataset in your training scripts.
+* Understand the compute and storage costs of your data at the granularity of individual augmentations and
+get cost projections before adding new data and new augmentations.
+* Rely on Pixeltable's automatic versioning and snapshot functionality to protect against regressions
+and to ensure reproducibility.
+

pixeltable-0.2.1.dist-info/RECORD

@@ -0,0 +1,125 @@
+pixeltable/__init__.py,sha256=enh38lhZ_38Ys3rCy_XC_BlPNPK9H2CKV4KePaqnV4E,959
+pixeltable/catalog/__init__.py,sha256=E41bxaPeQIcgRYzTWc2vkDOboQhRymrJf4IcHQO7o_8,453
+pixeltable/catalog/catalog.py,sha256=0TYWB1R6YBp9qCkWF7kCcX2Yw70UuburKKIemv5L1Js,7908
+pixeltable/catalog/column.py,sha256=7PU5yECislpR_PNZTT3Z5sZiE34DnI6SR3WDsI-WgCg,8661
+pixeltable/catalog/dir.py,sha256=pG1nMpG123POo6WMSHhAmnwXOQ26uUJfUcbzL-Jb4ws,919
+pixeltable/catalog/globals.py,sha256=yLEGNbsSnLzjWNHVJacfjA9hbw13Q6QXLOSCRmdTlq0,943
+pixeltable/catalog/insertable_table.py,sha256=1JGZqmx5tKbm_UmJLIalntFDs81s-mvTv0gOqk98b3Q,8280
+pixeltable/catalog/named_function.py,sha256=a96gnKtx-nz5_MzDIiD4t4Hxqdjkg9ZtijRQxvWA5WQ,1147
+pixeltable/catalog/path.py,sha256=QgccEi_QOfaKt8YsR2zLtd_z7z7QQkU_1kprJFi2SPQ,1677
+pixeltable/catalog/path_dict.py,sha256=xfvxg1Ze5jZCARUGASF2DRbQPh7pRVTYhuJ_u82gYUo,5941
+pixeltable/catalog/schema_object.py,sha256=-UxmPLbuEBqJiJi_GGRbFdr7arAFxTqs4bt6TFmSt3M,1059
+pixeltable/catalog/table.py,sha256=CJQc2NnebfL1ekMcaZhJEZ0CI408-F7R90_czjDKy-g,25499
+pixeltable/catalog/table_version.py,sha256=Q1NSaeLmFw7gYgARyyW6JJ79GRhjtp0_Q410KH27e1Q,35680
+pixeltable/catalog/table_version_path.py,sha256=kn5T0m5XBqphlDqCKsqD-s159diCjKvrSrtzYZHwKuw,5461
+pixeltable/catalog/view.py,sha256=BIL3s4DV3tWbOcqtqnhn46B2UvLaBhppfJUlNEt5nec,9734
+pixeltable/client.py,sha256=HiqGNRQoyBPXF2rAhTJFE3ZSUUaSLpGo28pLZjubh8Y,20548
+pixeltable/dataframe.py,sha256=rLgeYdVhAyeCZcgTDJWbCwR59OVp5vmpwL4PrIaEcDM,28327
+pixeltable/env.py,sha256=NdjLCAYCYqb2IlOJXTgLROondJim9adkj6hX3atCbNE,16225
+pixeltable/exceptions.py,sha256=MSP9zeL0AmXT93XqjdvgGN4rzno1_KRrGriq6hpemnw,376
+pixeltable/exec/__init__.py,sha256=FOQBSMQ3buGg5kRzymkfDCk5fnVfICn3LrsJtbyNC6E,412
+pixeltable/exec/aggregation_node.py,sha256=cf6rVAgrGh_uaMrCIgXJIwQTmbcboJlnrH_MmPIQSd0,3321
+pixeltable/exec/cache_prefetch_node.py,sha256=UE5LgZQzyhoiG1XNJgpXQ1CRJWVpiheJEAlcV9pc0ss,5104
+pixeltable/exec/component_iteration_node.py,sha256=Uz6zEeaJMcbvF3S0W0qmLI_uWsZsaSspHKNzuAMrasg,4069
+pixeltable/exec/data_row_batch.py,sha256=ZaS_ciyYhoP50Aoszhgtnh_yDRR6z9H43crnaJdP-xA,3505
+pixeltable/exec/exec_context.py,sha256=E82Q2bJMJ1ulud5L5D9dh2Z8vEUQ659SgT614YKDO34,924
+pixeltable/exec/exec_node.py,sha256=Hji5NCPHfa50IWyjladXrBm4I0zseV7AV4cVdx0Q8Ew,2170
+pixeltable/exec/expr_eval_node.py,sha256=mqACyEy48fsiWkbHSkkMc8gG2nL-WT6eJSG3nltM85c,10810
+pixeltable/exec/in_memory_data_node.py,sha256=x2Jn_AGx52YcDPORH8sZZRD0s64Ng1NvfMpqAW-bVwY,2949
+pixeltable/exec/media_validation_node.py,sha256=OKfRyKpcn7AZdACy_HD4NsDC87ZfNFs1tdrQz2NiIVw,1514
+pixeltable/exec/sql_scan_node.py,sha256=zKJ2_iM0ah748Vz8jD0Lkm7TRyUChIejnGUPNmYPgbs,10318
+pixeltable/exprs/__init__.py,sha256=EkpjeEW-8rriE9hVb9PdiknHQ3-Y8jPp37yJ-NC_oWA,935
+pixeltable/exprs/arithmetic_expr.py,sha256=sWBYCBKI6IHj9ASwDcm2BlkQ5gleVtKtmpiPvzFNBJM,4386
+pixeltable/exprs/array_slice.py,sha256=VmWc6iFusrM85MjyEBBCfXG1Jnt8-Gr6-J88BXxNoOE,2131
+pixeltable/exprs/column_property_ref.py,sha256=0PHiBys0fxe2LgjaMId5UHob4E-ZggyPLnnW41RgA0E,2706
+pixeltable/exprs/column_ref.py,sha256=5-mbWV8-cWWu0ynxPSQ0L8oLewDrLp17xh8DOCmQ36s,4794
+pixeltable/exprs/comparison.py,sha256=jwwvKG0nLOHiNyjZm8AWKn59qBtTYH98vTF_hhwn0Og,3000
+pixeltable/exprs/compound_predicate.py,sha256=Gh22MKi625m5A_RunVRd-a1XFi-fitikqBVz2VNXKrs,3830
+pixeltable/exprs/data_row.py,sha256=gKlRbzG4KoObR27zFK0QYlbc07IznIfYTwmknUyL5zo,7535
+pixeltable/exprs/expr.py,sha256=JyEmP8F9LXmxOrVswih1Aq0SrpGcboSRinOYIMWYfKM,23748
+pixeltable/exprs/expr_set.py,sha256=Q64Q2yI0CTq2Ma_E-BUYlMotSstVuMm4OFZnBCedHRk,1222
+pixeltable/exprs/function_call.py,sha256=QFzkb2gKjeALGTgCet-o0HETwTXoFBzsncbghgScmOE,16961
+pixeltable/exprs/globals.py,sha256=liPgUTccTkyDRs4kG2r9ehRkwGZERmrCSJDZRdJoMqk,1537
+pixeltable/exprs/image_member_access.py,sha256=aLRpSu3fhAph86jYMQEdE4ZLoN96xDXlf4t4-MUX2_s,4663
+pixeltable/exprs/image_similarity_predicate.py,sha256=PVoPaYP9-Wds1jZvr0AsUAjklkk2AxyokgcAykWs0g4,1906
+pixeltable/exprs/inline_array.py,sha256=i9Q7kD11X5X-j-NiuMx8kigdEnKBEL8HKBX6fQ8TmyE,4312
+pixeltable/exprs/inline_dict.py,sha256=Lb3VS3Mkxb72mWL4qipOQjUgY8AMxk1POj225Xqjtos,3695
+pixeltable/exprs/is_null.py,sha256=nvpOXtQj1UeYJpkCWzbaGuQElzrA2HSG3XNQugOv-pw,1041
+pixeltable/exprs/json_mapper.py,sha256=I60VNgus64ai80gnFCIsRn0VRWYXMkqH5VNvnATsN9s,4559
+pixeltable/exprs/json_path.py,sha256=Wz_5zFsyc9TPhsSbsDjDmQ3Nb0uVIwMCx5nh-cQYBiE,6526
+pixeltable/exprs/literal.py,sha256=LOeD0aN_V7Kg332xzCHWUlzKPupXiptpU_rg-X0bEt0,1885
+pixeltable/exprs/object_ref.py,sha256=eTcx84aWRI59fIiGvbdv3_cfL0XW4xEFQ4lwpLpJkM8,1250
+pixeltable/exprs/predicate.py,sha256=OSDgjfSqiK7J_5GZMUXMvjfyomKEGi0JNxeB073SGXw,1859
+pixeltable/exprs/row_builder.py,sha256=sOW2zG6MwqOT8BFgmlveqIiRGPZinuK0_dY6IgmCWT0,16992
+pixeltable/exprs/rowid_ref.py,sha256=74w4rEy21YysTVbyKNc3op-pYFqDAx8VJdtl7ZPpxHs,4268
+pixeltable/exprs/type_cast.py,sha256=JMg8p1qYoFfiAXfJPSbTEnfrK7lRO_JMaqlPHOrhNQU,1793
+pixeltable/exprs/variable.py,sha256=Kg_O4ytcHYZFijIyMHYBJn063cTKU1-YE583FAz8Qaw,1361
+pixeltable/func/__init__.py,sha256=4qvDnK_S5yljwtIrxCkeQlz6vuTVfwSU4zl-MBT2TMU,457
+pixeltable/func/aggregate_function.py,sha256=E11lVKBR4MZQ6VT0G4oo5xWR907BqHqJog-widXcJt0,9177
+pixeltable/func/batched_function.py,sha256=nrfmykJps4QkgzeC4ZroGy8mJ-BACNKbRJABHHG6-Ac,2350
+pixeltable/func/callable_function.py,sha256=WGUwjNEzXGDJ1jzdZ-mrn2cnfEHmFZIh_DRl_Yk89D0,2357
+pixeltable/func/expr_template_function.py,sha256=Nj-FDDozSuvcoQ7KsJcQrzzQn7foeCY7zSEFkusiLqQ,3392
+pixeltable/func/function.py,sha256=NcGyKp7ds6bMzg1qzuaK8pBQH_DhknmSiZzsfXi-z2k,4023
+pixeltable/func/function_registry.py,sha256=1ibSQxEPm3Zd3r497vSlckQiDG9sfCnyJx3zcSm9t7c,11456
+pixeltable/func/globals.py,sha256=UP4hAkEVKD_3lr7l_VVUUCetJP85sydUYiVAU4m5-aw,1220
+pixeltable/func/nos_function.py,sha256=HzIKK4XjTo1E6pML-EbhuX3u_LYibFWUuTkIxoIih7c,9650
+pixeltable/func/signature.py,sha256=5Xo3hIVSXoYtkU-BvUi21b6FghIQABm48UfVjQr9QYU,7107
+pixeltable/func/udf.py,sha256=XlB7dzOc98XinUrs4tMGUAetV0SmQ_Z2oKPDBsx46o0,6457
+pixeltable/functions/__init__.py,sha256=kFepRTpg-YOeeXG9076s9v-lm8ZUNqicaPUfX-CrW5c,3419
+pixeltable/functions/eval.py,sha256=qLc_55VTwi_IDnAJFq79Hy7FLi7Gb26DxdykYiBTMrM,8453
+pixeltable/functions/fireworks.py,sha256=7h1gxcGhG8jepS_Gi1nwp8zCw1gdRaTzufS6U08mmLc,1596
+pixeltable/functions/huggingface.py,sha256=Wg8AgCsoGFx8AX3AThko66L7uSg9cUEjL8_QxKoA4dg,4804
+pixeltable/functions/image.py,sha256=xR_S_0BuX6Ycc5E366GpOfP0JptD7beQwHE_fLl8ZVM,431
+pixeltable/functions/openai.py,sha256=SkwUBnnTT6olQCMHzQGO0vpvApgAaBk_88W7YM8QQuo,2863
+pixeltable/functions/pil/image.py,sha256=8gItSXXuJaCkq9FHEJE9qFpRM3WAoa59x89Xa0DgksQ,6217
+pixeltable/functions/string.py,sha256=RYOgZwifjC943YloEMi3PdflnjFqOYB2FddrUvzgtXs,516
+pixeltable/functions/together.py,sha256=TGo72RJuHqofwJHSrHqsJoO6RQm6Iipqhy49V3JiBss,650
+pixeltable/functions/util.py,sha256=v094FgixHchzKMj4YvfHExDRGIVhCL2D-NL3pl-92oo,1596
+pixeltable/functions/video.py,sha256=WZF4G3tV-_LfRQHUinXe_rnu1-4N68Ht60JCR_s7Bew,2403
+pixeltable/iterators/__init__.py,sha256=sfsasCypAq5rNOTMlr4j2ROXxzdl4M8L2KvQIEbd0cQ,70
+pixeltable/iterators/base.py,sha256=sugU9mG19xf9I4c_lEQDI_xrXPLuyuIYlKc-9OiS1HQ,1545
+pixeltable/iterators/document.py,sha256=LWqF8dK5sLMLemyYfEOSGXC8z8yrTev4cbgHbORPyQ0,13088
+pixeltable/iterators/video.py,sha256=mUdHev0f_XJIfHTB-mejjToURh10Ud7l096eZm2aPjM,3444
+pixeltable/metadata/__init__.py,sha256=6rLGFpWzQMCk0EcSKLp4Bnbk8tLK1cxuONBPqwDCMzU,2083
+pixeltable/metadata/converters/convert_10.py,sha256=0mSGCn7vqtef63riPi9msUaaUvsSQIj-NFj9QFDYPdA,733
+pixeltable/metadata/schema.py,sha256=oTxtFSvbmCEcr54F929_NYFVp76N8gpN4nHDr9VnA9M,7761
+pixeltable/plan.py,sha256=BQMCxOCy7lO4dqBCt5W9GUFdBWkuhr13-T8_2E97fUk,34710
+pixeltable/store.py,sha256=91WSmmYcvf_dXZEchj4jcBC7GavPFGZbwHGoPMKlfjU,19230
+pixeltable/tests/conftest.py,sha256=8H8llMTdc7l9tUKuPqI-KzJYdM_G_X-mGPx9RhxNPYU,6581
+pixeltable/tests/test_audio.py,sha256=92PMPrMtYzLoaLiW92MupEfWPEcfoLlYlZKlxmWQXdI,3186
+pixeltable/tests/test_catalog.py,sha256=Npxt72g5aZkfg1fqE-19L8rGilzicAiTC0ithIy3woI,1189
+pixeltable/tests/test_client.py,sha256=9acrjElh1YVX8WXWO04VQ-S6mNx9ZtqAHoh4uBc81y4,531
+pixeltable/tests/test_component_view.py,sha256=I_IQalmd79LocI3bgwQ4Ad91fOHS1E9AOVhe--NH4Io,17704
+pixeltable/tests/test_dataframe.py,sha256=zu1Zw3c7k96afWqUyFwUnOBebzLxTRZ0xA3v7tnM2n8,17686
+pixeltable/tests/test_dirs.py,sha256=WuWGOcpUFPCl1PGZgOMcU5bpzv1ClUqZ5AxavrDeCic,3611
+pixeltable/tests/test_document.py,sha256=KUHZmjpI94rHdwOPBrhsSpeaqYbBTzIKa2gX98WGE7E,5657
+pixeltable/tests/test_exprs.py,sha256=A4rhwONnOjovgenYF81n_q8NMJaGisT1kq8kJdDAqQ4,32695
+pixeltable/tests/test_function.py,sha256=6sA_3Oe1p4sUhL5L5hYyW-mG1TPGfFDmW1BPVPnGXek,12817
+pixeltable/tests/test_functions.py,sha256=XmqIwcZ5lVouSowtVImJPgIv0bSEYHR-J0BzgLDHkm8,14477
+pixeltable/tests/test_migration.py,sha256=UjJhhg061TtyTAa1CAB-BdlT9YwLJkl8yIGSetnqcKw,1535
+pixeltable/tests/test_nos.py,sha256=ITE7FNEaNreJ_XTz4wYLWuidFSUQMFp3ShuHTz05OrE,2649
+pixeltable/tests/test_snapshot.py,sha256=J8wepLOaOrJkqDWq1dkou8MIR5Hf1DEseAqlUrb7BFg,9297
+pixeltable/tests/test_table.py,sha256=rnB8LxER2hwXhFGWpZI_XgV_ZYfiYSw4x8zmbh-eln8,48202
+pixeltable/tests/test_transactional_directory.py,sha256=Jx55PZgrkHTI0Eli09puwMckvwfCM9arPTQUT9g6Tbg,1308
+pixeltable/tests/test_types.py,sha256=4_LR5Poc8Fa5fOpRBaAc_qAN21SsVxFP54Npq_6n9G8,970
+pixeltable/tests/test_video.py,sha256=GiSQjvobVdMvjGqvpZCc778sGpqX4LEy84zfgNSpjtA,7676
+pixeltable/tests/test_view.py,sha256=vbKEk9kWF5U6B78uNLSQsGw46s2oOOhHnJy8p9NmNTo,21859
+pixeltable/tests/utils.py,sha256=z_dj69xN3iLA2-nL7dy98tvZdlPFKjZHNuWogAWO75Y,9914
+pixeltable/tool/create_test_db_dump.py,sha256=ARlLUfOs4stxIPFl-hGl_KX-ck6JRWmUiXqTwTtS1GU,5148
+pixeltable/type_system.py,sha256=w3UMqk3U1IXyo-gAfoeiaOB26iSgYKAeGmTDzpwQkRk,31781
+pixeltable/utils/__init__.py,sha256=UYlrf6TIWJT0g-Hac0b34-dEk478B5Qx8dGco34YlIk,439
+pixeltable/utils/clip.py,sha256=HXXWFBJXW9XysdMk9_3hP1V1S-3B8Hwd5rNMbJFjjnI,720
+pixeltable/utils/coco.py,sha256=mk1cxjKYQC0ABm2ZQ9SNu9MvBPECmmKvnASpxnFXdL0,5604
+pixeltable/utils/documents.py,sha256=MGtWZs93Bt_pdExxT9yjH7VWbawSd5A2O5_YdxEZlMk,1094
+pixeltable/utils/filecache.py,sha256=UoNONG2VaAc2IBB0e3sQdsvyOPOes2XSDc5_CsA4qek,7839
+pixeltable/utils/help.py,sha256=cCnxJ4VP9MJ57iDqExmnDcM-JG3a1lw_q7g-D7bpSVI,252
+pixeltable/utils/media_store.py,sha256=x71wnJDZDHcdd13VCfL4AkHQ6IJB41gNA-zBvXJwFos,3116
+pixeltable/utils/parquet.py,sha256=3cjC1vibPHQ24cQS0xPwTjkhxK9TVkITkSxkf29bdaQ,5775
+pixeltable/utils/pytorch.py,sha256=h7q-7q3gXThDoTVA8k9vIvMc4VgnNAQy3ScDIU6h3IE,6515
+pixeltable/utils/s3.py,sha256=rkanuhk9DWvSfmbOLQW1j1Iov4sl2KhxGGKN-AJ8LSE,432
+pixeltable/utils/sql.py,sha256=5n5_OmXAGtqFdL6z5XvgnU-vlx6Ba6f1WJrO1ZwUle8,765
+pixeltable/utils/transactional_directory.py,sha256=UGzCrGtLR3hEEf8sYGuWBzLVFAEQml3vdIavigWeTBM,1349
+pixeltable-0.2.1.dist-info/LICENSE,sha256=0UNMmwuqWPC0xDY1NWMm4uNJ2_MyA1pnTNRgQTvuBiQ,746
+pixeltable-0.2.1.dist-info/METADATA,sha256=kGc8hDA7BwNSqw_uM-c-rytQbY8iZPFJKs_X8jQv0DY,5392
+pixeltable-0.2.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+pixeltable-0.2.1.dist-info/RECORD,,

{pixeltable-0.1.2.dist-info → pixeltable-0.2.1.dist-info}/WHEEL

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