pixeltable 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

pixeltable/store.py

@@ -32,6 +32,7 @@ class StoreBase:
     - v_min: version at which the row was created
     - v_max: version at which the row was deleted (or MAX_VERSION if it's still live)
     """
+
     tbl_version: catalog.TableVersion
     sa_md: sql.MetaData
     sa_tbl: Optional[sql.Table]
@@ -65,8 +66,9 @@ class StoreBase:
         """Create and return system columns"""
         rowid_cols = self._create_rowid_columns()
         self.v_min_col = sql.Column('v_min', sql.BigInteger, nullable=False)
-        self.v_max_col = \
-            sql.Column('v_max', sql.BigInteger, nullable=False, server_default=str(schema.Table.MAX_VERSION))
+        self.v_max_col = sql.Column(
+            'v_max', sql.BigInteger, nullable=False, server_default=str(schema.Table.MAX_VERSION)
+        )
         self._pk_cols = [*rowid_cols, self.v_min_col]
         return [*rowid_cols, self.v_min_col, self.v_max_col]
 
@@ -134,7 +136,7 @@ class StoreBase:
         return new_file_url
 
     def _move_tmp_media_files(
-            self, table_rows: list[dict[str, Any]], media_cols: list[catalog.Column], v_min: int
+        self, table_rows: list[dict[str, Any]], media_cols: list[catalog.Column], v_min: int
     ) -> None:
         """Move tmp media files that we generated to a permanent location"""
         for c in media_cols:
@@ -143,7 +145,7 @@ class StoreBase:
                 table_row[c.store_name()] = self._move_tmp_media_file(file_url, c, v_min)
 
     def _create_table_row(
-            self, input_row: exprs.DataRow, row_builder: exprs.RowBuilder, exc_col_ids: set[int], pk: tuple[int, ...]
+        self, input_row: exprs.DataRow, row_builder: exprs.RowBuilder, exc_col_ids: set[int], pk: tuple[int, ...]
     ) -> tuple[dict[str, Any], int]:
         """Return Tuple[complete table row, # of exceptions] for insert()
         Creates a row that includes the PK columns, with the values from input_row.pk.
@@ -193,11 +195,13 @@ class StoreBase:
         added_storage_cols = [col.store_name()]
         if col.records_errors:
             # we also need to create the errormsg and errortype storage cols
-            stmt = sql.text(f'ALTER TABLE {self._storage_name()} '
-                            f'ADD COLUMN {col.errormsg_store_name()} VARCHAR DEFAULT NULL')
+            stmt = sql.text(
+                f'ALTER TABLE {self._storage_name()} ADD COLUMN {col.errormsg_store_name()} VARCHAR DEFAULT NULL'
+            )
             conn.execute(stmt)
-            stmt = sql.text(f'ALTER TABLE {self._storage_name()} '
-                            f'ADD COLUMN {col.errortype_store_name()} VARCHAR DEFAULT NULL')
+            stmt = sql.text(
+                f'ALTER TABLE {self._storage_name()} ADD COLUMN {col.errortype_store_name()} VARCHAR DEFAULT NULL'
+            )
             conn.execute(stmt)
             added_storage_cols.extend([col.errormsg_store_name(), col.errortype_store_name()])
         self.create_sa_tbl()
@@ -219,7 +223,7 @@ class StoreBase:
         exec_plan: ExecNode,
         value_expr_slot_idx: int,
         conn: sql.engine.Connection,
-        on_error: Literal['abort', 'ignore']
+        on_error: Literal['abort', 'ignore'],
     ) -> int:
         """Update store column of a computed column with values produced by an execution plan
 
@@ -295,10 +299,9 @@ class StoreBase:
                 update_stmt = update_stmt.where(pk_col == tmp_pk_col)
             update_stmt = update_stmt.values({col.sa_col: tmp_val_col})
             if col.records_errors:
-                update_stmt = update_stmt.values({
-                    col.sa_errortype_col: tmp_errortype_col,
-                    col.sa_errormsg_col: tmp_errormsg_col
-                })
+                update_stmt = update_stmt.values(
+                    {col.sa_errortype_col: tmp_errortype_col, col.sa_errormsg_col: tmp_errormsg_col}
+                )
             log_explain(_logger, update_stmt, conn)
             conn.execute(update_stmt)
 
@@ -308,8 +311,13 @@ class StoreBase:
         return num_excs
 
     def insert_rows(
-            self, exec_plan: ExecNode, conn: sql.engine.Connection, v_min: Optional[int] = None,
-            show_progress: bool = True, rowids: Optional[Iterator[int]] = None, abort_on_exc: bool = False
+        self,
+        exec_plan: ExecNode,
+        conn: sql.engine.Connection,
+        v_min: Optional[int] = None,
+        show_progress: bool = True,
+        rowids: Optional[Iterator[int]] = None,
+        abort_on_exc: bool = False,
     ) -> tuple[int, int, set[int]]:
         """Insert rows into the store table and update the catalog table's md
         Returns:
@@ -347,12 +355,12 @@ class StoreBase:
 
                         if show_progress:
                             if progress_bar is None:
-                                warnings.simplefilter("ignore", category=TqdmWarning)
+                                warnings.simplefilter('ignore', category=TqdmWarning)
                                 progress_bar = tqdm(
                                     desc=f'Inserting rows into `{self.tbl_version.name}`',
                                     unit=' rows',
                                     ncols=100,
-                                    file=sys.stdout
+                                    file=sys.stdout,
                                 )
                             progress_bar.update(1)
 
@@ -379,8 +387,13 @@ class StoreBase:
         return sql.and_(clause, self.base._versions_clause(versions[1:], match_on_vmin))
 
     def delete_rows(
-            self, current_version: int, base_versions: list[Optional[int]], match_on_vmin: bool,
-            where_clause: Optional[sql.ColumnElement[bool]], conn: sql.engine.Connection) -> int:
+        self,
+        current_version: int,
+        base_versions: list[Optional[int]],
+        match_on_vmin: bool,
+        where_clause: Optional[sql.ColumnElement[bool]],
+        conn: sql.engine.Connection,
+    ) -> int:
         """Mark rows as deleted that are live and were created prior to current_version.
         Also: populate the undo columns
         Args:
@@ -394,12 +407,12 @@ class StoreBase:
         """
         where_clause = sql.true() if where_clause is None else where_clause
         where_clause = sql.and_(
-            self.v_min_col < current_version,
-            self.v_max_col == schema.Table.MAX_VERSION,
-            where_clause)
+            self.v_min_col < current_version, self.v_max_col == schema.Table.MAX_VERSION, where_clause
+        )
         rowid_join_clause = self._rowid_join_predicate()
-        base_versions_clause = sql.true() if len(base_versions) == 0 \
-            else self.base._versions_clause(base_versions, match_on_vmin)
+        base_versions_clause = (
+            sql.true() if len(base_versions) == 0 else self.base._versions_clause(base_versions, match_on_vmin)
+        )
         set_clause: dict[sql.Column, Union[int, sql.Column]] = {self.v_max_col: current_version}
         for index_info in self.tbl_version.idxs_by_name.values():
             # copy value column to undo column
@@ -450,7 +463,9 @@ class StoreView(StoreBase):
     def _rowid_join_predicate(self) -> sql.ColumnElement[bool]:
         return sql.and_(
             self.base._rowid_join_predicate(),
-            *[c1 == c2 for c1, c2 in zip(self.rowid_columns(), self.base.rowid_columns())])
+            *[c1 == c2 for c1, c2 in zip(self.rowid_columns(), self.base.rowid_columns())],
+        )
+
 
 class StoreComponentView(StoreView):
     """A view that stores components of its base, as produced by a ComponentIterator
@@ -482,4 +497,5 @@ class StoreComponentView(StoreView):
     def _rowid_join_predicate(self) -> sql.ColumnElement[bool]:
         return sql.and_(
             self.base._rowid_join_predicate(),
-            *[c1 == c2 for c1, c2 in zip(self.rowid_columns()[:-1], self.base.rowid_columns())])
+            *[c1 == c2 for c1, c2 in zip(self.rowid_columns()[:-1], self.base.rowid_columns())],
+        )

pixeltable/type_system.py

@@ -9,17 +9,18 @@ import typing
 import urllib.parse
 import urllib.request
 from pathlib import Path
+
+from typing import _GenericAlias  # type: ignore[attr-defined]  # isort: skip
 from typing import Any, Iterable, Mapping, Optional, Sequence, Union
 
-import PIL.Image
 import av  # type: ignore
 import jsonschema
 import jsonschema.protocols
 import jsonschema.validators
 import numpy as np
+import PIL.Image
 import pydantic
 import sqlalchemy as sql
-from typing import _GenericAlias  # type: ignore[attr-defined]
 from typing_extensions import _AnnotatedAlias
 
 import pixeltable.exceptions as excs
@@ -45,9 +46,11 @@ class ColumnType:
 
         @classmethod
         def supertype(
-                cls, type1: 'ColumnType.Type', type2: 'ColumnType.Type',
-                # we need to pass this in because we can't easily append it as a class member
-                common_supertypes: dict[tuple['ColumnType.Type', 'ColumnType.Type'], 'ColumnType.Type']
+            cls,
+            type1: 'ColumnType.Type',
+            type2: 'ColumnType.Type',
+            # we need to pass this in because we can't easily append it as a class member
+            common_supertypes: dict[tuple['ColumnType.Type', 'ColumnType.Type'], 'ColumnType.Type'],
         ) -> Optional['ColumnType.Type']:
             if type1 == type2:
                 return type1
@@ -59,23 +62,23 @@ class ColumnType:
                 return t
             return None
 
-
     @enum.unique
     class DType(enum.Enum):
         """
         Base type used in images and arrays
         """
-        BOOL = 0,
-        INT8 = 1,
-        INT16 = 2,
-        INT32 = 3,
-        INT64 = 4,
-        UINT8 = 5,
-        UINT16 = 6,
-        UINT32 = 7,
-        UINT64 = 8,
-        FLOAT16 = 9,
-        FLOAT32 = 10,
+
+        BOOL = (0,)
+        INT8 = (1,)
+        INT16 = (2,)
+        INT32 = (3,)
+        INT64 = (4,)
+        UINT8 = (5,)
+        UINT16 = (6,)
+        UINT32 = (7,)
+        UINT64 = (8,)
+        FLOAT16 = (9,)
+        FLOAT32 = (10,)
         FLOAT64 = 11
 
     scalar_types = {Type.STRING, Type.INT, Type.FLOAT, Type.BOOL, Type.TIMESTAMP}
@@ -113,10 +116,7 @@ class ColumnType:
         return json.dumps([t.as_dict() for t in type_list])
 
     def as_dict(self) -> dict:
-        return {
-            '_classname': self.__class__.__name__,
-            **self._as_dict(),
-        }
+        return {'_classname': self.__class__.__name__, **self._as_dict()}
 
     def _as_dict(self) -> dict:
         return {'nullable': self.nullable}
@@ -277,10 +277,7 @@ class ColumnType:
 
     @classmethod
     def from_python_type(
-        cls,
-        t: Union[type, _GenericAlias],
-        nullable_default: bool = False,
-        allow_builtin_types: bool = True
+        cls, t: Union[type, _GenericAlias], nullable_default: bool = False, allow_builtin_types: bool = True
     ) -> Optional[ColumnType]:
         """
         Convert a Python type into a Pixeltable `ColumnType` instance.
@@ -309,9 +306,7 @@ class ColumnType:
             required_args = typing.get_args(t)
             assert len(required_args) == 1
             return cls.from_python_type(
-                required_args[0],
-                nullable_default=False,
-                allow_builtin_types=allow_builtin_types
+                required_args[0], nullable_default=False, allow_builtin_types=allow_builtin_types
             )
         elif origin is typing.Annotated:
             annotated_args = typing.get_args(t)
@@ -349,7 +344,7 @@ class ColumnType:
         cls,
         t: Union[ColumnType, type, _AnnotatedAlias],
         nullable_default: bool = False,
-        allow_builtin_types: bool = True
+        allow_builtin_types: bool = True,
     ) -> ColumnType:
         """
         Convert any type recognizable by Pixeltable to its corresponding ColumnType.
@@ -415,7 +410,7 @@ class ColumnType:
 
     def _create_literal(self, val: Any) -> Any:
         """Create a literal of this type from val, including any needed conversions.
-             val is guaranteed to be non-None"""
+        val is guaranteed to be non-None"""
         return val
 
     def create_literal(self, val: Any) -> Any:
@@ -484,12 +479,7 @@ class ColumnType:
 
     def to_json_schema(self) -> dict[str, Any]:
         if self.nullable:
-            return {
-                'anyOf': [
-                    self._to_json_schema(),
-                    {'type': 'null'},
-                ]
-            }
+            return {'anyOf': [self._to_json_schema(), {'type': 'null'}]}
         else:
             return self._to_json_schema()
 
@@ -612,7 +602,6 @@ class TimestampType(ColumnType):
 
 
 class JsonType(ColumnType):
-
     json_schema: Optional[dict[str, Any]]
     __validator: Optional[jsonschema.protocols.Validator]
 
@@ -699,8 +688,7 @@ class JsonType(ColumnType):
         superschema = self.__superschema(self.json_schema, other.json_schema)
 
         return JsonType(
-            json_schema=(None if len(superschema) == 0 else superschema),
-            nullable=(self.nullable or other.nullable)
+            json_schema=(None if len(superschema) == 0 else superschema), nullable=(self.nullable or other.nullable)
         )
 
     @classmethod
@@ -755,7 +743,7 @@ class JsonType(ColumnType):
         a_type = a.get('type')
         b_type = b.get('type')
 
-        if (a_type in ('string', 'integer', 'number', 'boolean', 'object', 'array') and a_type == b_type):
+        if a_type in ('string', 'integer', 'number', 'boolean', 'object', 'array') and a_type == b_type:
             # a and b both have the same type designation, but are not identical. This can happen if
             # (for example) they have validators or other attributes that differ. In this case, we
             # generalize to {'type': t}, where t is their shared type, with no other qualifications.
@@ -793,15 +781,25 @@ class JsonType(ColumnType):
 
 
 class ArrayType(ColumnType):
-
     shape: Optional[tuple[Optional[int], ...]]
     pxt_dtype: Optional[ColumnType]
     dtype: Optional[ColumnType.Type]
 
-    def __init__(self, shape: Optional[tuple[Optional[int], ...]] = None, dtype: Optional[ColumnType] = None, nullable: bool = False):
+    def __init__(
+        self,
+        shape: Optional[tuple[Optional[int], ...]] = None,
+        dtype: Optional[ColumnType] = None,
+        nullable: bool = False,
+    ):
         super().__init__(self.Type.ARRAY, nullable=nullable)
         assert shape is None or dtype is not None, (shape, dtype)  # cannot specify a shape without a dtype
-        assert dtype is None or dtype.is_int_type() or dtype.is_float_type() or dtype.is_bool_type() or dtype.is_string_type()
+        assert (
+            dtype is None
+            or dtype.is_int_type()
+            or dtype.is_float_type()
+            or dtype.is_bool_type()
+            or dtype.is_string_type()
+        )
 
         self.shape = shape
         self.pxt_dtype = dtype  # we need this for copy() and __str__()
@@ -857,13 +855,15 @@ class ArrayType(ColumnType):
     def from_literal(cls, val: np.ndarray, nullable: bool = False) -> Optional[ArrayType]:
         # determine our dtype
         assert isinstance(val, np.ndarray)
+        dtype: ColumnType
         if np.issubdtype(val.dtype, np.integer):
-            dtype: ColumnType = IntType()
+            dtype = IntType()
         elif np.issubdtype(val.dtype, np.floating):
             dtype = FloatType()
         elif val.dtype == np.bool_:
             dtype = BoolType()
-        elif val.dtype == np.str_:
+        elif np.issubdtype(val.dtype, np.str_):
+            # Note that this includes NumPy types like '<U1' -- arrays of single Unicode characters
             dtype = StringType()
         else:
             return None
@@ -898,10 +898,7 @@ class ArrayType(ColumnType):
         return True
 
     def _to_json_schema(self) -> dict[str, Any]:
-        return {
-            'type': 'array',
-            'items': self.pxt_dtype._to_json_schema(),
-        }
+        return {'type': 'array', 'items': self.pxt_dtype._to_json_schema()}
 
     def _validate_literal(self, val: Any) -> None:
         if not isinstance(val, np.ndarray):
@@ -945,15 +942,19 @@ class ArrayType(ColumnType):
 
 class ImageType(ColumnType):
     def __init__(
-            self, width: Optional[int] = None, height: Optional[int] = None, size: Optional[tuple[int, int]] = None,
-            mode: Optional[str] = None, nullable: bool = False
+        self,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+        size: Optional[tuple[int, int]] = None,
+        mode: Optional[str] = None,
+        nullable: bool = False,
     ):
         """
         TODO: does it make sense to specify only width or height?
         """
         super().__init__(self.Type.IMAGE, nullable=nullable)
-        assert not(width is not None and size is not None)
-        assert not(height is not None and size is not None)
+        assert not (width is not None and size is not None)
+        assert not (height is not None and size is not None)
         if size is not None:
             self.width = size[0]
             self.height = size[1]
@@ -1143,6 +1144,7 @@ class DocumentType(ColumnType):
     def validate_media(self, val: Any) -> None:
         assert isinstance(val, str)
         from pixeltable.utils.documents import get_document_handle
+
         dh = get_document_handle(val)
         if dh is None:
             raise excs.Error(f'Not a recognized document format: {val}')
@@ -1156,6 +1158,7 @@ class Required(typing.Generic[T]):
     Marker class to indicate that a column is non-nullable in a schema definition. This has no meaning as a type hint,
     and is intended only for schema declarations.
     """
+
     pass
 
 
@@ -1178,6 +1181,7 @@ class _PxtType:
     `Image[(300, 300), 'RGB']`. The specialized forms resolve to `typing.Annotated` instances whose annotation is a
     `ColumnType`.
     """
+
     def __init__(self):
         raise TypeError(f'Type `{type(self)}` cannot be instantiated.')
 
@@ -1256,7 +1260,11 @@ class Image(PIL.Image.Image, _PxtType):
         mode: Optional[str] = None
         for param in params:
             if isinstance(param, tuple):
-                if len(param) != 2 or not isinstance(param[0], (int, type(None))) or not isinstance(param[1], (int, type(None))):
+                if (
+                    len(param) != 2
+                    or not isinstance(param[0], (int, type(None)))
+                    or not isinstance(param[1], (int, type(None)))
+                ):
                     raise TypeError(f'Invalid Image type parameter: {param}')
                 if size is not None:
                     raise TypeError(f'Duplicate Image type parameter: {param}')

pixeltable/utils/arrow.py

@@ -1,12 +1,11 @@
+import datetime
 from typing import Any, Iterator, Optional, Union
 
 import numpy as np
 import pyarrow as pa
-import datetime
 
 import pixeltable.type_system as ts
 
-
 _pa_to_pt: dict[pa.DataType, ts.ColumnType] = {
     pa.string(): ts.StringType(nullable=True),
     pa.bool_(): ts.BoolType(nullable=True),

pixeltable/utils/coco.py

@@ -22,6 +22,7 @@ Required format:
 }
 """
 
+
 def _verify_input_dict(input_dict: dict[str, Any]) -> None:
     """Verify that input_dict is a valid input dict for write_coco_dataset()"""
     if not isinstance(input_dict, dict):
@@ -30,7 +31,7 @@ def _verify_input_dict(input_dict: dict[str, Any]) -> None:
         raise excs.Error(f'Missing key "image" in input dict: {input_dict}{format_msg}')
     if not isinstance(input_dict['image'], PIL.Image.Image):
         raise excs.Error(f'Value for "image" is not a PIL.Image.Image: {input_dict}{format_msg}')
-    if  'annotations' not in input_dict:
+    if 'annotations' not in input_dict:
         raise excs.Error(f'Missing key "annotations" in input dict: {input_dict}{format_msg}')
     if not isinstance(input_dict['annotations'], list):
         raise excs.Error(f'Value for "annotations" is not a list: {input_dict}{format_msg}')
@@ -48,6 +49,7 @@ def _verify_input_dict(input_dict: dict[str, Any]) -> None:
         if not isinstance(annotation['category'], (str, int)):
             raise excs.Error(f'Value for "category" is not a str or int: {annotation}{format_msg}')
 
+
 def write_coco_dataset(df: pxt.DataFrame, dest_path: Path) -> Path:
     """Export a DataFrame result set as a COCO dataset in dest_path and return the path of the data.json file."""
     # TODO: validate schema
@@ -96,12 +98,7 @@ def write_coco_dataset(df: pxt.DataFrame, dest_path: Path) -> Path:
             img_path = images_dir / f'{img_id}.jpg'
             img.save(img_path)
 
-        images.append({
-            'id': img_id,
-            'file_name': str(img_path),
-            'width': img.width,
-            'height': img.height,
-        })
+        images.append({'id': img_id, 'file_name': str(img_path), 'width': img.width, 'height': img.height})
 
         # create annotation records for this image
         for annotation in input_dict['annotations']:
@@ -109,15 +106,17 @@ def write_coco_dataset(df: pxt.DataFrame, dest_path: Path) -> Path:
             x, y, w, h = annotation['bbox']
             category = annotation['category']
             categories.add(category)
-            annotations.append({
-                'id': ann_id,
-                'image_id': img_id,
-                # we use the category name here and fix it up at the end, when we have assigned category ids
-                'category_id': category,
-                'bbox': annotation['bbox'],
-                'area': w * h,
-                'iscrowd': 0,
-            })
+            annotations.append(
+                {
+                    'id': ann_id,
+                    'image_id': img_id,
+                    # we use the category name here and fix it up at the end, when we have assigned category ids
+                    'category_id': category,
+                    'bbox': annotation['bbox'],
+                    'area': w * h,
+                    'iscrowd': 0,
+                }
+            )
 
     # replace category names with ids
     category_ids = {category: id for id, category in enumerate(sorted(list(categories)))}
@@ -226,5 +225,5 @@ COCO_2017_CATEGORIES = {
     87: 'scissors',
     88: 'teddy bear',
     89: 'hair drier',
-    90: 'toothbrush'
+    90: 'toothbrush',
 }

pixeltable/utils/code.py

@@ -3,9 +3,9 @@ from typing import Optional
 
 from pixeltable.func import Function
 
-
 # Utilities related to the organization of the Pixeltable codebase.
 
+
 def local_public_names(mod_name: str, exclude: Optional[list[str]] = None) -> list[str]:
     """
     Returns a list of all functions and submodules that are local to the specified module and are

pixeltable/utils/console_output.py

@@ -1,5 +1,6 @@
 import logging
 
+
 def map_level(verbosity: int) -> int:
     """
         Map verbosity level to logging level.
@@ -19,6 +20,7 @@ def map_level(verbosity: int) -> int:
         return logging.DEBUG
     return logging.INFO
 
+
 class ConsoleOutputHandler(logging.StreamHandler):
     def __init__(self, stream):
         super().__init__(stream)
@@ -29,13 +31,14 @@ class ConsoleOutputHandler(logging.StreamHandler):
         else:
             self.stream.write(record.msg + '\n')
 
+
 class ConsoleMessageFilter(logging.Filter):
     def filter(self, record: logging.LogRecord) -> bool:
         if hasattr(record, 'user_visible') and record.user_visible:
             return True
         return False
 
-class ConsoleLogger(logging.LoggerAdapter):
-    def __init__(self, logger:logging.Logger):
-        super().__init__(logger, extra={'user_visible' : True})
 
+class ConsoleLogger(logging.LoggerAdapter):
+    def __init__(self, logger: logging.Logger):
+        super().__init__(logger, extra={'user_visible': True})

pixeltable/utils/description_helper.py

@@ -25,6 +25,7 @@ class DescriptionHelper:
     DescriptionHelper can convert a list of descriptors into either HTML or plaintext and do something reasonable
     in each case.
     """
+
     __descriptors: list[_Descriptor]
 
     def __init__(self) -> None:
@@ -69,18 +70,17 @@ class DescriptionHelper:
             return (
                 # Render the string as a single-cell DataFrame. This will ensure a consistent style of output in
                 # cases where strings appear alongside DataFrames in the same DescriptionHelper.
-                pd.DataFrame([descriptor.body]).style
-                .set_properties(None, **{'white-space': 'pre-wrap', 'text-align': 'left', 'font-weight': 'bold'})
-                .hide(axis='index').hide(axis='columns')
+                pd.DataFrame([descriptor.body])
+                .style.set_properties(None, **{'white-space': 'pre-wrap', 'text-align': 'left', 'font-weight': 'bold'})
+                .hide(axis='index')
+                .hide(axis='columns')
             )
         else:
             styler = descriptor.styler
             if styler is None:
                 styler = descriptor.body.style
-            styler = (
-                styler
-                .set_properties(None, **{'white-space': 'pre-wrap', 'text-align': 'left'})
-                .set_table_styles([dict(selector='th', props=[('text-align', 'left')])])
+            styler = styler.set_properties(None, **{'white-space': 'pre-wrap', 'text-align': 'left'}).set_table_styles(
+                [dict(selector='th', props=[('text-align', 'left')])]
             )
             if not descriptor.show_header:
                 styler = styler.hide(axis='columns')

pixeltable/utils/documents.py

@@ -83,6 +83,7 @@ def get_xml_handle(path: str) -> Optional[bs4.BeautifulSoup]:
 def get_markdown_handle(path: str) -> Optional[dict]:
     Env.get().require_package('mistune', [3, 0])
     import mistune
+
     try:
         with open(path, encoding='utf8') as file:
             text = file.read()
@@ -91,9 +92,10 @@ def get_markdown_handle(path: str) -> Optional[dict]:
     except Exception:
         return None
 
+
 def get_txt(path: str) -> Optional[str]:
     try:
-        with open(path, "r") as f:
+        with open(path, 'r') as f:
             doc = f.read()
         return doc if doc != '' else None
     except Exception: