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

pixeltable/type_system.py

@@ -7,13 +7,12 @@ import json
 import typing
 import urllib.parse
 import urllib.request
-from copy import deepcopy
 from pathlib import Path
-from typing import Any, Optional, Tuple, Dict, Callable, List, Union, Sequence, Mapping
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, Union
 
-import PIL.Image
-import av
+import av  # type: ignore
 import numpy as np
+import PIL.Image
 import sqlalchemy as sql
 
 from pixeltable import exceptions as excs
@@ -39,10 +38,10 @@ class ColumnType:
 
         @classmethod
         def supertype(
-                cls, type1: 'Type', type2: 'Type',
+                cls, type1: 'ColumnType.Type', type2: 'ColumnType.Type',
                 # we need to pass this in because we can't easily append it as a class member
-                common_supertypes: Dict[Tuple['Type', 'Type'], 'Type']
-        ) -> Optional['Type']:
+                common_supertypes: Dict[Tuple['ColumnType.Type', 'ColumnType.Type'], 'ColumnType.Type']
+        ) -> Optional['ColumnType.Type']:
             if type1 == type2:
                 return type1
             t = common_supertypes.get((type1, type2))
@@ -74,7 +73,7 @@ class ColumnType:
 
     scalar_types = {Type.STRING, Type.INT, Type.FLOAT, Type.BOOL, Type.TIMESTAMP}
     numeric_types = {Type.INT, Type.FLOAT}
-    common_supertypes: Dict[Tuple[Type, Type], Type] = {
+    common_supertypes: dict[tuple[Type, Type], Type] = {
         (Type.BOOL, Type.INT): Type.INT,
         (Type.BOOL, Type.FLOAT): Type.FLOAT,
         (Type.INT, Type.FLOAT): Type.FLOAT,
@@ -95,11 +94,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
+    def copy(self, nullable: bool) -> ColumnType:
+        # Default implementation calls unary initializer
+        if nullable == self.nullable:
+            return self
+        else:
+            return self.__class__(nullable=nullable)
 
     @classmethod
     def serialize_list(cls, type_list: List[ColumnType]) -> str:
@@ -136,7 +136,7 @@ class ColumnType:
         Default implementation: simply invoke c'tor
         """
         assert 'nullable' in d
-        return cls(nullable=d['nullable'])
+        return cls(nullable=d['nullable'])  # type: ignore[call-arg]
 
     @classmethod
     def make_type(cls, t: Type) -> ColumnType:
@@ -166,91 +166,89 @@ class ColumnType:
         return self._type.name.lower()
 
     def __eq__(self, other: object) -> bool:
-        return self.matches(other) and self.nullable == other.nullable
-
-    def is_supertype_of(self, other: ColumnType) -> bool:
-        if type(self) != type(other):
-            return False
-        if self.matches(other):
-            return True
-        return self._is_supertype_of(other)
+        return isinstance(other, ColumnType) and self.matches(other) and self.nullable == other.nullable
 
-    @abc.abstractmethod
-    def _is_supertype_of(self, other: ColumnType) -> bool:
-        return False
+    def is_supertype_of(self, other: ColumnType, ignore_nullable: bool = False) -> bool:
+        if ignore_nullable:
+            supertype = self.supertype(other)
+            if supertype is None:
+                return False
+            return supertype.matches(self)
+        else:
+            return self.supertype(other) == self
 
-    def matches(self, other: object) -> bool:
+    def matches(self, other: ColumnType) -> bool:
         """Two types match if they're equal, aside from nullability"""
-        if not isinstance(other, ColumnType):
-            pass
-        assert isinstance(other, ColumnType), type(other)
-        if type(self) != type(other):
-            return False
-        for member_var in vars(self).keys():
-            if member_var == '_nullable':
-                continue
-            if getattr(self, member_var) != getattr(other, member_var):
-                return False
-        return True
+        # Default: just compare base types (this works for all types whose only parameter is nullable)
+        return self._type == other._type
 
-    @classmethod
-    def supertype(cls, type1: ColumnType, type2: ColumnType) -> Optional[ColumnType]:
-        if type1 == type2:
-            return type1
+    def supertype(self, other: ColumnType) -> Optional[ColumnType]:
+        if self == other:
+            return self
+        if self.matches(other):
+            return self.copy(nullable=(self.nullable or other.nullable))
 
-        if type1.is_invalid_type():
-            return type2
-        if type2.is_invalid_type():
-            return type1
+        if self.is_invalid_type():
+            return other
+        if other.is_invalid_type():
+            return self
 
-        if type1.is_scalar_type() and type2.is_scalar_type():
-            t = cls.Type.supertype(type1._type, type2._type, cls.common_supertypes)
+        if self.is_scalar_type() and other.is_scalar_type():
+            t = self.Type.supertype(self._type, other._type, self.common_supertypes)
             if t is not None:
-                return cls.make_type(t).copy(nullable=(type1.nullable or type2.nullable))
+                return self.make_type(t).copy(nullable=(self.nullable or other.nullable))
             return None
 
-        if type1._type == type2._type:
-            return cls._supertype(type1, type2)
-
         return None
 
     @classmethod
-    @abc.abstractmethod
-    def _supertype(cls, type1: ColumnType, type2: ColumnType) -> Optional[ColumnType]:
-        """
-        Class-specific implementation of determining the supertype. type1 and type2 are from the same subclass of
-        ColumnType.
-        """
-        pass
-
-    @classmethod
-    def infer_literal_type(cls, val: Any) -> Optional[ColumnType]:
+    def infer_literal_type(cls, val: Any, nullable: bool = False) -> Optional[ColumnType]:
         if isinstance(val, str):
-            return StringType()
+            return StringType(nullable=nullable)
         if isinstance(val, bool):
             # We have to check bool before int, because isinstance(b, int) is True if b is a Python bool
-            return BoolType()
+            return BoolType(nullable=nullable)
         if isinstance(val, int):
-            return IntType()
+            return IntType(nullable=nullable)
         if isinstance(val, float):
-            return FloatType()
+            return FloatType(nullable=nullable)
         if isinstance(val, datetime.datetime):
-            return TimestampType()
+            return TimestampType(nullable=nullable)
         if isinstance(val, PIL.Image.Image):
-            return ImageType(width=val.width, height=val.height, mode=val.mode)
+            return ImageType(width=val.width, height=val.height, mode=val.mode, nullable=nullable)
         if isinstance(val, np.ndarray):
-            col_type = ArrayType.from_literal(val)
+            col_type = ArrayType.from_literal(val, nullable=nullable)
             if col_type is not None:
                 return col_type
             # this could still be json-serializable
         if isinstance(val, dict) or isinstance(val, list) or isinstance(val, np.ndarray):
             try:
                 JsonType().validate_literal(val)
-                return JsonType()
+                return JsonType(nullable=nullable)
             except TypeError:
                 return None
         return None
 
+    @classmethod
+    def infer_common_literal_type(cls, vals: Iterable[Any]) -> Optional[ColumnType]:
+        """
+        Returns the most specific type that is a supertype of all literals in `vals`. If no such type
+        exists, returns None.
+
+        Args:
+            vals: A collection of literals.
+        """
+        inferred_type: Optional[ColumnType] = None
+        for val in vals:
+            val_type = cls.infer_literal_type(val)
+            if inferred_type is None:
+                inferred_type = val_type
+            else:
+                inferred_type = inferred_type.supertype(val_type)
+                if inferred_type is None:
+                    return None
+        return inferred_type
+
     @classmethod
     def from_python_type(cls, t: type) -> Optional[ColumnType]:
         if typing.get_origin(t) is typing.Union:
@@ -317,10 +315,8 @@ class ColumnType:
     @abc.abstractmethod
     def _validate_literal(self, val: Any) -> None:
         """Raise TypeError if val is not a valid literal for this type"""
-        pass
 
-    @abc.abstractmethod
-    def _create_literal(self, val : Any) -> Any:
+    def _create_literal(self, val: Any) -> Any:
         """Create a literal of this type from val, including any needed conversions.
              val is guaranteed to be non-None"""
         return val
@@ -389,21 +385,6 @@ class ColumnType:
         """
         pass
 
-    @staticmethod
-    def no_conversion(v: Any) -> Any:
-        """
-        Special return value of conversion_fn() that indicates that no conversion is necessary.
-        Should not be called
-        """
-        assert False
-
-    def conversion_fn(self, target: ColumnType) -> Optional[Callable[[Any], Any]]:
-        """
-        Return Callable that converts a column value of type self to a value of type 'target'.
-        Returns None if conversion isn't possible.
-        """
-        return None
-
 
 class InvalidType(ColumnType):
     def __init__(self, nullable: bool = False):
@@ -423,17 +404,6 @@ class StringType(ColumnType):
     def __init__(self, nullable: bool = False):
         super().__init__(self.Type.STRING, nullable=nullable)
 
-    def conversion_fn(self, target: ColumnType) -> Optional[Callable[[Any], Any]]:
-        if not target.is_timestamp_type():
-            return None
-        def convert(val: str) -> Optional[datetime.datetime]:
-            try:
-                dt = datetime.datetime.fromisoformat(val)
-                return dt
-            except ValueError:
-                return None
-        return convert
-
     def to_sa_type(self) -> sql.types.TypeEngine:
         return sql.String()
 
@@ -522,6 +492,37 @@ class JsonType(ColumnType):
         super().__init__(self.Type.JSON, nullable=nullable)
         self.type_spec = type_spec
 
+    def copy(self, nullable: bool) -> ColumnType:
+        return JsonType(self.type_spec, nullable=nullable)
+
+    def matches(self, other: ColumnType) -> bool:
+        return other._type == self.Type.JSON and self.type_spec == other.type_spec
+
+    def supertype(self, other: ColumnType) -> Optional[JsonType]:
+        if not isinstance(other, JsonType):
+            return None
+        if self.type_spec is None:
+            # we don't have a type spec and can accept anything accepted by other
+            return JsonType(nullable=(self.nullable or other.nullable))
+        if other.type_spec is None:
+            # we have a type spec but other doesn't
+            return JsonType(nullable=(self.nullable or other.nullable))
+
+        # we both have type specs; the supertype's type spec is the union of the two
+        type_spec: dict[str, ColumnType] = {}
+        type_spec.update(self.type_spec)
+        for other_field_name, other_field_type in other.type_spec.items():
+            if other_field_name not in type_spec:
+                type_spec[other_field_name] = other_field_type
+            else:
+                # both type specs have this field
+                field_type = type_spec[other_field_name].supertype(other_field_type)
+                if field_type is None:
+                    # conflicting types
+                    return JsonType(nullable=(self.nullable or other.nullable))
+                type_spec[other_field_name] = field_type
+        return JsonType(type_spec, nullable=(self.nullable or other.nullable))
+
     def _as_dict(self) -> Dict:
         result = super()._as_dict()
         if self.type_spec is not None:
@@ -551,11 +552,20 @@ class JsonType(ColumnType):
 
     def _validate_literal(self, val: Any) -> None:
         if not isinstance(val, dict) and not isinstance(val, list):
+            # TODO In the future we should accept scalars too, which would enable us to remove this top-level check
             raise TypeError(f'Expected dict or list, got {val.__class__.__name__}')
-        try:
-            _ = json.dumps(val)
-        except TypeError as e:
-            raise TypeError(f'Expected JSON-serializable object, got {val}')
+        if not self.__is_valid_literal(val):
+            raise TypeError(f'That literal is not a valid Pixeltable JSON object: {val}')
+
+    @classmethod
+    def __is_valid_literal(cls, val: Any) -> None:
+        if val is None or isinstance(val, (str, int, float, bool)):
+            return True
+        if isinstance(val, (list, tuple)):
+            return all(cls.__is_valid_literal(v) for v in val)
+        if isinstance(val, dict):
+            return all(isinstance(k, str) and cls.__is_valid_literal(v) for k, v in val.items())
+        return False
 
     def _create_literal(self, val: Any) -> Any:
         if isinstance(val, tuple):
@@ -564,21 +574,29 @@ class JsonType(ColumnType):
 
 
 class ArrayType(ColumnType):
-    def __init__(
-            self, shape: Tuple[Union[int, None], ...], dtype: ColumnType, nullable: bool = False):
+    def __init__(self, shape: tuple[Union[int, None], ...], dtype: ColumnType, nullable: bool = False):
         super().__init__(self.Type.ARRAY, nullable=nullable)
         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
 
-    def _supertype(cls, type1: ArrayType, type2: ArrayType) -> Optional[ArrayType]:
-        if len(type1.shape) != len(type2.shape):
+    def copy(self, nullable: bool) -> ColumnType:
+        return ArrayType(self.shape, self.pxt_dtype, nullable=nullable)
+
+    def matches(self, other: ColumnType) -> bool:
+        return other._type == self.Type.ARRAY and self.shape == other.shape and self.dtype == other.dtype
+
+    def supertype(self, other: ColumnType) -> Optional[ArrayType]:
+        if not isinstance(other, ArrayType):
             return None
-        base_type = ColumnType.supertype(type1.dtype, type2.dtype)
+        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(type1.shape, type2.shape)]
-        return ArrayType(tuple(shape), base_type, nullable=(type1.nullable or type2.nullable))
+        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))
 
     def _as_dict(self) -> Dict:
         result = super()._as_dict()
@@ -597,11 +615,11 @@ class ArrayType(ColumnType):
         return cls(shape, dtype, nullable=d['nullable'])
 
     @classmethod
-    def from_literal(cls, val: np.ndarray) -> Optional[ArrayType]:
+    def from_literal(cls, val: np.ndarray, nullable: bool = False) -> Optional[ArrayType]:
         # determine our dtype
         assert isinstance(val, np.ndarray)
         if np.issubdtype(val.dtype, np.integer):
-            dtype = IntType()
+            dtype: ColumnType = IntType()
         elif np.issubdtype(val.dtype, np.floating):
             dtype = FloatType()
         elif val.dtype == np.bool_:
@@ -610,7 +628,7 @@ class ArrayType(ColumnType):
             dtype = StringType()
         else:
             return None
-        return cls(val.shape, dtype=dtype)
+        return cls(val.shape, dtype=dtype, nullable=nullable)
 
     def is_valid_literal(self, val: np.ndarray) -> bool:
         if not isinstance(val, np.ndarray):
@@ -677,6 +695,9 @@ class ImageType(ColumnType):
             self.height = height
         self.mode = mode
 
+    def copy(self, nullable: bool) -> ColumnType:
+        return ImageType(self.width, self.height, mode=self.mode, nullable=nullable)
+
     def __str__(self) -> str:
         if self.width is not None or self.height is not None or self.mode is not None:
             params_str = ''
@@ -695,13 +716,21 @@ class ImageType(ColumnType):
             params_str = ''
         return f'{self._type.name.lower()}{params_str}'
 
-    def _is_supertype_of(self, other: ImageType) -> bool:
-        if self.mode is not None and self.mode != other.mode:
-            return False
-        if self.width is None and self.height is None:
-            return True
-        if self.width != other.width and self.height != other.height:
-            return False
+    def matches(self, other: ColumnType) -> bool:
+        return (
+            other._type == self.Type.IMAGE
+            and self.width == other.width
+            and self.height == other.height
+            and self.mode == other.mode
+        )
+
+    def supertype(self, other: ColumnType) -> Optional[ImageType]:
+        if not isinstance(other, ImageType):
+            return None
+        width = self.width if self.width == other.width else None
+        height = self.height if self.height == other.height else None
+        mode = self.mode if self.mode == other.mode else None
+        return ImageType(width=width, height=height, mode=mode, nullable=(self.nullable or other.nullable))
 
     @property
     def size(self) -> Optional[Tuple[int, int]]:
@@ -709,10 +738,6 @@ class ImageType(ColumnType):
             return None
         return (self.width, self.height)
 
-    @property
-    def num_channels(self) -> Optional[int]:
-        return None if self.mode is None else self.mode.num_channels()
-
     def _as_dict(self) -> Dict:
         result = super()._as_dict()
         result.update(width=self.width, height=self.height, mode=self.mode)
@@ -725,26 +750,6 @@ class ImageType(ColumnType):
         assert 'mode' in d
         return cls(width=d['width'], height=d['height'], mode=d['mode'], nullable=d['nullable'])
 
-    def conversion_fn(self, target: ColumnType) -> Optional[Callable[[Any], Any]]:
-        if not target.is_image_type():
-            return None
-        assert isinstance(target, ImageType)
-        if (target.width is None) != (target.height is None):
-            # we can't resize only one dimension
-            return None
-        if (target.width == self.width or target.width is None) \
-            and (target.height == self.height or target.height is None) \
-            and (target.mode == self.mode or target.mode is None):
-            # nothing to do
-            return self.no_conversion
-        def convert(img: PIL.Image.Image) -> PIL.Image.Image:
-            if self.width != target.width or self.height != target.height:
-                img = img.resize((target.width, target.height))
-            if self.mode != target.mode:
-                img = img.convert(target.mode.to_pil())
-            return img
-        return convert
-
     def to_sa_type(self) -> sql.types.TypeEngine:
         return sql.String()
 
@@ -829,6 +834,7 @@ class DocumentType(ColumnType):
 
     def __init__(self, nullable: bool = False, doc_formats: Optional[str] = None):
         super().__init__(self.Type.DOCUMENT, nullable=nullable)
+        self.doc_formats = doc_formats
         if doc_formats is not None:
             type_strs = doc_formats.split(',')
             for type_str in type_strs:
@@ -838,6 +844,12 @@ class DocumentType(ColumnType):
         else:
             self._doc_formats = [t for t in self.DocumentFormat]
 
+    def copy(self, nullable: bool) -> ColumnType:
+        return DocumentType(doc_formats=self.doc_formats, nullable=nullable)
+
+    def matches(self, other: ColumnType) -> bool:
+        return other._type == self.Type.DOCUMENT and self._doc_formats == other._doc_formats
+
     def to_sa_type(self) -> sql.types.TypeEngine:
         # stored as a file path
         return sql.String()

pixeltable/utils/pytorch.py

@@ -1,16 +1,18 @@
+import datetime
 import io
+import json
+from pathlib import Path
+from typing import Any, Dict, Iterator
+
+import numpy as np
+import PIL.Image
 import pyarrow as pa
-import pyarrow.parquet
 import torch
 import torch.utils.data
-from pathlib import Path
-import PIL.Image
-import json
-from typing import Dict, Iterator, Any
-import datetime
+from pyarrow import parquet
 
 from pixeltable.type_system import ColumnType
-import numpy as np
+
 
 class PixeltablePytorchDataset(torch.utils.data.IterableDataset):
     """
@@ -39,7 +41,7 @@ class PixeltablePytorchDataset(torch.utils.data.IterableDataset):
         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 = pa.parquet.ParquetDataset(path).files
+        self.part_metadata = parquet.ParquetDataset(path).files
 
     def _unmarshall(self, k: str, v: Any) -> Any:
         if self.column_types[k].is_image_type():
@@ -52,7 +54,7 @@ class PixeltablePytorchDataset(torch.utils.data.IterableDataset):
                 return arr
 
             assert self.image_format == "pt"
-            import torchvision  # pylint: disable = import-outside-toplevel
+            import torchvision
 
             # use arr instead of im in ToTensor() to guarantee array input
             # to torch.from_numpy is writable. Using im is a suspected cause of
@@ -85,7 +87,7 @@ class PixeltablePytorchDataset(torch.utils.data.IterableDataset):
             part_list = [ i for i in part_list if (i % worker_info.num_workers) == worker_info.id ]
 
         for part_no in part_list:
-            pqf = pa.parquet.ParquetFile(self.part_metadata[part_no])
+            pqf = parquet.ParquetFile(self.part_metadata[part_no])
             for batch in pqf.iter_batches():
                 for tup in arrow.iter_tuples(batch):
                     yield {k: self._unmarshall(k, v) for k, v in tup.items()}

{pixeltable-0.2.14.dist-info → pixeltable-0.2.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixeltable
-Version: 0.2.14
+Version: 0.2.16
 Summary: Pixeltable: The Multimodal AI Data Plane
 Author: Pixeltable, Inc.
 Author-email: contact@pixeltable.com
@@ -21,11 +21,11 @@ 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.4)
 Requires-Dist: pgvector (>=0.2.1,<0.3.0)
 Requires-Dist: pillow (>=9.3.0)
+Requires-Dist: pixeltable-pgserver (==0.2.7)
 Requires-Dist: psutil (>=5.9.5,<6.0.0)
-Requires-Dist: psycopg2-binary (>=2.9.5,<3.0.0)
+Requires-Dist: psycopg[binary] (==3.1.18)
 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)
@@ -36,7 +36,7 @@ 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%" />
+<img src="https://raw.githubusercontent.com/pixeltable/pixeltable/main/docs/release/pixeltable-banner.png" alt="Pixeltable" width="45%" />
 
 # Unifying Data, Models, and Orchestration for AI Products
 
@@ -46,7 +46,7 @@ Description-Content-Type: text/markdown
 [![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)
+[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/release/docs/release/tutorials)
 </div>
 
 Pixeltable is a Python library that lets ML Engineers and Data Scientists focus on exploration, modeling, and app development without dealing with the customary data plumbing.
@@ -68,10 +68,10 @@ Learn how to create tables, populate them with data, and enhance them with built
 
 | Topic | Notebook | Topic | Notebook |
 |:----------|:-----------------|:-------------------------|:---------------------------------:|
-| 10-Minute Tour of Pixeltable    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/tutorials/pixeltable-basics.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a> | Tables and Data Operations    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/fundamentals/tables-and-data-operations.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
-| 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> | 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>
-| 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"/> | 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>
-| Integrating with Label Studio    | <a target="_blank" href="https://pixeltable.readme.io/docs/label-studio"> <img src="https://img.shields.io/badge/Docs-Label Studio-blue" alt="Visit our documentation"/></a> | Audio/Video Transcript Indexing    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/tutorials/audio-transcriptions.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+| 10-Minute Tour of Pixeltable    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/release/docs/release/tutorials/pixeltable-basics.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a> | Tables and Data Operations    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/release/docs/release/fundamentals/tables-and-data-operations.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+| User-Defined Functions (UDFs)    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/release/docs/release/howto/udfs-in-pixeltable.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a> | Object Detection Models | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/release/docs/release/tutorials/object-detection-in-videos.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+| Experimenting with Chunking (RAG) | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/release/docs/release/tutorials/rag-operations.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> | Working with External Files    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/release/docs/release/howto/working-with-external-files.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+| Integrating with Label Studio    | <a target="_blank" href="https://pixeltable.readme.io/docs/label-studio"> <img src="https://img.shields.io/badge/Docs-Label Studio-blue" alt="Visit our documentation"/></a> | Audio/Video Transcript Indexing    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/release/docs/release/tutorials/audio-transcriptions.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
 
 ## 🧱 Code Samples
 
@@ -186,7 +186,7 @@ Pixeltable unifies data storage, versioning, and indexing with orchestration and
 - **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.