pixeltable 0.3.2__tar.gz → 0.3.3__tar.gz

{pixeltable-0.3.2 → pixeltable-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixeltable
-Version: 0.3.2
+Version: 0.3.3
 Summary: AI Data Infrastructure: Declarative, Multimodal, and Incremental
 Home-page: https://pixeltable.com/
 License: Apache-2.0
@@ -60,7 +60,7 @@ Description-Content-Type: text/markdown
      alt="Pixeltable" width="50%" />
 <br></br>
 
-<h2>AI Data Infrastructure — Declarative, Multimodal, and Incremental</h2>
+<h2>Build Multimodal AI Apps with Declarative Data Infrastructure</h2>
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-0530AD.svg)](https://opensource.org/licenses/Apache-2.0)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pixeltable?logo=python&logoColor=white&)
@@ -82,17 +82,15 @@ Description-Content-Type: text/markdown
 [LLM](https://docs.pixeltable.com/docs/document-indexing-and-rag)
 </div>
 
-Pixeltable is a Python library providing a declarative interface for multimodal data (text, images, audio, video).
-It features built-in versioning, lineage tracking, and incremental updates, enabling users to **store**, **transform**,
-**index**, and **iterate** on data for their ML workflows.
+Pixeltable is a declarative data infrastructure for building multimodal AI applications, enabling incremental storage, transformation, indexing, and orchestration of your data.
 
-Data transformations, model inference, and custom logic are embedded as **computed columns**.
+Consider it your unified foundation for computer vision, LLMs, and multimodal AI development - where complex data operations become simple tables and computed columns, including but not limited to:
 
-- **Load/Query all data types**: Interact with
+- **Work with all your data**: Interact with
     [video data](https://github.com/pixeltable/pixeltable?tab=readme-ov-file#import-media-data-into-pixeltable-videos-images-audio)
     at the [frame level](https://github.com/pixeltable/pixeltable?tab=readme-ov-file#text-and-image-similarity-search-on-video-frames-with-embedding-indexes)
     and documents at the [chunk level](https://github.com/pixeltable/pixeltable?tab=readme-ov-file#automate-data-operations-with-views-eg-split-documents-into-chunks)
-- **Incremental updates for data transformation**: Maintain an
+- **Incremental updates**: Maintain an
     [embedding index](https://docs.pixeltable.com/docs/embedding-vector-indexes) colocated with your data
 - **Lazy evaluation and cache management**: Eliminates the need for
     [manual frame extraction](https://docs.pixeltable.com/docs/object-detection-in-videos)

{pixeltable-0.3.2 → pixeltable-0.3.3}/README.md

@@ -3,7 +3,7 @@
      alt="Pixeltable" width="50%" />
 <br></br>
 
-<h2>AI Data Infrastructure — Declarative, Multimodal, and Incremental</h2>
+<h2>Build Multimodal AI Apps with Declarative Data Infrastructure</h2>
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-0530AD.svg)](https://opensource.org/licenses/Apache-2.0)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pixeltable?logo=python&logoColor=white&)
@@ -25,17 +25,15 @@
 [LLM](https://docs.pixeltable.com/docs/document-indexing-and-rag)
 </div>
 
-Pixeltable is a Python library providing a declarative interface for multimodal data (text, images, audio, video).
-It features built-in versioning, lineage tracking, and incremental updates, enabling users to **store**, **transform**,
-**index**, and **iterate** on data for their ML workflows.
+Pixeltable is a declarative data infrastructure for building multimodal AI applications, enabling incremental storage, transformation, indexing, and orchestration of your data.
 
-Data transformations, model inference, and custom logic are embedded as **computed columns**.
+Consider it your unified foundation for computer vision, LLMs, and multimodal AI development - where complex data operations become simple tables and computed columns, including but not limited to:
 
-- **Load/Query all data types**: Interact with
+- **Work with all your data**: Interact with
     [video data](https://github.com/pixeltable/pixeltable?tab=readme-ov-file#import-media-data-into-pixeltable-videos-images-audio)
     at the [frame level](https://github.com/pixeltable/pixeltable?tab=readme-ov-file#text-and-image-similarity-search-on-video-frames-with-embedding-indexes)
     and documents at the [chunk level](https://github.com/pixeltable/pixeltable?tab=readme-ov-file#automate-data-operations-with-views-eg-split-documents-into-chunks)
-- **Incremental updates for data transformation**: Maintain an
+- **Incremental updates**: Maintain an
     [embedding index](https://docs.pixeltable.com/docs/embedding-vector-indexes) colocated with your data
 - **Lazy evaluation and cache management**: Eliminates the need for
     [manual frame extraction](https://docs.pixeltable.com/docs/object-detection-in-videos)

pixeltable-0.3.3/pixeltable/__init__.py

@@ -0,0 +1,78 @@
+from .__version__ import __version__, __version_tuple__
+from .catalog import Column, InsertableTable, Table, UpdateStatus, View
+from .dataframe import DataFrame
+from .exceptions import Error
+from .exprs import RELATIVE_PATH_ROOT
+from .func import Aggregator, Function, expr_udf, query, uda, udf
+from .globals import (
+    array,
+    configure_logging,
+    create_dir,
+    create_snapshot,
+    create_table,
+    create_view,
+    drop_dir,
+    drop_table,
+    get_table,
+    init,
+    list_dirs,
+    list_functions,
+    list_tables,
+    move,
+    tool,
+    tools,
+)
+from .type_system import (
+    Array,
+    ArrayType,
+    Audio,
+    AudioType,
+    Bool,
+    BoolType,
+    ColumnType,
+    Document,
+    DocumentType,
+    Float,
+    FloatType,
+    Image,
+    ImageType,
+    Int,
+    IntType,
+    Json,
+    JsonType,
+    Required,
+    String,
+    StringType,
+    Timestamp,
+    TimestampType,
+    Video,
+    VideoType,
+)
+
+# This import must go last to avoid circular imports.
+from . import ext, functions, io, iterators  # isort: skip
+
+# This is the safest / most maintainable way to construct __all__: start with the default and "blacklist"
+# stuff that we don't want in there. (Using a "whitelist" is considerably harder to maintain.)
+
+__default_dir = set(symbol for symbol in dir() if not symbol.startswith('_'))
+__removed_symbols = {
+    'catalog',
+    'dataframe',
+    'env',
+    'exceptions',
+    'exec',
+    'exprs',
+    'func',
+    'globals',
+    'index',
+    'metadata',
+    'plan',
+    'type_system',
+    'utils',
+}
+__all__ = sorted(list(__default_dir - __removed_symbols))
+
+
+def __dir__():
+    return __all__

{pixeltable-0.3.2 → pixeltable-0.3.3}/pixeltable/__version__.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced during build.
-__version__ = "0.3.2"
-__version_tuple__ = (0, 3, 2)
+__version__ = '0.3.3'
+__version_tuple__ = (0, 3, 3)

{pixeltable-0.3.2 → pixeltable-0.3.3}/pixeltable/catalog/__init__.py

@@ -1,7 +1,7 @@
 from .catalog import Catalog
 from .column import Column
 from .dir import Dir
-from .globals import UpdateStatus, is_valid_identifier, is_valid_path, MediaValidation, IfExistsParam, IfNotExistsParam
+from .globals import IfExistsParam, IfNotExistsParam, MediaValidation, UpdateStatus, is_valid_identifier, is_valid_path
 from .insertable_table import InsertableTable
 from .named_function import NamedFunction
 from .path import Path

{pixeltable-0.3.2 → pixeltable-0.3.3}/pixeltable/catalog/catalog.py

@@ -8,18 +8,22 @@ from uuid import UUID
 import sqlalchemy as sql
 import sqlalchemy.orm as orm
 
+import pixeltable.metadata.schema as schema
+
+from .path_dict import PathDict
+from .table import Table
 from .table_version import TableVersion
 from .table_version_path import TableVersionPath
-from .table import Table
-from .path_dict import PathDict
 
-import pixeltable.env as env
-import pixeltable.metadata.schema as schema
+# This import must go last to avoid circular imports.
+import pixeltable.env as env  # isort: skip
 
 _logger = logging.getLogger('pixeltable')
 
+
 class Catalog:
     """A repository of catalog objects"""
+
     _instance: Optional[Catalog] = None
 
     @classmethod
@@ -28,7 +32,7 @@ class Catalog:
             cls._instance = cls()
             with orm.Session(env.Env.get().engine, future=True) as session:
                 cls._instance._load_table_versions(session)
-                #cls._instance._load_functions(session)
+                # cls._instance._load_functions(session)
         return cls._instance
 
     @classmethod
@@ -62,17 +66,24 @@ class Catalog:
             _logger.info(f'Initialized catalog')
 
     def _load_snapshot_version(
-            self, tbl_id: UUID, version: int, base: Optional[TableVersion], session: orm.Session
+        self, tbl_id: UUID, version: int, base: Optional[TableVersion], session: orm.Session
     ) -> TableVersion:
-        q = session.query(schema.Table, schema.TableSchemaVersion) \
-            .select_from(schema.Table) \
-            .join(schema.TableVersion) \
-            .join(schema.TableSchemaVersion) \
-            .where(schema.Table.id == tbl_id) \
-            .where(sql.text(f"({schema.TableVersion.__table__}.md->>'version')::int = {version}")) \
-            .where(sql.text((
-                f"({schema.TableVersion.__table__}.md->>'schema_version')::int = "
-                f"{schema.TableSchemaVersion.__table__}.{schema.TableSchemaVersion.schema_version.name}")))
+        q = (
+            session.query(schema.Table, schema.TableSchemaVersion)
+            .select_from(schema.Table)
+            .join(schema.TableVersion)
+            .join(schema.TableSchemaVersion)
+            .where(schema.Table.id == tbl_id)
+            .where(sql.text(f"({schema.TableVersion.__table__}.md->>'version')::int = {version}"))
+            .where(
+                sql.text(
+                    (
+                        f"({schema.TableVersion.__table__}.md->>'schema_version')::int = "
+                        f'{schema.TableSchemaVersion.__table__}.{schema.TableSchemaVersion.schema_version.name}'
+                    )
+                )
+            )
+        )
         tbl_record, schema_version_record = q.one()
         tbl_md = schema.md_from_dict(schema.TableMd, tbl_record.md)
         schema_version_md = schema.md_from_dict(schema.TableSchemaVersionMd, schema_version_record.md)
@@ -86,15 +97,22 @@ class Catalog:
 
         # load tables/views;
         # do this in ascending order of creation ts so that we can resolve base references in one pass
-        q = session.query(schema.Table, schema.TableSchemaVersion) \
-            .select_from(schema.Table) \
-            .join(schema.TableVersion) \
-            .join(schema.TableSchemaVersion) \
-            .where(sql.text(f"({schema.TableVersion.__table__}.md->>'version')::int = 0")) \
-            .where(sql.text((
-                f"({schema.Table.__table__}.md->>'current_schema_version')::int = "
-                f"{schema.TableSchemaVersion.__table__}.{schema.TableSchemaVersion.schema_version.name}"))) \
+        q = (
+            session.query(schema.Table, schema.TableSchemaVersion)
+            .select_from(schema.Table)
+            .join(schema.TableVersion)
+            .join(schema.TableSchemaVersion)
+            .where(sql.text(f"({schema.TableVersion.__table__}.md->>'version')::int = 0"))
+            .where(
+                sql.text(
+                    (
+                        f"({schema.Table.__table__}.md->>'current_schema_version')::int = "
+                        f'{schema.TableSchemaVersion.__table__}.{schema.TableSchemaVersion.schema_version.name}'
+                    )
+                )
+            )
             .order_by(sql.text(f"({schema.TableVersion.__table__}.md->>'created_at')::float"))
+        )
 
         for tbl_record, schema_version_record in q.all():
             tbl_md = schema.md_from_dict(schema.TableMd, tbl_record.md)
@@ -129,14 +147,19 @@ class Catalog:
                     view_path = base_path
                 else:
                     tbl_version = TableVersion(
-                        tbl_record.id, tbl_md, tbl_md.current_version, schema_version_md, is_snapshot=is_snapshot,
+                        tbl_record.id,
+                        tbl_md,
+                        tbl_md.current_version,
+                        schema_version_md,
+                        is_snapshot=is_snapshot,
                         base=base_path.tbl_version if is_snapshot else None,
-                        base_path=base_path if not is_snapshot else None)
+                        base_path=base_path if not is_snapshot else None,
+                    )
                     view_path = TableVersionPath(tbl_version, base=base_path)
 
                 tbl: Table = View(
-                    tbl_record.id, tbl_record.dir_id, tbl_md.name, view_path, base_tbl_id,
-                    snapshot_only=snapshot_only)
+                    tbl_record.id, tbl_record.dir_id, tbl_md.name, view_path, base_tbl_id, snapshot_only=snapshot_only
+                )
                 self.tbl_dependents[base_tbl_id].append(tbl)
 
             else:

{pixeltable-0.3.2 → pixeltable-0.3.3}/pixeltable/catalog/column.py

@@ -8,7 +8,8 @@ import sqlalchemy as sql
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
 from pixeltable import exprs
-from .globals import is_valid_identifier, MediaValidation
+
+from .globals import MediaValidation, is_valid_identifier
 
 if TYPE_CHECKING:
     from .table_version import TableVersion
@@ -22,6 +23,7 @@ class Column:
     A Column contains all the metadata necessary for executing queries and updates against a particular version of a
     table/view.
     """
+
     name: str
     id: Optional[int]
     col_type: ts.ColumnType
@@ -41,12 +43,19 @@ class Column:
     tbl: Optional[TableVersion]
 
     def __init__(
-            self, name: Optional[str], col_type: Optional[ts.ColumnType] = None,
-            computed_with: Optional[exprs.Expr] = None,
-            is_pk: bool = False, stored: bool = True, media_validation: Optional[MediaValidation] = None,
-            col_id: Optional[int] = None, schema_version_add: Optional[int] = None,
-            schema_version_drop: Optional[int] = None, sa_col_type: Optional[sql.sqltypes.TypeEngine] = None,
-            records_errors: Optional[bool] = None, value_expr_dict: Optional[dict[str, Any]] = None,
+        self,
+        name: Optional[str],
+        col_type: Optional[ts.ColumnType] = None,
+        computed_with: Optional[exprs.Expr] = None,
+        is_pk: bool = False,
+        stored: bool = True,
+        media_validation: Optional[MediaValidation] = None,
+        col_id: Optional[int] = None,
+        schema_version_add: Optional[int] = None,
+        schema_version_drop: Optional[int] = None,
+        sa_col_type: Optional[sql.sqltypes.TypeEngine] = None,
+        records_errors: Optional[bool] = None,
+        value_expr_dict: Optional[dict[str, Any]] = None,
     ):
         """Column constructor.
 
@@ -81,7 +90,8 @@ class Column:
             if value_expr is None:
                 raise excs.Error(
                     f'Column {name}: computed_with needs to be a valid Pixeltable expression, '
-                    f'but it is a {type(computed_with)}')
+                    f'but it is a {type(computed_with)}'
+                )
             else:
                 self._value_expr = value_expr.copy()
                 self.col_type = self._value_expr.col_type
@@ -117,6 +127,7 @@ class Column:
         # catalog has been fully loaded; that way, we encounter bugs in the serialization/deserialization logic earlier
         if self.value_expr_dict is not None and self._value_expr is None:
             from pixeltable import exprs
+
             self._value_expr = exprs.Expr.from_dict(self.value_expr_dict)
         return self._value_expr
 
@@ -129,12 +140,14 @@ class Column:
         if self.stored == False and self.is_computed and self.has_window_fn_call():
             raise excs.Error(
                 f'Column {self.name}: stored={self.stored} not supported for columns computed with window functions:'
-                f'\n{self.value_expr}')
+                f'\n{self.value_expr}'
+            )
 
     def has_window_fn_call(self) -> bool:
         if self.value_expr is None:
             return False
         from pixeltable import exprs
+
         l = list(self.value_expr.subexprs(filter=lambda e: isinstance(e, exprs.FunctionCall) and e.is_window_fn_call))
         return len(l) > 0
 
@@ -177,6 +190,7 @@ class Column:
         If this is a computed col and the top-level expr is a function call, print the source, if possible.
         """
         from pixeltable import exprs
+
         if self.value_expr is None or not isinstance(self.value_expr, exprs.FunctionCall):
             return
         self.value_expr.fn.source()
@@ -188,8 +202,10 @@ class Column:
         assert self.is_stored
         # all storage columns are nullable (we deal with null errors in Pixeltable directly)
         self.sa_col = sql.Column(
-            self.store_name(), self.col_type.to_sa_type() if self.sa_col_type is None else self.sa_col_type,
-            nullable=True)
+            self.store_name(),
+            self.col_type.to_sa_type() if self.sa_col_type is None else self.sa_col_type,
+            nullable=True,
+        )
         if self.is_computed or self.col_type.is_media_type():
             self.sa_errormsg_col = sql.Column(self.errormsg_store_name(), ts.StringType().to_sa_type(), nullable=True)
             self.sa_errortype_col = sql.Column(self.errortype_store_name(), ts.StringType().to_sa_type(), nullable=True)

{pixeltable-0.3.2 → pixeltable-0.3.3}/pixeltable/catalog/dir.py

@@ -6,13 +6,14 @@ from uuid import UUID
 
 import sqlalchemy as sql
 
-from .schema_object import SchemaObject
 from pixeltable.env import Env
 from pixeltable.metadata import schema
 
+from .schema_object import SchemaObject
 
 _logger = logging.getLogger('pixeltable')
 
+
 class Dir(SchemaObject):
     def __init__(self, id: UUID, parent_id: UUID, name: str):
         super().__init__(id, name, parent_id)
@@ -23,8 +24,9 @@ class Dir(SchemaObject):
 
     @property
     def _has_dependents(self) -> bool:
-        """ Returns True if this directory has any children. """
+        """Returns True if this directory has any children."""
         from pixeltable.catalog import Catalog, Path
+
         return len(Catalog.get().paths.get_children(Path(self._path), child_type=None, recursive=False)) > 0
 
     def _move(self, new_name: str, new_dir_id: UUID) -> None:
@@ -34,5 +36,5 @@ class Dir(SchemaObject):
             conn.execute(
                 sql.update(schema.Dir.__table__)
                 .values({schema.Dir.parent_id: self._dir_id, schema.Dir.md: dataclasses.asdict(dir_md)})
-                .where(schema.Dir.id == self._id))
-
+                .where(schema.Dir.id == self._id)
+            )

{pixeltable-0.3.2 → pixeltable-0.3.3}/pixeltable/catalog/globals.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import dataclasses
 import enum
 import itertools
@@ -23,6 +24,7 @@ class UpdateStatus:
     """
     Information about updates that resulted from a table operation.
     """
+
     num_rows: int = 0
     # TODO: disambiguate what this means: # of slots computed or # of columns computed?
     num_computed_values: int = 0
@@ -51,6 +53,7 @@ class MediaValidation(enum.Enum):
             val_strs = ', '.join(f'{s.lower()!r}' for s in cls.__members__.keys())
             raise excs.Error(f'{error_prefix} must be one of: [{val_strs}]')
 
+
 class IfExistsParam(enum.Enum):
     ERROR = 0
     IGNORE = 1
@@ -65,6 +68,7 @@ class IfExistsParam(enum.Enum):
             val_strs = ', '.join(f'{s.lower()!r}' for s in cls.__members__.keys())
             raise excs.Error(f'{param_name} must be one of: [{val_strs}]')
 
+
 class IfNotExistsParam(enum.Enum):
     ERROR = 0
     IGNORE = 1
@@ -77,10 +81,12 @@ class IfNotExistsParam(enum.Enum):
             val_strs = ', '.join(f'{s.lower()!r}' for s in cls.__members__.keys())
             raise excs.Error(f'{param_name} must be one of: [{val_strs}]')
 
+
 def is_valid_identifier(name: str) -> bool:
     return name.isidentifier() and not name.startswith('_')
 
-def is_valid_path(path: str, empty_is_valid : bool) -> bool:
+
+def is_valid_path(path: str, empty_is_valid: bool) -> bool:
     if path == '':
         return empty_is_valid
 
@@ -89,6 +95,7 @@ def is_valid_path(path: str, empty_is_valid : bool) -> bool:
             return False
     return True
 
+
 def is_system_column_name(name: str) -> bool:
     from pixeltable.catalog import InsertableTable, View
 

{pixeltable-0.3.2 → pixeltable-0.3.3}/pixeltable/catalog/insertable_table.py

@@ -35,8 +35,15 @@ class InsertableTable(Table):
     # MODULE-LOCAL, NOT PUBLIC
     @classmethod
     def _create(
-        cls, dir_id: UUID, name: str, schema: dict[str, ts.ColumnType], df: Optional[pxt.DataFrame],
-        primary_key: list[str], num_retained_versions: int, comment: str, media_validation: MediaValidation
+        cls,
+        dir_id: UUID,
+        name: str,
+        schema: dict[str, ts.ColumnType],
+        df: Optional[pxt.DataFrame],
+        primary_key: list[str],
+        num_retained_versions: int,
+        comment: str,
+        media_validation: MediaValidation,
     ) -> InsertableTable:
         columns = cls._create_columns(schema)
         cls._verify_schema(columns)
@@ -51,8 +58,14 @@ class InsertableTable(Table):
 
         with orm.Session(Env.get().engine, future=True) as session:
             _, tbl_version = TableVersion.create(
-                session, dir_id, name, columns, num_retained_versions=num_retained_versions, comment=comment,
-                media_validation=media_validation)
+                session,
+                dir_id,
+                name,
+                columns,
+                num_retained_versions=num_retained_versions,
+                comment=comment,
+                media_validation=media_validation,
+            )
             tbl = cls(dir_id, tbl_version)
             # TODO We need to commit before doing the insertion, in order to avoid a primary key (version) collision
             #   when the table metadata gets updated. Once we have a notion of user-defined transactions in
@@ -84,16 +97,12 @@ class InsertableTable(Table):
         /,
         *,
         print_stats: bool = False,
-        on_error: Literal['abort', 'ignore'] = 'abort'
+        on_error: Literal['abort', 'ignore'] = 'abort',
     ) -> UpdateStatus: ...
 
     @overload
     def insert(
-        self,
-        *,
-        print_stats: bool = False,
-        on_error: Literal['abort', 'ignore'] = 'abort',
-        **kwargs: Any
+        self, *, print_stats: bool = False, on_error: Literal['abort', 'ignore'] = 'abort', **kwargs: Any
     ) -> UpdateStatus: ...
 
     def insert(  # type: ignore[misc]
@@ -103,7 +112,7 @@ class InsertableTable(Table):
         *,
         print_stats: bool = False,
         on_error: Literal['abort', 'ignore'] = 'abort',
-        **kwargs: Any
+        **kwargs: Any,
     ) -> UpdateStatus:
         if rows is None:
             rows = [kwargs]
@@ -127,8 +136,9 @@ class InsertableTable(Table):
         if status.num_excs == 0:
             cols_with_excs_str = ''
         else:
-            cols_with_excs_str = \
+            cols_with_excs_str = (
                 f' across {len(status.cols_with_excs)} column{"" if len(status.cols_with_excs) == 1 else "s"}'
+            )
             cols_with_excs_str += f' ({", ".join(status.cols_with_excs)})'
         msg = (
             f'Inserted {status.num_rows} row{"" if status.num_rows == 1 else "s"} '

{pixeltable-0.3.2 → pixeltable-0.3.3}/pixeltable/catalog/named_function.py

@@ -6,18 +6,20 @@ from uuid import UUID
 
 import sqlalchemy as sql
 
-from .schema_object import SchemaObject
 from pixeltable.env import Env
 from pixeltable.metadata import schema
 
+from .schema_object import SchemaObject
 
 _logger = logging.getLogger('pixeltable')
 
+
 class NamedFunction(SchemaObject):
     """
     Contains references to functions that are named and have a path.
     The Function itself is stored in the FunctionRegistry.
     """
+
     def __init__(self, id: UUID, dir_id: UUID, name: str):
         super().__init__(id, name, dir_id)
 
@@ -32,9 +34,11 @@ class NamedFunction(SchemaObject):
     def _move(self, new_name: str, new_dir_id: UUID) -> None:
         super()._move(new_name, new_dir_id)
         with Env.get().engine.begin() as conn:
-            stmt = sql.text((
-                f"UPDATE {schema.Function.__table__} "
-                f"SET {schema.Function.dir_id.name} = :new_dir_id, {schema.Function.md.name}['name'] = :new_name "
-                f"WHERE {schema.Function.id.name} = :id"))
+            stmt = sql.text(
+                (
+                    f'UPDATE {schema.Function.__table__} '
+                    f"SET {schema.Function.dir_id.name} = :new_dir_id, {schema.Function.md.name}['name'] = :new_name "
+                    f'WHERE {schema.Function.id.name} = :id'
+                )
+            )
             conn.execute(stmt, {'new_dir_id': new_dir_id, 'new_name': json.dumps(new_name), 'id': self._id})
-

{pixeltable-0.3.2 → pixeltable-0.3.3}/pixeltable/catalog/path.py

@@ -3,10 +3,12 @@ from __future__ import annotations
 import logging
 
 from pixeltable import exceptions as excs
+
 from .globals import is_valid_path
 
 _logger = logging.getLogger('pixeltable')
 
+
 class Path:
     def __init__(self, path: str, empty_is_valid: bool = False):
         if not is_valid_path(path, empty_is_valid):
@@ -50,9 +52,8 @@ class Path:
             return False
         if self.is_root and (other.len == 1 or not is_parent):
             return True
-        is_prefix = self.components == other.components[:self.len]
+        is_prefix = self.components == other.components[: self.len]
         return is_prefix and (self.len == (other.len - 1) or not is_parent)
 
     def __str__(self) -> str:
         return '.'.join(self.components)
-

{pixeltable-0.3.2 → pixeltable-0.3.3}/pixeltable/catalog/path_dict.py

@@ -17,8 +17,10 @@ from .schema_object import SchemaObject
 
 _logger = logging.getLogger('pixeltable')
 
+
 class PathDict:
     """Keep track of all paths in a Db instance"""
+
     def __init__(self):
         self.dir_contents: dict[UUID, dict[str, SchemaObject]] = {}
         self.schema_objs: dict[UUID, SchemaObject] = {}
@@ -64,7 +66,7 @@ class PathDict:
         """
         schema_obj = self.get_object(path)
         if schema_obj is None:
-            raise excs.Error(f"No such path: {str(path)}")
+            raise excs.Error(f'No such path: {str(path)}')
         return schema_obj
 
     def get_object(self, path: Path) -> Optional[SchemaObject]:
@@ -86,11 +88,11 @@ class PathDict:
             if component not in self.dir_contents[dir._id]:
                 if i == len(path.components) - 1:
                     return None
-                raise excs.Error(f'No such path: {".".join(path.components[:i + 1])}')
+                raise excs.Error(f'No such path: {".".join(path.components[: i + 1])}')
             schema_obj = self.dir_contents[dir._id][component]
             if i < len(path.components) - 1:
                 if not isinstance(schema_obj, Dir):
-                    raise excs.Error(f'Not a directory: {".".join(path.components[:i + 1])}')
+                    raise excs.Error(f'Not a directory: {".".join(path.components[: i + 1])}')
                 dir = schema_obj
         return schema_obj
 
@@ -145,10 +147,11 @@ class PathDict:
         obj = self.get_object(path)
         if expected is not None:
             if obj is None:
-                raise excs.Error(f"No such path: {str(path)}")
+                raise excs.Error(f'No such path: {str(path)}')
             if not isinstance(obj, expected):
                 raise excs.Error(
-                    f'{str(path)} needs to be a {expected._display_name()} but is a {type(obj)._display_name()}')
+                    f'{str(path)} needs to be a {expected._display_name()} but is a {type(obj)._display_name()}'
+                )
         if expected is None and obj is not None:
             raise excs.Error(f"{type(obj)._display_name()} '{str(path)}' already exists")
 
@@ -164,4 +167,3 @@ class PathDict:
             for dir in [obj for obj in self.dir_contents[dir._id].values() if isinstance(obj, Dir)]:
                 result.extend(self.get_children(copy.copy(parent).append(dir._name), child_type, recursive))
         return result
-