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

pixeltable/metadata/converters/convert_43.py

@@ -0,0 +1,44 @@
+from typing import Any
+
+import numpy as np
+import sqlalchemy as sql
+
+from pixeltable import type_system as ts
+from pixeltable.metadata import register_converter
+from pixeltable.metadata.converters.util import convert_table_md
+
+
+@register_converter(version=43)
+def _(engine: sql.engine.Engine) -> None:
+    """Converts ArrayTypes by replacing legacy dtype (which was a pxt Type ID) to numpy dtype."""
+    convert_table_md(engine, substitution_fn=_substitution_fn)
+
+
+def _substitution_fn(key: str | None, value: Any) -> tuple[str | None, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    if value.get('_classname', None) != 'ArrayType':
+        return None
+    if 'numpy_dtype' in value:
+        return None
+    assert 'dtype' in value
+
+    legacy_dtype_val = value['dtype']
+    new_dtype: np.dtype | None
+    if legacy_dtype_val is None:
+        new_dtype = None
+    else:
+        legacy_dtype = ts.ColumnType.Type(legacy_dtype_val)
+        new_dtype = ts.ArrayType.pxt_dtype_to_numpy_dtype.get(legacy_dtype, None)
+        if new_dtype is None:
+            raise ValueError(f'Unrecognized dtype: {legacy_dtype_val} ({legacy_dtype}) in {key}, {value}')
+
+    del value['dtype']
+    if new_dtype is None:
+        value['numpy_dtype'] = None
+    elif new_dtype == np.str_:
+        # str(np.str_) would be something like '<U'
+        value['numpy_dtype'] = 'str'
+    else:
+        value['numpy_dtype'] = str(new_dtype)
+    return key, value

pixeltable/metadata/converters/util.py

@@ -1,21 +1,22 @@
 import copy
 import logging
-from typing import Any, Callable, Optional
+from typing import Any, Callable, TypeVar
 from uuid import UUID
 
 import sqlalchemy as sql
 
-from pixeltable.metadata.schema import Function, Table, TableSchemaVersion, TableVersion
+from pixeltable.metadata.schema import Function, Table, TableSchemaVersion
 
 __logger = logging.getLogger('pixeltable')
 
 
 def convert_table_md(
     engine: sql.engine.Engine,
-    table_md_updater: Optional[Callable[[dict, UUID], None]] = None,
-    column_md_updater: Optional[Callable[[dict], None]] = None,
-    external_store_md_updater: Optional[Callable[[dict], None]] = None,
-    substitution_fn: Optional[Callable[[Optional[str], Any], Optional[tuple[Optional[str], Any]]]] = None,
+    table_md_updater: Callable[[dict, UUID], None] | None = None,
+    column_md_updater: Callable[[dict], None] | None = None,
+    external_store_md_updater: Callable[[dict], None] | None = None,
+    substitution_fn: Callable[[str | None, Any], tuple[str | None, Any] | None] | None = None,
+    table_modifier: Callable[[sql.Connection, UUID, dict, dict], None] | None = None,
 ) -> None:
     """
     Converts schema.TableMd dicts based on the specified conversion functions.
@@ -33,9 +34,10 @@ def convert_table_md(
             the original entry will be replaced, and the traversal will continue with `v'`.
     """
     with engine.begin() as conn:
-        for row in conn.execute(sql.select(Table)):
+        # avoid a SELECT * here, which breaks when we add new columns to Table
+        for row in conn.execute(sql.select(Table.id, Table.md)):
             tbl_id = row[0]
-            table_md = row[2]
+            table_md = row[1]
             assert isinstance(table_md, dict)
             updated_table_md = copy.deepcopy(table_md)
             if table_md_updater is not None:
@@ -49,6 +51,8 @@ def convert_table_md(
             if updated_table_md != table_md:
                 __logger.info(f'Updating schema for table: {tbl_id}')
                 conn.execute(sql.update(Table).where(Table.id == tbl_id).values(md=updated_table_md))
+            if table_modifier is not None:
+                table_modifier(conn, tbl_id, table_md, updated_table_md)
 
         for row in conn.execute(sql.select(Function)):
             fn_id = row[0]
@@ -76,9 +80,7 @@ def __update_external_store_md(table_md: dict, external_store_md_updater: Callab
         external_store_md_updater(store_md)
 
 
-def __substitute_md_rec(
-    md: Any, substitution_fn: Callable[[Optional[str], Any], Optional[tuple[Optional[str], Any]]]
-) -> Any:
+def __substitute_md_rec(md: Any, substitution_fn: Callable[[str | None, Any], tuple[str | None, Any] | None]) -> Any:
     if isinstance(md, dict):
         updated_dict: dict[str, Any] = {}
         for k, v in md.items():
@@ -106,8 +108,8 @@ def __substitute_md_rec(
 
 def convert_table_schema_version_md(
     engine: sql.engine.Engine,
-    table_schema_version_md_updater: Optional[Callable[[dict], None]] = None,
-    schema_column_updater: Optional[Callable[[dict], None]] = None,
+    table_schema_version_md_updater: Callable[[dict], None] | None = None,
+    schema_column_updater: Callable[[dict], None] | None = None,
 ) -> None:
     """
     Converts schema.TableSchemaVersionMd dicts based on the specified conversion functions.
@@ -145,26 +147,13 @@ def __update_schema_column(table_schema_version_md: dict, schema_column_updater:
         schema_column_updater(schema_col)
 
 
-def convert_table_record(engine: sql.engine.Engine, table_record_updater: Optional[Callable[[Table], None]]) -> None:
-    with sql.orm.Session(engine, future=True) as session:
-        for record in session.query(Table).all():
-            table_record_updater(record)
-        session.commit()
-
-
-def convert_table_version_record(
-    engine: sql.engine.Engine, table_version_record_updater: Optional[Callable[[TableVersion], None]]
-) -> None:
-    with sql.orm.Session(engine, future=True) as session:
-        for record in session.query(TableVersion).all():
-            table_version_record_updater(record)
-        session.commit()
+T = TypeVar('T')
 
 
-def convert_table_schema_version_record(
-    engine: sql.engine.Engine, table_schema_version_record_updater: Optional[Callable[[TableSchemaVersion], None]]
+def convert_sql_table_record(
+    schema: type[T], engine: sql.engine.Engine, record_updater: Callable[[T], None] | None
 ) -> None:
     with sql.orm.Session(engine, future=True) as session:
-        for record in session.query(TableSchemaVersion).all():
-            table_schema_version_record_updater(record)
+        for record in session.query(schema).all():
+            record_updater(record)
         session.commit()

pixeltable/metadata/notes.py

@@ -2,6 +2,15 @@
 # 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 = {
+    44: 'ArrayType dtype migration from pxt types to numpy dtypes',
+    43: 'Changing tables.dir_id to nullable',
+    42: 'Add additional_md columns to metadata tables',
+    41: 'Cellmd columns for array and json columns',
+    40: 'Convert error property columns to cellmd columns',
+    39: 'ColumnHandles in external stores',
+    38: 'Added TableMd.view_sn',
+    37: 'Add support for the sample() method on DataFrames',
+    36: 'Added Table.lock_dummy',
     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',

pixeltable/metadata/schema.py

@@ -1,13 +1,17 @@
 import dataclasses
+import types
 import typing
 import uuid
-from typing import Any, NamedTuple, Optional, TypeVar, Union, get_type_hints
+from enum import Enum
+from typing import Any, TypeVar, Union, get_type_hints
 
 import sqlalchemy as sql
 from sqlalchemy import BigInteger, ForeignKey, Integer, LargeBinary, orm
 from sqlalchemy.dialects.postgresql import JSONB, UUID
 from sqlalchemy.orm.decl_api import DeclarativeMeta
 
+from ..catalog.update_status import UpdateStatus
+
 # Base has to be marked explicitly as a type, in order to be used elsewhere as a type hint. But in addition to being
 # a type, it's also a `DeclarativeMeta`. The following pattern enables us to expose both `Base` and `Base.metadata`
 # outside of the module in a typesafe way.
@@ -18,17 +22,17 @@ base_metadata = Base.metadata
 T = TypeVar('T')
 
 
-def md_from_dict(data_class_type: type[T], data: Any) -> T:
+def md_from_dict(type_: type[T], data: Any) -> T:
     """Re-instantiate a dataclass instance that contains nested dataclasses from a dict."""
-    if dataclasses.is_dataclass(data_class_type):
-        fieldtypes = get_type_hints(data_class_type)
-        return data_class_type(**{f: md_from_dict(fieldtypes[f], data[f]) for f in data})  # type: ignore[return-value]
+    if dataclasses.is_dataclass(type_):
+        fieldtypes = get_type_hints(type_)
+        return type_(**{f: md_from_dict(fieldtypes[f], data[f]) for f in data})
 
-    origin = typing.get_origin(data_class_type)
+    origin = typing.get_origin(type_)
     if origin is not None:
-        type_args = typing.get_args(data_class_type)
-        if origin is Union and type(None) in type_args:
-            # Handling Optional types
+        type_args = typing.get_args(type_)
+        if (origin is Union or origin is types.UnionType) and type(None) in type_args:
+            # handling T | None, T | None
             non_none_args = [arg for arg in type_args if arg is not type(None)]
             assert len(non_none_args) == 1
             return md_from_dict(non_none_args[0], data) if data is not None else None
@@ -42,10 +46,18 @@ def md_from_dict(data_class_type: type[T], data: Any) -> T:
             return tuple(md_from_dict(arg_type, elem) for arg_type, elem in zip(type_args, data))  # type: ignore[return-value]
         else:
             raise AssertionError(origin)
+    elif isinstance(type_, type) and issubclass(type_, Enum):
+        return type_(data)
     else:
         return data
 
 
+def _md_dict_factory(data: list[tuple[str, Any]]) -> dict:
+    """Use this to serialize <>Md instances with dataclasses.asdict()"""
+    # serialize enums to their values
+    return {k: v.value if isinstance(v, Enum) else v for k, v in data}
+
+
 # structure of the stored metadata:
 # - each schema entity that grows somehow proportionally to the data (# of output_rows, total insert operations,
 #   number of schema changes) gets its own table
@@ -65,6 +77,7 @@ class SystemInfo(Base):
     """A single-row table that contains system-wide metadata."""
 
     __tablename__ = 'systeminfo'
+
     dummy = sql.Column(Integer, primary_key=True, default=0, nullable=False)
     md = sql.Column(JSONB, nullable=False)  # SystemInfoMd
 
@@ -72,8 +85,8 @@ class SystemInfo(Base):
 @dataclasses.dataclass
 class DirMd:
     name: str
-    user: Optional[str]
-    additional_md: dict[str, Any]
+    user: str | None
+    additional_md: dict[str, Any]  # deprecated
 
 
 class Dir(Base):
@@ -84,7 +97,9 @@ class Dir(Base):
     )
     parent_id: orm.Mapped[uuid.UUID] = orm.mapped_column(UUID(as_uuid=True), ForeignKey('dirs.id'), nullable=True)
     md: orm.Mapped[dict[str, Any]] = orm.mapped_column(JSONB, nullable=False)  # DirMd
-    # This field is updated to synchronize database operations across multiple sessions
+    additional_md: orm.Mapped[dict[str, Any]] = orm.mapped_column(JSONB, nullable=False, default=dict)
+
+    # used to force acquisition of an X-lock via an Update stmt
     lock_dummy: orm.Mapped[int] = orm.mapped_column(BigInteger, nullable=True)
 
 
@@ -100,17 +115,20 @@ class ColumnMd:
 
     id: int
     schema_version_add: int
-    schema_version_drop: Optional[int]
+    schema_version_drop: int | None
     col_type: dict
 
     # if True, is part of the primary key
     is_pk: bool
 
     # if set, this is a computed column
-    value_expr: Optional[dict]
+    value_expr: dict | None
 
     # if True, the column is present in the stored table
-    stored: Optional[bool]
+    stored: bool | None
+
+    # If present, the URI for the destination for column values
+    destination: str | None = None
 
 
 @dataclasses.dataclass
@@ -126,13 +144,13 @@ class IndexMd:
     index_val_col_id: int  # column holding the values to be indexed
     index_val_undo_col_id: int  # column holding index values for deleted rows
     schema_version_add: int
-    schema_version_drop: Optional[int]
+    schema_version_drop: int | None
     class_fqn: str
     init_args: dict[str, Any]
 
 
 # a stored table version path is a list of (table id as str, effective table version)
-TableVersionPath = list[tuple[str, Optional[int]]]
+TableVersionPath = list[tuple[str, int | None]]
 
 
 @dataclasses.dataclass
@@ -144,13 +162,36 @@ class ViewMd:
     base_versions: TableVersionPath
 
     # filter predicate applied to the base table; view-only
-    predicate: Optional[dict[str, Any]]
+    predicate: dict[str, Any] | None
+
+    # sampling predicate applied to the base table; view-only
+    sample_clause: dict[str, Any] | None
 
     # ComponentIterator subclass; only for component views
-    iterator_class_fqn: Optional[str]
+    iterator_class_fqn: str | None
 
     # args to pass to the iterator class constructor; only for component views
-    iterator_args: Optional[dict[str, Any]]
+    iterator_args: dict[str, Any] | None
+
+
+class TableState(Enum):
+    """The operational state of the table"""
+
+    LIVE = 0
+    ROLLFORWARD = 1  # finalizing pending table ops
+    ROLLBACK = 2  # rolling back pending table ops
+
+
+class TableStatement(Enum):
+    """The top-level DDL/DML operation (corresponding to a statement in SQL; not: a TableOp) currently being executed"""
+
+    CREATE_TABLE = 0
+    CREATE_VIEW = 1
+    DROP_TABLE = 2
+    ADD_COLUMNS = 3
+    DROP_COLUMNS = 4
+    ADD_INDEX = 5
+    DROP_INDEX = 6
 
 
 @dataclasses.dataclass
@@ -159,7 +200,7 @@ class TableMd:
     name: str
     is_replica: bool
 
-    user: Optional[str]
+    user: str | None
 
     # monotonically increasing w/in Table for both data and schema changes, starting at 0
     current_version: int
@@ -173,14 +214,52 @@ class TableMd:
     # - every row is assigned a unique and immutable rowid on insertion
     next_row_id: int
 
+    # sequence number to track changes in the set of mutable views of this table (ie, this table = the view base)
+    # - incremented for each add/drop of a mutable view
+    # - only maintained for mutable tables
+    # TODO: replace with mutable_views: list[UUID] to help with debugging
+    view_sn: int
+
     # Metadata format for external stores:
     # {'class': 'pixeltable.io.label_studio.LabelStudioProject', 'md': {'project_id': 3}}
     external_stores: list[dict[str, Any]]
 
     column_md: dict[int, ColumnMd]  # col_id -> ColumnMd
     index_md: dict[int, IndexMd]  # index_id -> IndexMd
-    view_md: Optional[ViewMd]
-    additional_md: dict[str, Any]
+    view_md: ViewMd | None
+    # TODO: Remove additional_md from this and other Md dataclasses (and switch to using the separate additional_md
+    #     column in all cases)
+    additional_md: dict[str, Any]  # deprecated
+
+    # deprecated
+    has_pending_ops: bool = False
+
+    tbl_state: TableState = TableState.LIVE
+    pending_stmt: TableStatement | None = None
+
+    @property
+    def is_snapshot(self) -> bool:
+        return self.view_md is not None and self.view_md.is_snapshot
+
+    @property
+    def is_mutable(self) -> bool:
+        return not self.is_snapshot and not self.is_replica
+
+    @property
+    def is_pure_snapshot(self) -> bool:
+        return (
+            self.view_md is not None
+            and self.view_md.is_snapshot
+            and self.view_md.sample_clause is None
+            and self.view_md.predicate is None
+            and len(self.column_md) == 0
+        )
+
+    @property
+    def ancestors(self) -> TableVersionPath:
+        if self.view_md is None:
+            return []
+        return self.view_md.base_versions
 
 
 class Table(Base):
@@ -190,6 +269,8 @@ class Table(Base):
     Views are in essence a subclass of tables, because they also store materialized columns. The differences are:
     - views have a base, which is either a (live) table or a snapshot
     - views can have a filter predicate
+
+    dir_id: NULL for dropped tables
     """
 
     __tablename__ = 'tables'
@@ -197,26 +278,37 @@ class Table(Base):
     MAX_VERSION = 9223372036854775807  # 2^63 - 1
 
     id: orm.Mapped[uuid.UUID] = orm.mapped_column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    dir_id: orm.Mapped[uuid.UUID] = orm.mapped_column(UUID(as_uuid=True), ForeignKey('dirs.id'), nullable=False)
+    dir_id: orm.Mapped[uuid.UUID] = orm.mapped_column(UUID(as_uuid=True), ForeignKey('dirs.id'), nullable=True)
     md: orm.Mapped[dict[str, Any]] = orm.mapped_column(JSONB, nullable=False)  # TableMd
+    additional_md: orm.Mapped[dict[str, Any]] = orm.mapped_column(JSONB, nullable=False, default=dict)
+
+    # used to force acquisition of an X-lock via an Update stmt
+    lock_dummy: orm.Mapped[int] = orm.mapped_column(BigInteger, nullable=True)
 
 
 @dataclasses.dataclass
-class TableVersionMd:
+class VersionMd:
     tbl_id: str  # uuid.UUID
     created_at: float  # time.time()
     version: int
     schema_version: int
-    additional_md: dict[str, Any]
+    user: str | None = None  # User that created this version
+    update_status: UpdateStatus | None = None  # UpdateStatus of the change that created this version
+    # A version fragment cannot be queried or instantiated via get_table(). A fragment represents a version of a
+    # replica table that has incomplete data, and exists only to provide base table support for a dependent view.
+    is_fragment: bool = False
+    additional_md: dict[str, Any] = dataclasses.field(default_factory=dict)  # deprecated
 
 
 class TableVersion(Base):
     __tablename__ = 'tableversions'
+
     tbl_id: orm.Mapped[uuid.UUID] = orm.mapped_column(
         UUID(as_uuid=True), ForeignKey('tables.id'), primary_key=True, nullable=False
     )
     version: orm.Mapped[int] = orm.mapped_column(BigInteger, primary_key=True, nullable=False)
     md: orm.Mapped[dict[str, Any]] = orm.mapped_column(JSONB, nullable=False)
+    additional_md: orm.Mapped[dict[str, Any]] = orm.mapped_column(JSONB, nullable=False, default=dict)
 
 
 @dataclasses.dataclass
@@ -230,18 +322,18 @@ class SchemaColumn:
 
     # media validation strategy of this particular media column; if not set, TableMd.media_validation applies
     # stores column.MediaValiation.name.lower()
-    media_validation: Optional[str]
+    media_validation: str | None
 
 
 @dataclasses.dataclass
-class TableSchemaVersionMd:
+class SchemaVersionMd:
     """
     Records all versioned table metadata.
     """
 
     tbl_id: str  # uuid.UUID
     schema_version: int
-    preceding_schema_version: Optional[int]
+    preceding_schema_version: int | None
     columns: dict[int, SchemaColumn]  # col_id -> SchemaColumn
     num_retained_versions: int
     comment: str
@@ -249,7 +341,7 @@ class TableSchemaVersionMd:
     # default validation strategy for any media column of this table
     # stores column.MediaValiation.name.lower()
     media_validation: str
-    additional_md: dict[str, Any]
+    additional_md: dict[str, Any]  # deprecated
 
 
 # versioning: each table schema change results in a new record
@@ -261,6 +353,23 @@ class TableSchemaVersion(Base):
     )
     schema_version: orm.Mapped[int] = orm.mapped_column(BigInteger, primary_key=True, nullable=False)
     md: orm.Mapped[dict[str, Any]] = orm.mapped_column(JSONB, nullable=False)  # TableSchemaVersionMd
+    additional_md: orm.Mapped[dict[str, Any]] = orm.mapped_column(JSONB, nullable=False, default=dict)
+
+
+class PendingTableOp(Base):
+    """
+    Table operation that needs to be completed before the table can be used.
+
+    Operations need to be completed in order of increasing seq_num.
+    """
+
+    __tablename__ = 'pendingtableops'
+
+    tbl_id: orm.Mapped[uuid.UUID] = orm.mapped_column(
+        UUID(as_uuid=True), ForeignKey('tables.id'), primary_key=True, nullable=False
+    )
+    op_sn: orm.Mapped[int] = orm.mapped_column(Integer, primary_key=True, nullable=False)  # catalog.TableOp.op_sn
+    op: orm.Mapped[dict[str, Any]] = orm.mapped_column(JSONB, nullable=False)  # catalog.TableOp
 
 
 @dataclasses.dataclass
@@ -288,26 +397,4 @@ class Function(Base):
     )
     dir_id: orm.Mapped[uuid.UUID] = orm.mapped_column(UUID(as_uuid=True), ForeignKey('dirs.id'), nullable=True)
     md: orm.Mapped[dict[str, Any]] = orm.mapped_column(JSONB, nullable=False)  # FunctionMd
-    binary_obj: orm.Mapped[Optional[bytes]] = orm.mapped_column(LargeBinary, nullable=True)
-
-
-class FullTableMd(NamedTuple):
-    tbl_md: TableMd
-    version_md: TableVersionMd
-    schema_version_md: TableSchemaVersionMd
-
-    def as_dict(self) -> dict[str, Any]:
-        return {
-            'table_id': self.tbl_md.tbl_id,
-            'table_md': dataclasses.asdict(self.tbl_md),
-            'table_version_md': dataclasses.asdict(self.version_md),
-            'table_schema_version_md': dataclasses.asdict(self.schema_version_md),
-        }
-
-    @classmethod
-    def from_dict(cls, data_dict: dict[str, Any]) -> 'FullTableMd':
-        return FullTableMd(
-            tbl_md=md_from_dict(TableMd, data_dict['table_md']),
-            version_md=md_from_dict(TableVersionMd, data_dict['table_version_md']),
-            schema_version_md=md_from_dict(TableSchemaVersionMd, data_dict['table_schema_version_md']),
-        )
+    binary_obj: orm.Mapped[bytes | None] = orm.mapped_column(LargeBinary, nullable=True)

pixeltable/metadata/utils.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from pixeltable.metadata import schema
+
+
+class MetadataUtils:
+    @classmethod
+    def _diff_md(
+        cls, old_md: dict[int, schema.SchemaColumn] | None, new_md: dict[int, schema.SchemaColumn] | None
+    ) -> str:
+        """Return a string reporting the differences in a specific entry in two dictionaries
+
+        Results are formatted as follows:
+        - If `old_md` is `None`, returns 'Initial Version'.
+        - If `old_md` and `new_md` are the same, returns an empty string.
+        - If there are additions, changes, or deletions, returns a string summarizing the changes.
+        """
+        assert new_md is not None
+        if old_md is None:
+            return 'Initial Version'
+        if old_md == new_md:
+            return ''
+        added = {k: v.name for k, v in new_md.items() if k not in old_md}
+        changed = {
+            k: f'{old_md[k].name!r} to {v.name!r}'
+            for k, v in new_md.items()
+            if k in old_md and old_md[k].name != v.name
+        }
+        deleted = {k: v.name for k, v in old_md.items() if k not in new_md}
+        if len(added) == 0 and len(changed) == 0 and len(deleted) == 0:
+            return ''
+        # Format the result
+        t = []
+        if len(added) > 0:
+            t.append('Added: ' + ', '.join(added.values()))
+        if len(changed) > 0:
+            t.append('Renamed: ' + ', '.join(changed.values()))
+        if len(deleted) > 0:
+            t.append('Deleted: ' + ', '.join(deleted.values()))
+        r = ', '.join(t)
+        return r
+
+    @classmethod
+    def _create_md_change_dict(cls, md_list: list[tuple[int, dict[int, schema.SchemaColumn]]] | None) -> dict[int, str]:
+        """Return a dictionary of schema changes by version
+        Args:
+            md_list: a list of tuples, each containing a version number and a metadata dictionary.
+        """
+        r: dict[int, str] = {}
+        if md_list is None or len(md_list) == 0:
+            return r
+
+        # Sort the list in place by version number
+        md_list.sort()
+
+        first_retrieved_version = md_list[0][0]
+        if first_retrieved_version == 0:
+            prev_md = None
+            prev_ver = -1
+            start = 0
+        else:
+            prev_md = md_list[0][1]
+            prev_ver = first_retrieved_version
+            start = 1
+
+        for ver, curr_md in md_list[start:]:
+            if ver == prev_ver:
+                continue
+            assert ver > prev_ver
+            tf = cls._diff_md(prev_md, curr_md)
+            if tf != '':
+                r[ver] = tf
+            prev_md = curr_md
+        return r

pixeltable/mypy/__init__.py

@@ -0,0 +1,3 @@
+from .mypy_plugin import plugin
+
+__all__ = ['plugin']