pixeltable 0.3.7__py3-none-any.whl → 0.3.8__py3-none-any.whl

pixeltable/exprs/row_builder.py

@@ -8,9 +8,7 @@ from uuid import UUID
 
 import numpy as np
 
-import pixeltable.catalog as catalog
-import pixeltable.exceptions as excs
-import pixeltable.utils as utils
+from pixeltable import catalog, exceptions as excs, utils
 from pixeltable.env import Env
 from pixeltable.utils.media_store import MediaStore
 
@@ -366,8 +364,8 @@ class RowBuilder:
     def set_exc(self, data_row: DataRow, slot_idx: int, exc: Exception) -> None:
         """Record an exception in data_row and propagate it to dependents"""
         data_row.set_exc(slot_idx, exc)
-        for slot_idx in self._exc_dependents[slot_idx]:
-            data_row.set_exc(slot_idx, exc)
+        for idx in self._exc_dependents[slot_idx]:
+            data_row.set_exc(idx, exc)
 
     def eval(
         self,

pixeltable/exprs/rowid_ref.py

@@ -1,21 +1,17 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, cast
+from typing import Any, Optional, cast
 from uuid import UUID
 
 import sqlalchemy as sql
 
-import pixeltable.catalog as catalog
-import pixeltable.type_system as ts
+from pixeltable import catalog, type_system as ts
 
 from .data_row import DataRow
 from .expr import Expr
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
 
-if TYPE_CHECKING:
-    from pixeltable import store
-
 
 class RowidRef(Expr):
     """A reference to a part of a table rowid
@@ -68,7 +64,8 @@ class RowidRef(Expr):
         )
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [
+        return [
+            *super()._id_attrs(),
             ('normalized_base_id', self.normalized_base_id),
             ('idx', self.rowid_component_idx),
         ]

pixeltable/exprs/similarity_expr.py

@@ -62,14 +62,14 @@ class SimilarityExpr(Expr):
         return f'{self.components[0]}.similarity({self.components[1]})'
 
     def _id_attrs(self):
-        return super()._id_attrs() + [('idx_name', self.idx_info.name)]
+        return [*super()._id_attrs(), ('idx_name', self.idx_info.name)]
 
     def default_column_name(self) -> str:
         return 'similarity'
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         if not isinstance(self.components[1], Literal):
-            raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
+            raise excs.Error('similarity(): requires a string or a PIL.Image.Image object, not an expression')
         item = self.components[1].val
         from pixeltable import index
 
@@ -78,7 +78,7 @@ class SimilarityExpr(Expr):
 
     def as_order_by_clause(self, is_asc: bool) -> Optional[sql.ColumnElement]:
         if not isinstance(self.components[1], Literal):
-            raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
+            raise excs.Error('similarity(): requires a string or a PIL.Image.Image object, not an expression')
         item = self.components[1].val
         from pixeltable import index
 
@@ -87,14 +87,14 @@ class SimilarityExpr(Expr):
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         # this should never get called
-        assert False
+        raise AssertionError()
 
     def _as_dict(self) -> dict:
         return {'idx_name': self.idx_info.name, **super()._as_dict()}
 
     @classmethod
     def _from_dict(cls, d: dict, components: list[Expr]) -> 'SimilarityExpr':
-        iname = d['idx_name'] if 'idx_name' in d else None
+        iname = d.get('idx_name')
         assert len(components) == 2
         assert isinstance(components[0], ColumnRef)
         return cls(components[0], components[1], idx_name=iname)

pixeltable/exprs/sql_element_cache.py

@@ -1,4 +1,4 @@
-from typing import Iterable, Optional, Union, cast
+from typing import Iterable, Optional
 
 import sqlalchemy as sql
 

pixeltable/exprs/type_cast.py

@@ -1,9 +1,8 @@
-from typing import Any, Optional, Union
+from typing import Optional
 
 import sqlalchemy as sql
 
-import pixeltable.exprs as exprs
-import pixeltable.type_system as ts
+from pixeltable import type_system as ts
 
 from .expr import DataRow, Expr
 from .literal import Literal

pixeltable/exprs/variable.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Any, NoReturn
 
-import pixeltable.type_system as ts
+from pixeltable import type_system as ts
 
 from .data_row import DataRow
 from .expr import Expr
@@ -22,7 +22,7 @@ class Variable(Expr):
         self.id = self._create_id()
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('name', self.name)]
+        return [*super()._id_attrs(), ('name', self.name)]
 
     def default_column_name(self) -> NoReturn:
         raise NotImplementedError()

pixeltable/ext/__init__.py

@@ -4,6 +4,8 @@ are not intended for production use. Long-term support cannot be guaranteed, usu
 have dependencies whose future support is unclear.
 """
 
+# ruff: noqa: F401
+
 from pixeltable.utils.code import local_public_names
 
 from . import functions

pixeltable/ext/functions/__init__.py

@@ -1,3 +1,5 @@
+# ruff: noqa: F401
+
 from pixeltable.utils.code import local_public_names
 
 from . import whisperx, yolox

pixeltable/ext/functions/yolox.py

@@ -111,10 +111,10 @@ def _images_to_tensors(images: Iterable[PIL.Image.Image], exp: 'Exp') -> Iterato
     import torch
     from yolox.data import ValTransform  # type: ignore[import-untyped]
 
-    _val_transform = ValTransform(legacy=False)
+    val_transform = ValTransform(legacy=False)
     for image in images:
-        image = normalize_image_mode(image)
-        image_transform, _ = _val_transform(np.array(image), None, exp.test_size)
+        normalized_image = normalize_image_mode(image)
+        image_transform, _ = val_transform(np.array(normalized_image), None, exp.test_size)
         yield torch.from_numpy(image_transform)
 
 

pixeltable/func/__init__.py

@@ -1,3 +1,5 @@
+# ruff: noqa: F401
+
 from .aggregate_function import AggregateFunction, Aggregator, uda
 from .callable_function import CallableFunction
 from .expr_template_function import ExprTemplateFunction

pixeltable/func/aggregate_function.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import abc
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, overload
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, Sequence, overload
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
@@ -16,11 +16,11 @@ if TYPE_CHECKING:
 
 
 class Aggregator(abc.ABC):
-    def update(self, *args: Any, **kwargs: Any) -> None:
-        pass
+    @abc.abstractmethod
+    def update(self, *args: Any, **kwargs: Any) -> None: ...
 
-    def value(self) -> Any:
-        pass
+    @abc.abstractmethod
+    def value(self) -> Any: ...
 
 
 class AggregateFunction(Function):
@@ -32,9 +32,9 @@ class AggregateFunction(Function):
     allows_window: if True, the aggregate function can be used with a window
     """
 
-    ORDER_BY_PARAM = 'order_by'
-    GROUP_BY_PARAM = 'group_by'
-    RESERVED_PARAMS = {ORDER_BY_PARAM, GROUP_BY_PARAM}
+    ORDER_BY_PARAM: ClassVar[str] = 'order_by'
+    GROUP_BY_PARAM: ClassVar[str] = 'group_by'
+    RESERVED_PARAMS: ClassVar[set[str]] = {ORDER_BY_PARAM, GROUP_BY_PARAM}
 
     agg_classes: list[type[Aggregator]]  # classes for each signature, in signature order
     init_param_names: list[list[str]]  # names of the __init__ parameters for each signature
@@ -124,7 +124,7 @@ class AggregateFunction(Function):
             )
             for i, p in enumerate(py_init_params)
         ]
-        duplicate_params = set(p.name for p in init_params) & set(p.name for p in update_params)
+        duplicate_params = {p.name for p in init_params} & {p.name for p in update_params}
         if len(duplicate_params) > 0:
             raise excs.Error(
                 f'__init__() and update() cannot have parameters with the same name: {", ".join(duplicate_params)}'

pixeltable/func/callable_function.py

@@ -98,11 +98,10 @@ class CallableFunction(Function):
                 result = self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs)
             assert len(result) == 1
             return result[0]
+        elif inspect.iscoroutinefunction(self.py_fn):
+            return asyncio.run(self.py_fn(*args, **kwargs))
         else:
-            if inspect.iscoroutinefunction(self.py_fn):
-                return asyncio.run(self.py_fn(*args, **kwargs))
-            else:
-                return self.py_fn(*args, **kwargs)
+            return self.py_fn(*args, **kwargs)
 
     async def aexec_batch(self, *args: Any, **kwargs: Any) -> list:
         """Execute the function with the given arguments and return the result.

pixeltable/func/expr_template_function.py

@@ -1,8 +1,6 @@
-import inspect
 from typing import Any, Optional, Sequence
 
-import pixeltable
-import pixeltable.exceptions as excs
+from pixeltable import exceptions as excs, exprs
 
 from .function import Function
 from .signature import Signature
@@ -15,13 +13,11 @@ class ExprTemplate:
     `CallableFunction`.)
     """
 
-    expr: 'pixeltable.exprs.Expr'
+    expr: 'exprs.Expr'
     signature: Signature
-    param_exprs: dict[str, 'pixeltable.exprs.Variable']
-
-    def __init__(self, expr: 'pixeltable.exprs.Expr', signature: Signature):
-        from pixeltable import exprs
+    param_exprs: dict[str, 'exprs.Variable']
 
+    def __init__(self, expr: 'exprs.Expr', signature: Signature):
         self.expr = expr
         self.signature = signature
 
@@ -59,9 +55,7 @@ class ExprTemplateFunction(Function):
         assert not self.is_polymorphic
         return self.templates[0]
 
-    def instantiate(self, args: Sequence[Any], kwargs: dict[str, Any]) -> 'pixeltable.exprs.Expr':
-        from pixeltable import exprs
-
+    def instantiate(self, args: Sequence[Any], kwargs: dict[str, Any]) -> 'exprs.Expr':
         assert not self.is_polymorphic
         template = self.template
         bound_args = self.signature.py_signature.bind(*args, **kwargs).arguments
@@ -86,14 +80,12 @@ class ExprTemplateFunction(Function):
         return result
 
     def _docstring(self) -> Optional[str]:
-        from pixeltable import exprs
-
         if isinstance(self.templates[0].expr, exprs.FunctionCall):
             return self.templates[0].expr.fn._docstring()
         return None
 
     def exec(self, args: Sequence[Any], kwargs: dict[str, Any]) -> Any:
-        from pixeltable import exec, exprs
+        from pixeltable import exec
 
         assert not self.is_polymorphic
         expr = self.instantiate(args, kwargs)
@@ -130,7 +122,5 @@ class ExprTemplateFunction(Function):
         if 'expr' not in d:
             return super()._from_dict(d)
         assert 'signature' in d and 'name' in d
-        import pixeltable.exprs as exprs
-
         template = ExprTemplate(exprs.Expr.from_dict(d['expr']), Signature.from_dict(d['signature']))
         return cls([template], name=d['name'])

pixeltable/func/function.py

@@ -246,7 +246,7 @@ class Function(ABC):
         # `None` when any of its non-nullable inputs are `None`.
         for arg_name, arg in bound_args.items():
             param = self.signature.parameters[arg_name]
-            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+            if param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}:
                 continue
             if arg.col_type.nullable and not param.col_type.nullable:
                 return_type = return_type.copy(nullable=True)
@@ -304,13 +304,12 @@ class Function(ABC):
                     callable_args[param.name] = arg
                 else:
                     return None
-            else:
+            elif isinstance(arg, exprs.Literal):
                 # The callable is expecting `param.name` to be a constant Python value. Unpack a Literal if we find
                 # one; otherwise return None.
-                if isinstance(arg, exprs.Literal):
-                    callable_args[param.name] = arg.val
-                else:
-                    return None
+                callable_args[param.name] = arg.val
+            else:
+                return None
 
         return callable_args
 
@@ -386,10 +385,10 @@ class Function(ABC):
             else:
                 var = exprs.Variable(name, param.col_type)
                 bindings[name] = var
-                if args_ok and param.kind in (
+                if args_ok and param.kind in {
                     inspect.Parameter.POSITIONAL_ONLY,
                     inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                ):
+                }:
                     template_args.append(var)
                 else:
                     template_kwargs[name] = var
@@ -436,6 +435,9 @@ class Function(ABC):
             return False
         return self.self_path == other.self_path
 
+    def __hash__(self) -> int:
+        return hash(self.self_path)
+
     def source(self) -> None:
         """Print source code"""
         print('source not available')

pixeltable/func/function_registry.py

@@ -9,9 +9,7 @@ from uuid import UUID
 
 import sqlalchemy as sql
 
-import pixeltable.env as env
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
+from pixeltable import env, exceptions as excs, type_system as ts
 from pixeltable.metadata import schema
 
 from .function import Function

pixeltable/func/query_template_function.py

@@ -1,13 +1,9 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, overload
+from typing import TYPE_CHECKING, Any, Callable, Optional, overload
 
-import sqlalchemy as sql
-
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
-from pixeltable import exprs
+from pixeltable import exprs, type_system as ts
 
 from .function import Function
 from .signature import Signature

pixeltable/func/signature.py

@@ -2,10 +2,9 @@ from __future__ import annotations
 
 import dataclasses
 import inspect
-import json
 import logging
 import typing
-from typing import TYPE_CHECKING, Any, Callable, Optional
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
@@ -69,6 +68,9 @@ class Parameter:
         py_default = self.default.val if self.default is not None else inspect.Parameter.empty
         return inspect.Parameter(self.name, self.kind, default=py_default)
 
+    def __hash__(self) -> int:
+        return hash((self.name, self.col_type, self.kind, self.default, self.is_batched))
+
 
 T = typing.TypeVar('T')
 Batch = typing.Annotated[list[T], 'pxt-batch']
@@ -81,7 +83,7 @@ class Signature:
     - self.is_batched: return type is a Batch[...] type
     """
 
-    SPECIAL_PARAM_NAMES = ['group_by', 'order_by']
+    SPECIAL_PARAM_NAMES: ClassVar[list[str]] = ['group_by', 'order_by']
 
     def __init__(self, return_type: ts.ColumnType, parameters: list[Parameter], is_batched: bool = False):
         assert isinstance(return_type, ts.ColumnType)
@@ -135,26 +137,28 @@ class Signature:
             if (
                 param.kind != other_param.kind
                 or (param.col_type is None) != (other_param.col_type is None)  # this can happen if they are varargs
-                or param.col_type is not None
-                and not other_param.col_type.is_supertype_of(param.col_type, ignore_nullable=True)
+                or (
+                    param.col_type is not None
+                    and not other_param.col_type.is_supertype_of(param.col_type, ignore_nullable=True)
+                )
             ):
                 return False
 
         # Check (iii)
-        for other_param in other.required_parameters:
+        for other_param in other.required_parameters:  # noqa: SIM110
             if other_param.name not in self.parameters:
                 return False
 
         return True
 
     def validate_args(self, bound_args: dict[str, Optional['exprs.Expr']], context: str = '') -> None:
-        if context != '':
+        if context:
             context = f' ({context})'
 
         for param_name, arg in bound_args.items():
             assert param_name in self.parameters
             param = self.parameters[param_name]
-            is_var_param = param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+            is_var_param = param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}
             if is_var_param:
                 continue
             assert param.col_type is not None
@@ -191,6 +195,9 @@ class Signature:
                 return False
         return True
 
+    def __hash__(self) -> int:
+        return hash((self.return_type, self.parameters))
+
     def __str__(self) -> str:
         param_strs: list[str] = []
         for p in self.parameters.values():
@@ -199,8 +206,8 @@ class Signature:
             elif p.kind == inspect.Parameter.VAR_KEYWORD:
                 param_strs.append(f'**{p.name}')
             else:
-                param_strs.append(f'{p.name}: {str(p.col_type)}')
-        return f'({", ".join(param_strs)}) -> {str(self.get_return_type())}'
+                param_strs.append(f'{p.name}: {p.col_type}')
+        return f'({", ".join(param_strs)}) -> {self.get_return_type()}'
 
     @classmethod
     def _infer_type(cls, annotation: Optional[type]) -> tuple[Optional[ts.ColumnType], Optional[bool]]:
@@ -213,7 +220,7 @@ class Signature:
             type_args = typing.get_args(annotation)
             if len(type_args) == 2 and type_args[1] == 'pxt-batch':
                 # this is our Batch
-                assert typing.get_origin(type_args[0]) == list
+                assert typing.get_origin(type_args[0]) is list
                 is_batched = True
                 py_type = typing.get_args(type_args[0])[0]
         if py_type is None:
@@ -246,7 +253,7 @@ class Signature:
                 continue  # skip 'self' or 'cls' parameter
             if param.name in cls.SPECIAL_PARAM_NAMES:
                 raise excs.Error(f'{param.name!r} is a reserved parameter name')
-            if param.kind == inspect.Parameter.VAR_POSITIONAL or param.kind == inspect.Parameter.VAR_KEYWORD:
+            if param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}:
                 parameters.append(Parameter(param.name, col_type=None, kind=param.kind))
                 continue
 
@@ -257,11 +264,8 @@ class Signature:
                 param_type = param_types[idx]
                 is_batched = False
             else:
-                py_type: Optional[type]
-                if param.annotation in type_substitutions:
-                    py_type = type_substitutions[param.annotation]
-                else:
-                    py_type = param.annotation
+                # Look up the substitution for param.annotation, defaulting to param.annotation if there is none
+                py_type = type_substitutions.get(param.annotation, param.annotation)
                 param_type, is_batched = cls._infer_type(py_type)
                 if param_type is None:
                     raise excs.Error(f'Cannot infer pixeltable type for parameter {param.name!r}')
@@ -297,11 +301,8 @@ class Signature:
         )
         sig = inspect.signature(py_fn)
         if return_type is None:
-            py_type: Optional[type]
-            if sig.return_annotation in type_substitutions:
-                py_type = type_substitutions[sig.return_annotation]
-            else:
-                py_type = sig.return_annotation
+            # Look up the substitution for sig.return_annotation, defaulting to return_annotation if there is none
+            py_type = type_substitutions.get(sig.return_annotation, sig.return_annotation)
             return_type, return_is_batched = cls._infer_type(py_type)
             if return_type is None:
                 raise excs.Error('Cannot infer pixeltable return type')

pixeltable/func/tools.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
 
 import pydantic
 
@@ -69,7 +69,7 @@ class Tool(pydantic.BaseModel):
             return _extract_float_tool_arg(kwargs, param_name=param.name)
         if param.col_type.is_bool_type():
             return _extract_bool_tool_arg(kwargs, param_name=param.name)
-        assert False
+        raise AssertionError()
 
 
 class ToolChoice(pydantic.BaseModel):
@@ -113,7 +113,7 @@ class Tools(pydantic.BaseModel):
                 )
                 tool_name = tool_obj.name or tool_obj.fn.name
             except StopIteration:
-                raise excs.Error(f'That tool is not in the specified list of tools: {tool}')
+                raise excs.Error(f'That tool is not in the specified list of tools: {tool}') from None
         return ToolChoice(auto=auto, required=required, tool=tool_name, parallel_tool_calls=parallel_tool_calls)
 
 

pixeltable/func/udf.py

@@ -146,7 +146,8 @@ def make_function(
             raise excs.Error(f'Cannot specify both `is_method` and `is_property` (in function `{function_name}`)')
         if is_property and len(sig.parameters) != 1:
             raise excs.Error(
-                f'`is_property=True` expects a UDF with exactly 1 parameter, but `{function_name}` has {len(sig.parameters)}'
+                '`is_property=True` expects a UDF with exactly 1 parameter, but '
+                f'`{function_name}` has {len(sig.parameters)}'
             )
         if (is_method or is_property) and function_path is None:
             raise excs.Error('Stored functions cannot be declared using `is_method` or `is_property`')
@@ -205,6 +206,8 @@ def expr_udf(*, param_types: Optional[list[ts.ColumnType]] = None) -> Callable[[
 
 def expr_udf(*args: Any, **kwargs: Any) -> Any:
     def make_expr_template(py_fn: Callable, param_types: Optional[list[ts.ColumnType]]) -> ExprTemplateFunction:
+        from pixeltable import exprs
+
         if py_fn.__module__ != '__main__' and py_fn.__name__.isidentifier():
             # this is a named function in a module
             function_path = f'{py_fn.__module__}.{py_fn.__qualname__}'
@@ -216,7 +219,6 @@ def expr_udf(*args: Any, **kwargs: Any) -> Any:
 
         # construct Signature from the function signature
         sig = Signature.create(py_fn=py_fn, param_types=param_types, return_type=ts.InvalidType())
-        import pixeltable.exprs as exprs
 
         var_exprs = [exprs.Variable(param.name, param.col_type) for param in sig.parameters.values()]
         # call the function with the parameter expressions to construct an Expr with parameters
@@ -260,7 +262,7 @@ def from_table(
     """
     from pixeltable import exprs
 
-    ancestors = [tbl] + tbl._bases
+    ancestors = [tbl, *tbl._bases]
     ancestors.reverse()  # We must traverse the ancestors in order from base to derived
 
     subst: dict[exprs.Expr, exprs.Expr] = {}

pixeltable/share/__init__.py

@@ -1 +1,3 @@
+# ruff: noqa: F401
+
 from .publish import publish_snapshot

pixeltable/share/packager.py

@@ -66,8 +66,8 @@ class TablePackager:
                 'tables': [
                     {
                         'table_id': str(t._tbl_version.id),
-                        # These are temporary; will replace with a better solution once the concurrency changes to catalog have
-                        # been merged
+                        # These are temporary; will replace with a better solution once the concurrency
+                        # changes to catalog have been merged
                         'table_md': dataclasses.asdict(t._tbl_version.get()._create_tbl_md()),
                         'table_version_md': dataclasses.asdict(
                             t._tbl_version.get()._create_version_md(datetime.now().timestamp())
@@ -98,7 +98,7 @@ class TablePackager:
             for t in ancestors:
                 _logger.info(f"Exporting table '{t._path}'.")
                 self.__export_table(t)
-        _logger.info(f'Building archive.')
+        _logger.info('Building archive.')
         bundle_path = self.__build_tarball()
         _logger.info(f'Packaging complete: {bundle_path}')
         return bundle_path

pixeltable/share/publish.py

@@ -1,16 +1,14 @@
-import dataclasses
 import os
 import sys
 import urllib.parse
 import urllib.request
-from datetime import datetime
 from pathlib import Path
 
 import requests
 from tqdm import tqdm
 
 import pixeltable as pxt
-from pixeltable import exceptions as excs, metadata
+from pixeltable import exceptions as excs
 from pixeltable.env import Env
 from pixeltable.utils import sha256sum
 
@@ -46,7 +44,7 @@ def publish_snapshot(dest_tbl_uri: str, src_tbl: pxt.Table) -> str:
     else:
         raise excs.Error(f'Unsupported destination: {destination_uri}')
 
-    Env.get().console_logger.info(f'Finalizing snapshot ...')
+    Env.get().console_logger.info('Finalizing snapshot ...')
 
     finalize_request_json = {
         'upload_id': upload_id,
@@ -83,7 +81,7 @@ def _upload_bundle_to_s3(bundle: Path, parsed_location: urllib.parse.ParseResult
     upload_args = {'ChecksumAlgorithm': 'SHA256'}
 
     progress_bar = tqdm(
-        desc=f'Uploading',
+        desc='Uploading',
         total=bundle.stat().st_size,
         unit='B',
         unit_scale=True,

pixeltable/utils/coco.py

@@ -103,7 +103,7 @@ def write_coco_dataset(df: pxt.DataFrame, dest_path: Path) -> Path:
         # create annotation records for this image
         for annotation in input_dict['annotations']:
             ann_id += 1
-            x, y, w, h = annotation['bbox']
+            _, _, w, h = annotation['bbox']
             category = annotation['category']
             categories.add(category)
             annotations.append(
@@ -119,7 +119,7 @@ def write_coco_dataset(df: pxt.DataFrame, dest_path: Path) -> Path:
             )
 
     # replace category names with ids
-    category_ids = {category: id for id, category in enumerate(sorted(list(categories)))}
+    category_ids = {category: id for id, category in enumerate(sorted(categories))}
     for annotation in annotations:
         annotation['category_id'] = category_ids[annotation['category_id']]
 
@@ -129,8 +129,8 @@ def write_coco_dataset(df: pxt.DataFrame, dest_path: Path) -> Path:
         'categories': [{'id': id, 'name': category} for category, id in category_ids.items()],
     }
     output_path = dest_path / 'data.json'
-    with open(output_path, 'w') as f:
-        json.dump(result, f)
+    with open(output_path, 'w', encoding='utf-8') as fp:
+        json.dump(result, fp)
     return output_path