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

pixeltable/type_system.py

@@ -9,21 +9,22 @@ import typing
 import urllib.parse
 import urllib.request
 from pathlib import Path
-from typing import Any, Iterable, Mapping, Optional, Sequence, Union
+from typing import Any, Iterable, Literal, 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
 
+from typing import _GenericAlias  # type: ignore[attr-defined]  # isort: skip
+
 
 class ColumnType:
     @enum.unique
@@ -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}
@@ -213,9 +213,9 @@ class ColumnType:
             return self.copy(nullable=(self.nullable or other.nullable))
 
         if self.is_invalid_type():
-            return other
+            return other.copy(nullable=(self.nullable or other.nullable))
         if other.is_invalid_type():
-            return self
+            return self.copy(nullable=(self.nullable or other.nullable))
 
         if self.is_scalar_type() and other.is_scalar_type():
             t = self.Type.supertype(self._type, other._type, self.common_supertypes)
@@ -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.
@@ -295,28 +292,24 @@ class ColumnType:
                 designations will be allowed regardless.
         """
         origin = typing.get_origin(t)
+        type_args = typing.get_args(t)
         if origin is typing.Union:
             # Check if `t` has the form Optional[T].
-            union_args = typing.get_args(t)
-            if len(union_args) == 2 and type(None) in union_args:
+            if len(type_args) == 2 and type(None) in type_args:
                 # `t` is a type of the form Optional[T] (equivalently, Union[T, None] or Union[None, T]).
                 # We treat it as the underlying type but with nullable=True.
-                underlying_py_type = union_args[0] if union_args[1] is type(None) else union_args[1]
+                underlying_py_type = type_args[0] if type_args[1] is type(None) else type_args[1]
                 underlying = cls.from_python_type(underlying_py_type, allow_builtin_types=allow_builtin_types)
                 if underlying is not None:
                     return underlying.copy(nullable=True)
         elif origin is Required:
-            required_args = typing.get_args(t)
-            assert len(required_args) == 1
+            assert len(type_args) == 1
             return cls.from_python_type(
-                required_args[0],
-                nullable_default=False,
-                allow_builtin_types=allow_builtin_types
-            )
+                type_args[0], nullable_default=False, allow_builtin_types=allow_builtin_types
+            ).copy(nullable=False)
         elif origin is typing.Annotated:
-            annotated_args = typing.get_args(t)
-            origin = annotated_args[0]
-            parameters = annotated_args[1]
+            origin = type_args[0]
+            parameters = type_args[1]
             if isinstance(parameters, ColumnType):
                 return parameters.copy(nullable=nullable_default)
         else:
@@ -328,6 +321,11 @@ class ColumnType:
             if isinstance(t, type) and issubclass(t, _PxtType):
                 return t.as_col_type(nullable=nullable_default)
             elif allow_builtin_types:
+                if t is Literal and len(type_args) > 0:
+                    literal_type = cls.infer_common_literal_type(type_args)
+                    if literal_type is None:
+                        return None
+                    return literal_type.copy(nullable=(literal_type.nullable or nullable_default))
                 if t is str:
                     return StringType(nullable=nullable_default)
                 if t is int:
@@ -340,7 +338,7 @@ class ColumnType:
                     return TimestampType(nullable=nullable_default)
                 if t is PIL.Image.Image:
                     return ImageType(nullable=nullable_default)
-                if issubclass(t, Sequence) or issubclass(t, Mapping) or issubclass(t, pydantic.BaseModel):
+                if isinstance(t, type) and issubclass(t, (Sequence, Mapping, pydantic.BaseModel)):
                     return JsonType(nullable=nullable_default)
         return None
 
@@ -349,7 +347,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 +413,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 +482,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 +605,6 @@ class TimestampType(ColumnType):
 
 
 class JsonType(ColumnType):
-
     json_schema: Optional[dict[str, Any]]
     __validator: Optional[jsonschema.protocols.Validator]
 
@@ -699,8 +691,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 +746,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 +784,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__()
@@ -853,21 +854,39 @@ class ArrayType(ColumnType):
         dtype = None if d['dtype'] is None else cls.make_type(cls.Type(d['dtype']))
         return cls(shape, dtype, nullable=d['nullable'])
 
+    @classmethod
+    def from_np_dtype(cls, dtype: np.dtype, nullable: bool) -> Optional[ColumnType]:
+        """
+        Return pixeltable type corresponding to a given simple numpy dtype
+        """
+        if np.issubdtype(dtype, np.integer):
+            return IntType(nullable=nullable)
+
+        if np.issubdtype(dtype, np.floating):
+            return FloatType(nullable=nullable)
+
+        if dtype == np.bool_:
+            return BoolType(nullable=nullable)
+
+        if np.issubdtype(dtype, np.str_):
+            return StringType(nullable=nullable)
+
+        if np.issubdtype(dtype, np.character):
+            return StringType(nullable=nullable)
+
+        if np.issubdtype(dtype, np.datetime64):
+            return TimestampType(nullable=nullable)
+
+        return None
+
     @classmethod
     def from_literal(cls, val: np.ndarray, nullable: bool = False) -> Optional[ArrayType]:
         # determine our dtype
         assert isinstance(val, np.ndarray)
-        if np.issubdtype(val.dtype, np.integer):
-            dtype: ColumnType = IntType()
-        elif np.issubdtype(val.dtype, np.floating):
-            dtype = FloatType()
-        elif val.dtype == np.bool_:
-            dtype = BoolType()
-        elif val.dtype == np.str_:
-            dtype = StringType()
-        else:
+        pxttype: Optional[ColumnType] = cls.from_np_dtype(val.dtype, nullable)
+        if pxttype == None:
             return None
-        return cls(val.shape, dtype=dtype, nullable=nullable)
+        return cls(val.shape, dtype=pxttype, nullable=nullable)
 
     def is_valid_literal(self, val: np.ndarray) -> bool:
         if not isinstance(val, np.ndarray):
@@ -898,10 +917,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 +961,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 +1163,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 +1177,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 +1200,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 +1279,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,13 +1,12 @@
+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_TO_PXT_TYPES: dict[pa.DataType, ts.ColumnType] = {
     pa.string(): ts.StringType(nullable=True),
     pa.bool_(): ts.BoolType(nullable=True),
     pa.uint8(): ts.IntType(nullable=True),
@@ -19,7 +18,7 @@ _pa_to_pt: dict[pa.DataType, ts.ColumnType] = {
     pa.float32(): ts.FloatType(nullable=True),
 }
 
-_pt_to_pa: dict[type[ts.ColumnType], pa.DataType] = {
+PXT_TO_PA_TYPES: dict[type[ts.ColumnType], pa.DataType] = {
     ts.StringType: pa.string(),
     ts.TimestampType: pa.timestamp('us', tz=datetime.timezone.utc),  # postgres timestamp is microseconds
     ts.BoolType: pa.bool_(),
@@ -39,8 +38,8 @@ def to_pixeltable_type(arrow_type: pa.DataType) -> Optional[ts.ColumnType]:
     """
     if isinstance(arrow_type, pa.TimestampType):
         return ts.TimestampType(nullable=True)
-    elif arrow_type in _pa_to_pt:
-        return _pa_to_pt[arrow_type]
+    elif arrow_type in PA_TO_PXT_TYPES:
+        return PA_TO_PXT_TYPES[arrow_type]
     elif isinstance(arrow_type, pa.FixedShapeTensorType):
         dtype = to_pixeltable_type(arrow_type.value_type)
         if dtype is None:
@@ -54,8 +53,8 @@ def to_arrow_type(pixeltable_type: ts.ColumnType) -> Optional[pa.DataType]:
     """Convert a pixeltable DataType to a pyarrow datatype if one is defined.
     Returns None if no conversion is currently implemented.
     """
-    if pixeltable_type.__class__ in _pt_to_pa:
-        return _pt_to_pa[pixeltable_type.__class__]
+    if pixeltable_type.__class__ in PXT_TO_PA_TYPES:
+        return PXT_TO_PA_TYPES[pixeltable_type.__class__]
     elif isinstance(pixeltable_type, ts.ArrayType):
         return pa.fixed_shape_tensor(pa.from_numpy_dtype(pixeltable_type.numpy_dtype()), pixeltable_type.shape)
     else:

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:

pixeltable/utils/filecache.py

@@ -17,9 +17,9 @@ from pixeltable.env import Env
 
 _logger = logging.getLogger('pixeltable')
 
+
 @dataclass
 class CacheEntry:
-
     key: str
     tbl_id: UUID
     col_id: int
@@ -56,6 +56,7 @@ class FileCache:
     TODO:
     - implement MRU eviction for queries that exceed the capacity
     """
+
     __instance: Optional[FileCache] = None
 
     cache: OrderedDict[str, CacheEntry]
@@ -79,8 +80,7 @@ class FileCache:
 
     FileCacheColumnStats = namedtuple('FileCacheColumnStats', ('tbl_id', 'col_id', 'num_files', 'total_size'))
     FileCacheStats = namedtuple(
-        'FileCacheStats',
-        ('total_size', 'num_requests', 'num_hits', 'num_evictions', 'column_stats')
+        'FileCacheStats', ('total_size', 'num_requests', 'num_hits', 'num_evictions', 'column_stats')
     )
 
     @classmethod
@@ -154,7 +154,7 @@ class FileCache:
                 f'Consider increasing the cache size to at least {round(suggested_cache_size / (1 << 30), 1)} GiB '
                 f'(it is currently {round(self.capacity_bytes / (1 << 30), 1)} GiB).\n'
                 f'You can do this by setting the value of `file_cache_size_g` in: {str(Env.get()._config_file)}',
-                excs.PixeltableWarning
+                excs.PixeltableWarning,
             )
             self.new_redownload_witnessed = False
 
@@ -195,7 +195,9 @@ class FileCache:
             self.evicted_working_set_keys.add(key)
             self.new_redownload_witnessed = True
         self.keys_retrieved.add(key)
-        entry = CacheEntry(key, tbl_id, col_id, file_info.st_size, datetime.fromtimestamp(file_info.st_mtime), path.suffix)
+        entry = CacheEntry(
+            key, tbl_id, col_id, file_info.st_size, datetime.fromtimestamp(file_info.st_mtime), path.suffix
+        )
         self.cache[key] = entry
         self.total_size += entry.size
         new_path = entry.path
@@ -217,7 +219,9 @@ class FileCache:
                 # Make a record of the eviction, so that we can generate a warning later if the key is retrieved again.
                 self.keys_evicted_after_retrieval.add(lru_entry.key)
             os.remove(str(lru_entry.path))
-            _logger.debug(f'evicted entry for cell {lru_entry.key} from file cache (of size {lru_entry.size // (1 << 20)} MiB)')
+            _logger.debug(
+                f'evicted entry for cell {lru_entry.key} from file cache (of size {lru_entry.size // (1 << 20)} MiB)'
+            )
 
     def set_capacity(self, capacity_bytes: int) -> None:
         self.capacity_bytes = capacity_bytes
@@ -232,7 +236,8 @@ class FileCache:
             t[0] += 1
             t[1] += entry.size
         col_stats = [
-            self.FileCacheColumnStats(tbl_id, col_id, num_files, size) for (tbl_id, col_id), (num_files, size) in d.items()
+            self.FileCacheColumnStats(tbl_id, col_id, num_files, size)
+            for (tbl_id, col_id), (num_files, size) in d.items()
         ]
         col_stats.sort(key=lambda e: e[3], reverse=True)
         return self.FileCacheStats(self.total_size, self.num_requests, self.num_hits, self.num_evictions, col_stats)