pixeltable 0.2.6__py3-none-any.whl → 0.2.7__py3-none-any.whl

pixeltable/iterators/video.py

@@ -6,14 +6,22 @@ from typing import Dict, Any, List, Tuple
 import PIL.Image
 import cv2
 
-from pixeltable import exprs
 from pixeltable.exceptions import Error
 from pixeltable.type_system import ColumnType, VideoType, ImageType, IntType, FloatType
 from .base import ComponentIterator
 
 _logger = logging.getLogger('pixeltable')
 
+
 class FrameIterator(ComponentIterator):
+    """Iterator over frames of a video.
+
+        Args:
+            video: URL or file of the video to use for frame extraction
+            fps: number of frames to extract per second of video. This may be a fractional value, such as 0.5.
+                If set to 0.0, then the native framerate of the video will be used (all frames will be extracted).
+                Default: 0.0
+    """
     def __init__(self, video: str, *, fps: float = 0.0):
         video_path = Path(video)
         assert video_path.exists() and video_path.is_file()

pixeltable/metadata/__init__.py

@@ -10,11 +10,11 @@ import sqlalchemy.orm as orm
 from .schema import SystemInfo, SystemInfoMd
 
 # current version of the metadata; this is incremented whenever the metadata schema changes
-VERSION = 14
+VERSION = 16
 
 
 def create_system_info(engine: sql.engine.Engine) -> None:
-    """Create the systemmetadata record"""
+    """Create the system metadata record"""
     system_md = SystemInfoMd(schema_version=VERSION)
     record = SystemInfo(md=dataclasses.asdict(system_md))
     with orm.Session(engine, future=True) as session:

pixeltable/metadata/converters/convert_14.py

@@ -0,0 +1,13 @@
+import sqlalchemy as sql
+
+from pixeltable.metadata.schema import Table
+from pixeltable.metadata import register_converter
+
+
+def convert_14(engine: sql.engine.Engine) -> None:
+    default_remotes = {'remotes': []}
+    with engine.begin() as conn:
+        conn.execute(sql.update(Table).where(Table.md['remotes'] == None).values(md=Table.md.concat(default_remotes)))
+
+
+register_converter(14, convert_14)

pixeltable/metadata/converters/convert_15.py

@@ -0,0 +1,29 @@
+import uuid
+
+import sqlalchemy as sql
+
+from pixeltable.metadata import register_converter
+from pixeltable.metadata.converters.util import convert_table_md
+
+
+def convert_15(engine: sql.engine.Engine) -> None:
+    convert_table_md(engine, column_md_updater=update_column_md, remote_md_updater=update_remote_md)
+
+
+def update_column_md(column_md: dict) -> None:
+    column_md['proxy_base'] = None
+
+
+def update_remote_md(remote_md: dict) -> None:
+    remote_md['class'] = f'{remote_md["module"]}.{remote_md["class"]}'
+    del remote_md['module']
+    if remote_md['class'] == 'pixeltable.datatransfer.remote.MockRemote':
+        remote_md['remote_md']['name'] = f'remote_{uuid.uuid4()}'
+    elif remote_md['class'] == 'pixeltable.datatransfer.label_studio.LabelStudioProject':
+        # 'post' is the media_import_method for legacy LabelStudioProject remotes
+        remote_md['remote_md']['media_import_method'] = 'post'
+    else:
+        assert False, remote_md['class']
+
+
+register_converter(15, convert_15)

pixeltable/metadata/converters/util.py

@@ -0,0 +1,63 @@
+import copy
+import logging
+from typing import Any, Callable, Optional
+
+import sqlalchemy as sql
+
+from pixeltable.metadata.schema import Table
+
+__logger = logging.getLogger('pixeltable')
+
+
+def convert_table_md(
+    engine: sql.engine.Engine,
+    column_md_updater: Optional[Callable[[dict], None]] = None,
+    remote_md_updater: Optional[Callable[[dict], None]] = None,
+    substitution_fn: Optional[Callable[[Any, Any], Optional[tuple[Any, Any]]]] = None
+) -> None:
+    with engine.begin() as conn:
+        for row in conn.execute(sql.select(Table)):
+            id = row[0]
+            table_md = row[2]
+            assert isinstance(table_md, dict)
+            updated_table_md = copy.deepcopy(table_md)
+            if column_md_updater is not None:
+                __update_column_md(updated_table_md, column_md_updater)
+            if remote_md_updater is not None:
+                __update_remote_md(updated_table_md, remote_md_updater)
+            if substitution_fn is not None:
+                updated_table_md = __substitute_md_rec(updated_table_md, substitution_fn)
+            if updated_table_md != table_md:
+                __logger.info(f'Updating schema for table: {id}')
+                conn.execute(sql.update(Table).where(Table.id == id).values(md=updated_table_md))
+
+
+def __update_column_md(table_md: dict, column_md_updater: Callable[[dict], None]) -> None:
+    columns_md = table_md['column_md']
+    assert isinstance(columns_md, dict)
+    for column_md in columns_md.values():
+        column_md_updater(column_md)
+
+
+def __update_remote_md(table_md: dict, remote_md_updater: Callable[[dict], None]) -> None:
+    remotes_md = table_md['remotes']
+    assert isinstance(remotes_md, list)
+    for remote_md in remotes_md:
+        remote_md_updater(remote_md)
+
+
+def __substitute_md_rec(md: Any, substitution_fn: Callable[[Any, Any], Optional[tuple[Any, Any]]]) -> Any:
+    if isinstance(md, dict):
+        updated_md = {}
+        for k, v in md.items():
+            substitute = substitution_fn(k, v)
+            if substitute is not None:
+                updated_k, updated_v = substitute
+                updated_md[updated_k] = updated_v
+            else:
+                updated_md[k] = __substitute_md_rec(v, substitution_fn)
+        return updated_md
+    elif isinstance(md, list):
+        return [__substitute_md_rec(v, substitution_fn) for v in md]
+    else:
+        return md

pixeltable/metadata/schema.py

@@ -1,12 +1,11 @@
-from typing import Optional, List, get_type_hints, Type, Any, TypeVar, Tuple, Union
-import platform
-import uuid
 import dataclasses
+import uuid
+from typing import Optional, List, get_type_hints, Type, Any, TypeVar, Tuple, Union
 
 import sqlalchemy as sql
-from sqlalchemy import Integer, String, Boolean, BigInteger, LargeBinary
+from sqlalchemy import ForeignKey
+from sqlalchemy import Integer, BigInteger, LargeBinary
 from sqlalchemy.dialects.postgresql import UUID, JSONB
-from sqlalchemy import ForeignKey, UniqueConstraint, ForeignKeyConstraint
 from sqlalchemy.orm import declarative_base
 
 Base = declarative_base()
@@ -93,6 +92,9 @@ class ColumnMd:
     # if True, the column is present in the stored table
     stored: Optional[bool]
 
+    # if specified, the column is a stored proxy of another column
+    proxy_base: Optional[int]
+
 
 @dataclasses.dataclass
 class IndexMd:
@@ -143,6 +145,10 @@ class TableMd:
     # - every row is assigned a unique and immutable rowid on insertion
     next_row_id: int
 
+    # Metadata format for remotes:
+    # {'class': 'pixeltable.datatransfer.LabelStudioProject', 'md': {'project_id': 3}}
+    remotes: list[dict[str, Any]]
+
     column_md: dict[int, ColumnMd]  # col_id -> ColumnMd
     index_md: dict[int, IndexMd]  # index_id -> IndexMd
     view_md: Optional[ViewMd]
@@ -160,7 +166,7 @@ class Table(Base):
 
     MAX_VERSION = 9223372036854775807  # 2^63 - 1
 
-    id = sql.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, nullable=False)
+    id = sql.Column(UUID(as_uuid=True), primary_key=True, nullable=False)
     dir_id = sql.Column(UUID(as_uuid=True), ForeignKey('dirs.id'), nullable=False)
     md = sql.Column(JSONB, nullable=False)  # TableMd
 

pixeltable/plan.py

@@ -251,7 +251,7 @@ class Planner:
         Returns:
             - root node of the plan
             - list of qualified column names that are getting updated
-            - list of columns that are being recomputed
+            - list of user-visible columns that are being recomputed
         """
         # retrieve all stored cols and all target exprs
         assert isinstance(tbl, catalog.TableVersionPath)
@@ -260,7 +260,10 @@ class Planner:
         if len(recompute_targets) > 0:
             recomputed_cols = recompute_targets.copy()
         else:
-            recomputed_cols = target.get_dependent_columns(updated_cols) if cascade else {}
+            recomputed_cols = target.get_dependent_columns(updated_cols) if cascade else set()
+            # regardless of cascade, we need to update all indices on any updated column
+            idx_val_cols = target.get_idx_val_columns(updated_cols)
+            recomputed_cols.update(idx_val_cols)
             # we only need to recompute stored columns (unstored ones are substituted away)
             recomputed_cols = {c for c in recomputed_cols if c.is_stored}
         recomputed_base_cols = {col for col in recomputed_cols if col.tbl == target}
@@ -273,8 +276,8 @@ class Planner:
         recomputed_exprs = \
             [c.value_expr.copy().resolve_computed_cols(resolve_cols=recomputed_base_cols) for c in recomputed_base_cols]
         # recomputed cols reference the new values of the updated cols
-        for col, e in update_targets.items():
-            exprs.Expr.list_substitute(recomputed_exprs, exprs.ColumnRef(col), e)
+        spec = {exprs.ColumnRef(col): e for col, e in update_targets.items()}
+        exprs.Expr.list_substitute(recomputed_exprs, spec)
         select_list.extend(recomputed_exprs)
 
         # we need to retrieve the PK columns of the existing rows
@@ -282,7 +285,8 @@ class Planner:
         all_base_cols = copied_cols + updated_cols + list(recomputed_base_cols)  # same order as select_list
         # update row builder with column information
         [plan.row_builder.add_table_column(col, select_list[i].slot_idx) for i, col in enumerate(all_base_cols)]
-        return plan, [f'{c.tbl.name}.{c.name}' for c in updated_cols + list(recomputed_cols)], list(recomputed_cols)
+        recomputed_user_cols = [c for c in recomputed_cols if c.name is not None]
+        return plan, [f'{c.tbl.name}.{c.name}' for c in updated_cols + recomputed_user_cols], recomputed_user_cols
 
     @classmethod
     def create_view_update_plan(

pixeltable/store.py

@@ -66,7 +66,6 @@ class StoreBase:
         """Create self.sa_tbl from self.tbl_version."""
         system_cols = self._create_system_columns()
         all_cols = system_cols.copy()
-        idxs: List[sql.Index] = []
         for col in [c for c in self.tbl_version.cols if c.is_stored]:
             # re-create sql.Column for each column, regardless of whether it already has sa_col set: it was bound
             # to the last sql.Table version we created and cannot be reused
@@ -76,26 +75,18 @@ class StoreBase:
                 all_cols.append(col.sa_errormsg_col)
                 all_cols.append(col.sa_errortype_col)
 
-            # we create an index for:
-            # - scalar columns (except for strings, because long strings can't be used for B-tree indices)
-            # - non-computed video and image columns (they will contain external paths/urls that users might want to
-            #   filter on)
-            if (col.col_type.is_scalar_type() and not col.col_type.is_string_type()) \
-                    or (col.col_type.is_media_type() and not col.is_computed):
-                # index names need to be unique within the Postgres instance
-                idx_name = f'idx_{col.id}_{self.tbl_version.id.hex}'
-                idxs.append(sql.Index(idx_name, col.sa_col))
-
         if self.sa_tbl is not None:
             # if we're called in response to a schema change, we need to remove the old table first
             self.sa_md.remove(self.sa_tbl)
 
+        idxs: List[sql.Index] = []
         # index for all system columns:
         # - base x view joins can be executed as merge joins
         # - speeds up ORDER BY rowid DESC
         # - allows filtering for a particular table version in index scan
         idx_name = f'sys_cols_idx_{self.tbl_version.id.hex}'
         idxs.append(sql.Index(idx_name, *system_cols))
+
         # v_min/v_max indices: speeds up base table scans needed to propagate a base table insert or delete
         idx_name = f'vmin_idx_{self.tbl_version.id.hex}'
         idxs.append(sql.Index(idx_name, self.v_min_col, postgresql_using='brin'))
@@ -264,7 +255,8 @@ class StoreBase:
         return num_excs
 
     def insert_rows(
-            self, exec_plan: ExecNode, conn: sql.engine.Connection, v_min: Optional[int] = None
+            self, exec_plan: ExecNode, conn: sql.engine.Connection, v_min: Optional[int] = None,
+            show_progress: bool = True
     ) -> Tuple[int, int, Set[int]]:
         """Insert rows into the store table and update the catalog table's md
         Returns:
@@ -293,15 +285,16 @@ class StoreBase:
                             self._create_table_row(row, row_builder, media_cols, cols_with_excs, v_min=v_min)
                         num_excs += num_row_exc
                         table_rows.append(table_row)
-                        if progress_bar is None:
-                            warnings.simplefilter("ignore", category=TqdmWarning)
-                            progress_bar = tqdm(
-                                desc=f'Inserting rows into `{self.tbl_version.name}`',
-                                unit=' rows',
-                                ncols=100,
-                                file=sys.stdout
-                            )
-                        progress_bar.update(1)
+                        if show_progress:
+                            if progress_bar is None:
+                                warnings.simplefilter("ignore", category=TqdmWarning)
+                                progress_bar = tqdm(
+                                    desc=f'Inserting rows into `{self.tbl_version.name}`',
+                                    unit=' rows',
+                                    ncols=100,
+                                    file=sys.stdout
+                                )
+                            progress_bar.update(1)
                     self._move_tmp_media_files(table_rows, media_cols, v_min)
                     conn.execute(sql.insert(self.sa_tbl), table_rows)
             if progress_bar is not None:

pixeltable/tool/create_test_db_dump.py

@@ -30,6 +30,8 @@ class Dumper:
         os.environ['PIXELTABLE_DB'] = db_name
         os.environ['PIXELTABLE_PGDATA'] = str(shared_home / 'pgdata')
 
+        Env._init_env(reinit_db=True)
+
         Env.get().configure_logging(level=logging.DEBUG, to_stdout=True)
 
     def dump_db(self) -> None:
@@ -162,6 +164,20 @@ class Dumper:
         # astype
         v['astype'] = t.c1.astype(pxt.FloatType())
 
+        # Add remotes
+        from pixeltable.datatransfer.remote import MockRemote
+        v.link(
+            MockRemote('remote', {'int_field': pxt.IntType()}, {'str_field': pxt.StringType()}),
+            col_mapping={'test_udf': 'int_field', 'c1': 'str_field'}
+        )
+        # We're just trying to test metadata here, so reach "under the covers" and link a fake
+        # Label Studio project without validation (so we don't need a real Label Studio server)
+        from pixeltable.datatransfer.label_studio import LabelStudioProject
+        v.tbl_version_path.tbl_version.link(
+            LabelStudioProject(4171780, media_import_method='file'),
+            col_mapping={'str_format': 'str_format'}
+        )
+
 
 @pxt.udf(_force_stored=True)
 def test_udf_stored(n: int) -> int:

pixeltable/type_system.py

@@ -7,7 +7,7 @@ import json
 import typing
 import urllib.parse
 import urllib.request
-from copy import copy
+from copy import deepcopy
 from pathlib import Path
 from typing import Any, Optional, Tuple, Dict, Callable, List, Union, Sequence, Mapping
 
@@ -82,7 +82,11 @@ class ColumnType:
 
     def __init__(self, t: Type, nullable: bool = False):
         self._type = t
-        self.nullable = nullable
+        self._nullable = nullable
+
+    @property
+    def nullable(self) -> bool:
+        return self._nullable
 
     @property
     def type_enum(self) -> Type:
@@ -91,6 +95,12 @@ class ColumnType:
     def serialize(self) -> str:
         return json.dumps(self.as_dict())
 
+    def copy(self, nullable: Optional[bool] = None) -> ColumnType:
+        result = deepcopy(self)
+        if nullable is not None:
+            result._nullable = nullable
+        return result
+
     @classmethod
     def serialize_list(cls, type_list: List[ColumnType]) -> str:
         return json.dumps([t.as_dict() for t in type_list])
@@ -177,7 +187,7 @@ class ColumnType:
         if type(self) != type(other):
             return False
         for member_var in vars(self).keys():
-            if member_var == 'nullable':
+            if member_var == '_nullable':
                 continue
             if getattr(self, member_var) != getattr(other, member_var):
                 return False
@@ -250,7 +260,7 @@ class ColumnType:
                 # We treat it as the underlying type but with nullable=True.
                 underlying = cls.from_python_type(union_args[0])
                 if underlying is not None:
-                    underlying.nullable = True
+                    underlying._nullable = True
                     return underlying
         else:
             # Discard type parameters to ensure that parameterized types such as `list[T]`

pixeltable/utils/coco.py

@@ -134,3 +134,97 @@ def write_coco_dataset(df: 'pixeltable.DataFrame', dest_path: Path) -> Path:
         json.dump(result, f)
     return output_path
 
+
+COCO_2017_CATEGORIES = {
+    0: 'N/A',
+    1: 'person',
+    2: 'bicycle',
+    3: 'car',
+    4: 'motorcycle',
+    5: 'airplane',
+    6: 'bus',
+    7: 'train',
+    8: 'truck',
+    9: 'boat',
+    10: 'traffic light',
+    11: 'fire hydrant',
+    12: 'N/A',
+    13: 'stop sign',
+    14: 'parking meter',
+    15: 'bench',
+    16: 'bird',
+    17: 'cat',
+    18: 'dog',
+    19: 'horse',
+    20: 'sheep',
+    21: 'cow',
+    22: 'elephant',
+    23: 'bear',
+    24: 'zebra',
+    25: 'giraffe',
+    26: 'N/A',
+    27: 'backpack',
+    28: 'umbrella',
+    29: 'N/A',
+    30: 'N/A',
+    31: 'handbag',
+    32: 'tie',
+    33: 'suitcase',
+    34: 'frisbee',
+    35: 'skis',
+    36: 'snowboard',
+    37: 'sports ball',
+    38: 'kite',
+    39: 'baseball bat',
+    40: 'baseball glove',
+    41: 'skateboard',
+    42: 'surfboard',
+    43: 'tennis racket',
+    44: 'bottle',
+    45: 'N/A',
+    46: 'wine glass',
+    47: 'cup',
+    48: 'fork',
+    49: 'knife',
+    50: 'spoon',
+    51: 'bowl',
+    52: 'banana',
+    53: 'apple',
+    54: 'sandwich',
+    55: 'orange',
+    56: 'broccoli',
+    57: 'carrot',
+    58: 'hot dog',
+    59: 'pizza',
+    60: 'donut',
+    61: 'cake',
+    62: 'chair',
+    63: 'couch',
+    64: 'potted plant',
+    65: 'bed',
+    66: 'N/A',
+    67: 'dining table',
+    68: 'N/A',
+    69: 'N/A',
+    70: 'toilet',
+    71: 'N/A',
+    72: 'tv',
+    73: 'laptop',
+    74: 'mouse',
+    75: 'remote',
+    76: 'keyboard',
+    77: 'cell phone',
+    78: 'microwave',
+    79: 'oven',
+    80: 'toaster',
+    81: 'sink',
+    82: 'refrigerator',
+    83: 'N/A',
+    84: 'book',
+    85: 'clock',
+    86: 'vase',
+    87: 'scissors',
+    88: 'teddy bear',
+    89: 'hair drier',
+    90: 'toothbrush'
+}

pixeltable-0.2.7.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.1
+Name: pixeltable
+Version: 0.2.7
+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: 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: jinja2 (>=3.1.3,<4.0.0)
+Requires-Dist: jmespath (>=1.0.1,<2.0.0)
+Requires-Dist: mistune (>=3.0.2,<4.0.0)
+Requires-Dist: more-itertools (>=10.2,<11.0)
+Requires-Dist: numpy (>=1.25)
+Requires-Dist: opencv-python-headless (>=4.7.0.68,<5.0.0.0)
+Requires-Dist: pandas (>=2.0,<3.0)
+Requires-Dist: pgserver (==0.1.3)
+Requires-Dist: pgvector (>=0.2.1,<0.3.0)
+Requires-Dist: pillow (>=9.3.0)
+Requires-Dist: psutil (>=5.9.5,<6.0.0)
+Requires-Dist: psycopg2-binary (>=2.9.5,<3.0.0)
+Requires-Dist: pymupdf (>=1.24.1,<2.0.0)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: setuptools (==69.1.1)
+Requires-Dist: sqlalchemy[mypy] (>=2.0.23,<3.0.0)
+Requires-Dist: tenacity (>=8.2,<9.0)
+Requires-Dist: tqdm (>=4.64)
+Description-Content-Type: text/markdown
+
+<div align="center">
+<img src="https://raw.githubusercontent.com/pixeltable/pixeltable/master/docs/release/pixeltable-banner.png" alt="Pixeltable" width="45%" />
+
+# Unifying Data, Models, and Orchestration for AI Products
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-darkblue.svg)](https://opensource.org/licenses/Apache-2.0)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pixeltable?logo=python&logoColor=white)
+  [![Platform Support](https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20Windows-8A2BE2)]()
+[![pytest status](https://github.com/pixeltable/pixeltable/actions/workflows/pytest.yml/badge.svg)](https://github.com/pixeltable/pixeltable/actions)
+[![PyPI Package](https://img.shields.io/pypi/v/pixeltable?color=darkorange)](https://pypi.org/project/pixeltable/)
+
+[Installation](https://pixeltable.github.io/pixeltable/getting-started/) | [Documentation](https://pixeltable.readme.io/) | [API Reference](https://pixeltable.github.io/pixeltable/) | [Code Samples](https://pixeltable.readme.io/recipes) | [Examples](https://github.com/pixeltable/pixeltable/tree/master/docs/release/tutorials)
+</div>
+
+Pixeltable is a Python library that lets AI engineers and data scientists focus on exploration, modeling, and app development without dealing with the customary data plumbing.
+
+## 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. With Pixeltable you can store, transform, index, and iterate on your data within the same table interface, whether it's text, images, embeddings, or even video. Built-in lineage and versioning ensure transparency and reproducibility, while the development-to-production mirror streamlines deployment.
+
+## 💾 Installation
+
+```python
+%pip install pixeltable
+```
+
+To verify that it's working:
+
+```python
+import pixeltable as pxt
+pxt.init()
+```
+> [!NOTE]
+> Check out the [Pixeltable Basics](https://pixeltable.readme.io/docs/pixeltable-basics) tutorial for a tour of its most important features.
+
+## 💡 Get Started
+Learn how to create tables, populate them with data, and enhance them with built-in or user-defined transformations and AI operations.
+
+| Topic      |                                                                                Notebook                                                                                |                                                                                API                                                                                |
+|:--------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------:|
+| Get Started    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/tutorials/pixeltable-basics.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a> |                 [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://pixeltable.github.io/pixeltable/api/pixeltable/)                 |
+| User-Defined Functions (UDFs)    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/howto/udfs-in-pixeltable.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a> |                 [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://pixeltable.github.io/pixeltable/api/iterators/document-splitter/)                 |
+| Comparing Object Detection Models | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/tutorials/object-detection-in-videos.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>            | [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://pixeltable.github.io/pixeltable/api-cheat-sheet/#frame-extraction-for-video-data) |
+| Experimenting with Chunking (RAG) | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/tutorials/rag-operations.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>            | [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://pixeltable.github.io/pixeltable/api/iterators/document-splitter/) |
+| Working with External Files    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/howto/working-with-external-files.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a> |                 [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://pixeltable.github.io/pixeltable/api-cheat-sheet/#inserting-data-into-a-table)                 |
+
+## ❓ FAQ
+
+### What does Pixeltable provide me with? Pixeltable provides:
+
+- Data storage and versioning
+- Combined Data and Model Lineage
+- Indexing (e.g. embedding vectors) and Data Retrieval
+- Orchestration of multimodal workloads
+- Incremental updates
+- Code is automatically production-ready
+
+### 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
+ 
+### What is Pixeltable not providing?
+
+- Pixeltable is not a low-code, prescriptive AI solution. We empower you to use the best frameworks and techniques for your specific needs.
+- We do not aim to replace your existing AI toolkit, but rather enhance it by streamlining the underlying data infrastructure and orchestration.
+
+> [!TIP]
+> Check out the [Integrations](https://pixeltable.readme.io/docs/working-with-openai) section, and feel free to submit a request for additional ones.
+
+## 📙 Example of 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.
+
+## 🐛 Contributions & Feedback
+
+Are you experiencing issues or bugs with Pixeltable? File an [Issue](https://github.com/pixeltable/pixeltable/issues).
+</br>Do you want to contribute? Feel free to open a [PR](https://github.com/pixeltable/pixeltable/pulls).
+
+## :classical_building: License
+
+This library is licensed under the Apache 2.0 License.
+