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

pixeltable/exprs/literal.py

@@ -50,6 +50,9 @@ class Literal(Expr):
             assert isinstance(self.val, datetime.datetime)
             default_tz = Env.get().default_time_zone
             return f"'{self.val.astimezone(default_tz).isoformat()}'"
+        if self.col_type.is_date_type():
+            assert isinstance(self.val, datetime.date)
+            return f"'{self.val.isoformat()}'"
         if self.col_type.is_array_type():
             assert isinstance(self.val, np.ndarray)
             return str(self.val.tolist())
@@ -82,6 +85,10 @@ class Literal(Expr):
             # stored as UTC in the database)
             encoded_val = self.val.isoformat()
             return {'val': encoded_val, 'val_t': self.col_type._type.name, **super()._as_dict()}
+        elif self.col_type.is_date_type():
+            assert isinstance(self.val, datetime.date)
+            encoded_val = self.val.isoformat()
+            return {'val': encoded_val, 'val_t': self.col_type._type.name, **super()._as_dict()}
         elif self.col_type.is_array_type():
             assert isinstance(self.val, np.ndarray)
             return {'val': self.val.tolist(), 'val_t': self.col_type._type.name, **super()._as_dict()}
@@ -96,7 +103,10 @@ class Literal(Expr):
         assert 'val' in d
         if 'val_t' in d:
             val_t = d['val_t']
-            if val_t == ts.ColumnType.Type.TIMESTAMP.name:
+            if val_t == ts.ColumnType.Type.DATE.name:
+                dt = datetime.date.fromisoformat(d['val'])
+                return cls(dt)
+            elif val_t == ts.ColumnType.Type.TIMESTAMP.name:
                 dt = datetime.datetime.fromisoformat(d['val'])
                 assert dt.tzinfo == datetime.timezone.utc  # Must be UTC in the database
                 return cls(dt)

pixeltable/exprs/rowid_ref.py

@@ -30,7 +30,7 @@ class RowidRef(Expr):
 
     def __init__(
         self,
-        tbl: catalog.TableVersionHandle,
+        tbl: Optional[catalog.TableVersionHandle],
         idx: int,
         tbl_id: Optional[UUID] = None,
         normalized_base_id: Optional[UUID] = None,
@@ -98,6 +98,9 @@ class RowidRef(Expr):
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         tbl = self.tbl.get() if self.tbl is not None else catalog.Catalog.get().get_tbl_version(self.tbl_id, None)
         rowid_cols = tbl.store_tbl.rowid_columns()
+        assert self.rowid_component_idx <= len(rowid_cols), (
+            f'{self.rowid_component_idx} not consistent with {rowid_cols}'
+        )
         return rowid_cols[self.rowid_component_idx]
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:

pixeltable/exprs/similarity_expr.py

@@ -26,7 +26,7 @@ class SimilarityExpr(Expr):
         from pixeltable import index
 
         # determine index to use
-        idx_dict = ColumnRef.find_embedding_index(col_ref.col, idx_name, 'similarity')
+        idx_dict = col_ref.find_embedding_index(idx_name, 'similarity')
         assert len(idx_dict) == 1
         self.idx_info = next(iter(idx_dict.values()))
         idx = self.idx_info.idx

pixeltable/func/function.py

@@ -514,7 +514,7 @@ class InvalidFunction(Function):
     def _as_dict(self) -> dict:
         """
         Here we write out (verbatim) the original metadata that failed to load (and that resulted in the
-        InvalidFunction). Note that the InvalidFunction itself is never serlialized, so there is no corresponding
+        InvalidFunction). Note that the InvalidFunction itself is never serialized, so there is no corresponding
         from_dict() method.
         """
         return self.fn_dict

pixeltable/functions/__init__.py

@@ -6,6 +6,7 @@ from . import (
     anthropic,
     audio,
     bedrock,
+    date,
     deepseek,
     fireworks,
     gemini,

pixeltable/functions/date.py

@@ -0,0 +1,185 @@
+"""
+Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs) for `DateType`.
+
+Usage example:
+```python
+import pixeltable as pxt
+
+t = pxt.get_table(...)
+t.select(t.date_col.year, t.date_col.weekday()).collect()
+```
+"""
+
+from datetime import date, timedelta
+
+import sqlalchemy as sql
+
+import pixeltable as pxt
+from pixeltable.utils.code import local_public_names
+
+_SQL_ZERO = sql.literal(0)
+
+# NOT YET SUPPORTED date +/- integer
+# NOT YET SUPPORTED date1 - date2 -> integer
+# NOT YET SUPPORTED timestamp(date)
+# NOT YET SUPPORTED date(timestamp)
+
+
+@pxt.udf(is_property=True)
+def year(self: date) -> int:
+    """
+    Between [`MINYEAR`](https://docs.python.org/3/library/datetime.html#datetime.MINYEAR) and
+    [`MAXYEAR`](https://docs.python.org/3/library/datetime.html#datetime.MAXYEAR) inclusive.
+
+    Equivalent to [`date.year`](https://docs.python.org/3/library/datetime.html#datetime.date.year).
+    """
+    return self.year
+
+
+@year.to_sql
+def _(self: sql.ColumnElement) -> sql.ColumnElement:
+    return sql.extract('year', self)
+
+
+@pxt.udf(is_property=True)
+def month(self: date) -> int:
+    """
+    Between 1 and 12 inclusive.
+
+    Equivalent to [`date.month`](https://docs.python.org/3/library/datetime.html#datetime.date.month).
+    """
+    return self.month
+
+
+@month.to_sql
+def _(self: sql.ColumnElement) -> sql.ColumnElement:
+    return sql.extract('month', self)
+
+
+@pxt.udf(is_property=True)
+def day(self: date) -> int:
+    """
+    Between 1 and the number of days in the given month of the given year.
+
+    Equivalent to [`date.day`](https://docs.python.org/3/library/datetime.html#datetime.date.day).
+    """
+    return self.day
+
+
+@day.to_sql
+def _(self: sql.ColumnElement) -> sql.ColumnElement:
+    return sql.extract('day', self)
+
+
+@pxt.udf(is_method=True)
+def make_date(year: int, month: int, day: int) -> date:
+    """
+    Create a date.
+
+    Equivalent to [`datetime()`](https://docs.python.org/3/library/datetime.html#datetime.date).
+    """
+    return date(year, month, day)
+
+
+@make_date.to_sql
+def _(year: sql.ColumnElement, month: sql.ColumnElement, day: sql.ColumnElement) -> sql.ColumnElement:
+    return sql.func.make_date(sql.cast(year, sql.Integer), sql.cast(month, sql.Integer), sql.cast(day, sql.Integer))
+
+
+@pxt.udf(is_method=True)
+def weekday(self: date) -> int:
+    """
+    Between 0 (Monday) and 6 (Sunday) inclusive.
+
+    Equivalent to [`date.weekday()`](https://docs.python.org/3/library/datetime.html#datetime.date.weekday).
+    """
+    return self.weekday()
+
+
+@weekday.to_sql
+def _(self: sql.ColumnElement) -> sql.ColumnElement:
+    return sql.extract('isodow', self) - 1
+
+
+@pxt.udf(is_method=True)
+def isoweekday(self: date) -> int:
+    """
+    Return the day of the week as an integer, where Monday is 1 and Sunday is 7.
+
+    Equivalent to [`date.isoweekday()`](https://docs.python.org/3/library/datetime.html#datetime.date.isoweekday).
+    """
+    return self.isoweekday()
+
+
+@isoweekday.to_sql
+def _(self: sql.ColumnElement) -> sql.ColumnElement:
+    return sql.extract('isodow', self)
+
+
+@pxt.udf(is_method=True)
+def isocalendar(self: date) -> dict:
+    """
+    Return a dictionary with three entries: `'year'`, `'week'`, and `'weekday'`.
+
+    Equivalent to
+    [`date.isocalendar()`](https://docs.python.org/3/library/datetime.html#datetime.date.isocalendar).
+    """
+    iso_year, iso_week, iso_weekday = self.isocalendar()
+    return {'year': iso_year, 'week': iso_week, 'weekday': iso_weekday}
+
+
+@pxt.udf(is_method=True)
+def isoformat(self: date, sep: str = 'T', timespec: str = 'auto') -> str:
+    """
+    Return a string representing the date and time in ISO 8601 format.
+
+    Equivalent to [`date.isoformat()`](https://docs.python.org/3/library/datetime.html#datetime.date.isoformat).
+
+    Args:
+        sep: Separator between date and time.
+        timespec: The number of additional terms in the output. See the
+            [`date.isoformat()`](https://docs.python.org/3/library/datetime.html#datetime.date.isoformat)
+            documentation for more details.
+    """
+    return self.isoformat()
+
+
+@pxt.udf(is_method=True)
+def toordinal(self: date) -> int:
+    """
+    Return the proleptic Gregorian ordinal of the date, where January 1 of year 1 has ordinal 1.
+
+    Equivalent to [`date.toordinal()`](https://docs.python.org/3/library/datetime.html#datetime.date.toordinal).
+    """
+    return self.toordinal()
+
+
+@pxt.udf(is_method=True)
+def strftime(self: date, format: str) -> str:
+    """
+    Return a string representing the date and time, controlled by an explicit format string.
+
+    Equivalent to [`date.strftime()`](https://docs.python.org/3/library/datetime.html#datetime.date.strftime).
+
+    Args:
+        format: The format string to control the output. For a complete list of formatting directives, see
+            [`strftime()` and `strptime()` Behavior](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior).
+    """
+    return self.strftime(format)
+
+
+@pxt.udf(is_method=True)
+def add_days(self: date, n: int) -> date:
+    """
+    Add `n` days to the date.
+
+    Equivalent to [`date + timedelta(days=n)`](https://docs.python.org/3/library/datetime.html#datetime.timedelta).
+    """
+    return self + timedelta(days=n)
+
+
+__all__ = local_public_names(__name__)
+
+
+def __dir__() -> list[str]:
+    return __all__

pixeltable/functions/gemini.py

@@ -1,32 +1,35 @@
 """
 Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs)
 that wrap various endpoints from the Google Gemini API. In order to use them, you must
-first `pip install google-generativeai` and configure your Gemini credentials, as described in
+first `pip install google-genai` and configure your Gemini credentials, as described in
 the [Working with Gemini](https://pixeltable.readme.io/docs/working-with-gemini) tutorial.
 """
 
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 import pixeltable as pxt
 from pixeltable import env
 
+if TYPE_CHECKING:
+    from google import genai
+
 
 @env.register_client('gemini')
-def _(api_key: str) -> None:
-    import google.generativeai as genai
+def _(api_key: str) -> 'genai.client.Client':
+    from google import genai
 
-    genai.configure(api_key=api_key)
+    return genai.client.Client(api_key=api_key)
 
 
-def _ensure_loaded() -> None:
-    env.Env.get().get_client('gemini')
+def _genai_client() -> 'genai.client.Client':
+    return env.Env.get().get_client('gemini')
 
 
 @pxt.udf(resource_pool='request-rate:gemini')
 async def generate_content(
     contents: str,
     *,
-    model_name: str,
+    model: str,
     candidate_count: Optional[int] = None,
     stop_sequences: Optional[list[str]] = None,
     max_output_tokens: Optional[int] = None,
@@ -48,11 +51,11 @@ async def generate_content(
 
     __Requirements:__
 
-    - `pip install google-generativeai`
+    - `pip install google-genai`
 
     Args:
         contents: The input content to generate from.
-        model_name: The name of the model to use.
+        model: The name of the model to use.
 
     For details on the other parameters, see: <https://ai.google.dev/gemini-api/docs>
 
@@ -63,14 +66,12 @@ async def generate_content(
         Add a computed column that applies the model `gemini-1.5-flash`
         to an existing Pixeltable column `tbl.prompt` of the table `tbl`:
 
-        >>> tbl.add_computed_column(response=generate_content(tbl.prompt, model_name='gemini-1.5-flash'))
+        >>> tbl.add_computed_column(response=generate_content(tbl.prompt, model='gemini-1.5-flash'))
     """
-    env.Env.get().require_package('google.generativeai')
-    _ensure_loaded()
-    import google.generativeai as genai
+    env.Env.get().require_package('google.genai')
+    from google.genai import types
 
-    model = genai.GenerativeModel(model_name=model_name)
-    gc = genai.GenerationConfig(
+    config = types.GenerateContentConfig(
         candidate_count=candidate_count,
         stop_sequences=stop_sequences,
         max_output_tokens=max_output_tokens,
@@ -82,10 +83,11 @@ async def generate_content(
         presence_penalty=presence_penalty,
         frequency_penalty=frequency_penalty,
     )
-    response = await model.generate_content_async(contents, generation_config=gc)
-    return response.to_dict()
+
+    response = await _genai_client().aio.models.generate_content(model=model, contents=contents, config=config)
+    return response.model_dump()
 
 
 @generate_content.resource_pool
-def _(model_name: str) -> str:
-    return f'request-rate:gemini:{model_name}'
+def _(model: str) -> str:
+    return f'request-rate:gemini:{model}'

pixeltable/functions/globals.py

@@ -49,22 +49,7 @@ def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
     allows_window=True,
     # Allow counting non-null values of any type
     # TODO: should we have an "Any" type that can be used here?
-    type_substitutions=tuple(
-        {T: Optional[t]}  # type: ignore[misc]
-        for t in (
-            ts.String,
-            ts.Int,
-            ts.Float,
-            ts.Bool,
-            ts.Timestamp,
-            ts.Array,
-            ts.Json,
-            ts.Image,
-            ts.Video,
-            ts.Audio,
-            ts.Document,
-        )
-    ),
+    type_substitutions=tuple({T: Optional[t]} for t in ts.ALL_PIXELTABLE_TYPES),  # type: ignore[misc]
 )
 class count(func.Aggregator, typing.Generic[T]):
     def __init__(self) -> None:

pixeltable/functions/json.py

@@ -4,9 +4,10 @@ Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs)
 Example:
 ```python
 import pixeltable as pxt
+import pixeltable.functions as pxtf
 
 t = pxt.get_table(...)
-t.select(pxt.functions.json.make_list()).collect()
+t.select(pxtf.json.make_list(t.json_col)).collect()
 ```
 """
 

pixeltable/functions/math.py

@@ -1,3 +1,15 @@
+"""
+Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs) for mathematical operations.
+
+Example:
+```python
+import pixeltable as pxt
+
+t = pxt.get_table(...)
+t.select(t.float_col.floor()).collect()
+```
+"""
+
 import builtins
 import math
 from typing import Optional
@@ -10,6 +22,11 @@ from pixeltable.utils.code import local_public_names
 
 @pxt.udf(is_method=True)
 def abs(self: float) -> float:
+    """
+    Return the absolute value of the given number.
+
+    Equivalent to Python [`builtins.abs()`](https://docs.python.org/3/library/functions.html#abs).
+    """
     return builtins.abs(self)
 
 
@@ -20,6 +37,14 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
 
 @pxt.udf(is_method=True)
 def ceil(self: float) -> float:
+    """
+    Return the ceiling of the given number.
+
+    Equivalent to Python [`float(math.ceil(self))`](https://docs.python.org/3/library/math.html#math.ceil) if `self`
+    is finite, or `self` itself if `self` is infinite. (This is slightly different from the default behavior of
+    `math.ceil(self)`, which always returns an `int` and raises an error if `self` is infinite. The behavior in
+    Pixeltable generalizes the Python operator and is chosen to align with the SQL standard.)
+    """
     # This ensures the same behavior as SQL
     if math.isfinite(self):
         return float(math.ceil(self))
@@ -34,6 +59,14 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
 
 @pxt.udf(is_method=True)
 def floor(self: float) -> float:
+    """
+    Return the ceiling of the given number.
+
+    Equivalent to Python [`float(math.floor(self))`](https://docs.python.org/3/library/math.html#math.ceil) if `self`
+    is finite, or `self` itself if `self` is infinite. (This is slightly different from the default behavior of
+    `math.floor(self)`, which always returns an `int` and raises an error if `self` is infinite. The behavior of
+    Pixeltable generalizes the Python operator and is chosen to align with the SQL standard.)
+    """
     # This ensures the same behavior as SQL
     if math.isfinite(self):
         return float(math.floor(self))
@@ -48,6 +81,13 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
 
 @pxt.udf(is_method=True)
 def round(self: float, digits: Optional[int] = None) -> float:
+    """
+    Round a number to a given precision in decimal digits.
+
+    Equivalent to Python [`builtins.round(self, digits or 0)`](https://docs.python.org/3/library/functions.html#round).
+    Note that if `digits` is not specified, the behavior matches `builtins.round(self, 0)` rather than
+    `builtins.round(self)`; this ensures that the return type is always `float` (as in SQL) rather than `int`.
+    """
     # Set digits explicitly to 0 to guarantee a return type of float; this ensures the same behavior as SQL
     return builtins.round(self, digits or 0)
 

pixeltable/functions/string.py

@@ -5,10 +5,9 @@ It closely follows the Pandas `pandas.Series.str` API.
 Example:
 ```python
 import pixeltable as pxt
-from pixeltable.functions import string as pxt_str
 
 t = pxt.get_table(...)
-t.select(pxt_str.capitalize(t.str_col)).collect()
+t.select(t.str_col.capitalize()).collect()
 ```
 """
 

pixeltable/functions/video.py

@@ -4,10 +4,10 @@ Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs)
 Example:
 ```python
 import pixeltable as pxt
-from pixeltable.functions import video as pxt_video
+import pixeltable.functions as pxtf
 
 t = pxt.get_table(...)
-t.select(pxt_video.extract_audio(t.video_col)).collect()
+t.select(pxtf.video.extract_audio(t.video_col)).collect()
 ```
 """
 

pixeltable/globals.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import logging
 import os
-import urllib.parse
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Iterable, Iterator, Literal, Optional, Union
 
@@ -372,6 +371,31 @@ def create_snapshot(
     )
 
 
+def create_replica(destination: str, source: Union[str, catalog.Table]) -> Optional[catalog.Table]:
+    """
+    Create a replica of a table. Can be used either to create a remote replica of a local table, or to create a local
+    replica of a remote table. A given table can have at most one replica per Pixeltable instance.
+
+    Args:
+        destination: Path where the replica will be created. Can be either a local path such as `'my_dir.my_table'`, or
+            a remote URI such as `'pxt://username/mydir.my_table'`.
+        source: Path to the source table, or (if the source table is a local table) a handle to the source table.
+    """
+    remote_dest = destination.startswith('pxt://')
+    remote_source = isinstance(source, str) and source.startswith('pxt://')
+    if remote_dest == remote_source:
+        raise excs.Error('Exactly one of `destination` or `source` must be a remote URI.')
+
+    if remote_dest:
+        if isinstance(source, str):
+            source = get_table(source)
+        share.push_replica(destination, source)
+        return None
+    else:
+        assert isinstance(source, str)
+        return share.pull_replica(destination, source)
+
+
 def get_table(path: str) -> catalog.Table:
     """Get a handle to an existing table, view, or snapshot.
 
@@ -470,7 +494,7 @@ def drop_table(
         # if we're dropping a table by handle, we first need to get the current path, then drop the S lock on
         # the Table record, and then get X locks in the correct order (first containing directory, then table)
         with Env.get().begin_xact():
-            tbl_path = table._path()
+            tbl_path = table._path
     else:
         assert isinstance(table, str)
         tbl_path = table
@@ -627,13 +651,6 @@ def _extract_paths(
     return result
 
 
-def publish_snapshot(dest_uri: str, table: catalog.Table) -> None:
-    parsed_uri = urllib.parse.urlparse(dest_uri)
-    if parsed_uri.scheme != 'pxt':
-        raise excs.Error(f'Invalid Pixeltable URI (does not start with pxt://): {dest_uri}')
-    share.publish_snapshot(dest_uri, table)
-
-
 def list_dirs(path: str = '', recursive: bool = True) -> list[str]:
     """List the directories in a directory.
 

pixeltable/io/hf_datasets.py

@@ -31,8 +31,8 @@ _hf_to_pxt: dict[str, ts.ColumnType] = {
     'timestamp[s]': ts.TimestampType(nullable=True),
     'timestamp[ms]': ts.TimestampType(nullable=True),  # HF dataset iterator converts timestamps to datetime.datetime
     'timestamp[us]': ts.TimestampType(nullable=True),
-    'date32': ts.StringType(nullable=True),  # date32 is not supported in pixeltable, use string
-    'date64': ts.StringType(nullable=True),  # date64 is not supported in pixeltable, use string
+    'date32': ts.DateType(nullable=True),
+    'date64': ts.DateType(nullable=True),
 }
 
 

pixeltable/io/pandas.py

@@ -9,6 +9,7 @@ from pandas.api.types import is_datetime64_any_dtype, is_extension_array_dtype
 import pixeltable as pxt
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
+from pixeltable.env import Env
 
 
 def import_pandas(
@@ -209,14 +210,25 @@ def _df_row_to_pxt_row(
             nval = bool(val)
         elif pxt_type.is_string_type():
             nval = str(val)
+        elif pxt_type.is_date_type():
+            if pd.isnull(val):
+                # pandas has the bespoke 'NaT' valud for a missing timestamp
+                # This is not supported by postgres, and must be converted to None
+                nval = None
+            else:
+                nval = pd.Timestamp(val).date()
         elif pxt_type.is_timestamp_type():
             if pd.isnull(val):
-                # pandas has the bespoke 'NaT' type for a missing timestamp; postgres is very
-                # much not-ok with it. (But if we convert it to None and then load out the
-                # table contents as a pandas DataFrame, it will correctly restore the 'NaT'!)
+                # pandas has the bespoke 'NaT' value for a missing timestamp
+                # This is not supported by postgres, and must be converted to None
                 nval = None
             else:
-                nval = pd.Timestamp(val).to_pydatetime()
+                tval = pd.Timestamp(val)
+                # pandas supports tz-aware and naive timestamps.
+                if tval.tz is None:
+                    nval = pd.Timestamp(tval).tz_localize(tz=Env.get().default_time_zone)
+                else:
+                    nval = tval.astimezone(Env.get().default_time_zone)
         else:
             nval = val
         pxt_row[pxt_name] = nval

pixeltable/io/parquet.py

@@ -127,6 +127,8 @@ def export_parquet(
                         length = 8
                     elif col_type.is_bool_type():
                         length = 1
+                    elif col_type.is_date_type():
+                        length = 4
                     elif col_type.is_timestamp_type():
                         val = val.astimezone(datetime.timezone.utc)
                         length = 8

pixeltable/metadata/__init__.py

@@ -16,7 +16,7 @@ _console_logger = ConsoleLogger(logging.getLogger('pixeltable'))
 
 
 # current version of the metadata; this is incremented whenever the metadata schema changes
-VERSION = 34
+VERSION = 35
 
 
 def create_system_info(engine: sql.engine.Engine) -> None:

pixeltable/metadata/converters/convert_34.py

@@ -0,0 +1,21 @@
+from typing import Any, Optional
+
+import sqlalchemy as sql
+
+from pixeltable.metadata import register_converter
+from pixeltable.metadata.converters.util import convert_table_md
+
+
+@register_converter(version=34)
+def _(engine: sql.engine.Engine) -> None:
+    convert_table_md(engine, substitution_fn=__substitute_md)
+
+
+def __substitute_md(k: Optional[str], v: Any) -> Optional[tuple[Optional[str], Any]]:
+    if isinstance(v, dict) and '_classname' in v and v['_classname'] == 'ColumnRef':
+        # Add reference_tbl to ColumnRef; for historical metadata it is always equal to tbl
+        assert 'reference_tbl' not in v
+        v['reference_tbl'] = None
+        return k, v
+
+    return None

pixeltable/metadata/notes.py

@@ -2,6 +2,7 @@
 # rather than as a comment, so that the existence of a description can be enforced by
 # the unit tests when new versions are added.
 VERSION_NOTES = {
+    35: 'Track reference_tbl in ColumnRef',
     34: 'Set default value for is_pk field in column metadata to False',
     33: 'Add is_replica field to table metadata',
     32: 'Add the lock_dummy BIGINT column to the dirs table',