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

pixeltable/io/external_store.py

@@ -8,11 +8,11 @@ from dataclasses import dataclass
 from typing import Any, Optional
 from uuid import UUID
 
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
-from pixeltable import Table, Column
 import sqlalchemy as sql
 
+import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
+from pixeltable import Column, Table
 from pixeltable.catalog import TableVersion
 
 _logger = logging.getLogger('pixeltable')
@@ -148,7 +148,9 @@ class Project(ExternalStore, abc.ABC):
         """
         from pixeltable import exprs
 
-        assert col.col_type.is_media_type() and not (col.is_stored and col.is_computed) and col not in self.stored_proxies
+        assert (
+            col.col_type.is_media_type() and not (col.is_stored and col.is_computed) and col not in self.stored_proxies
+        )
         proxy_col = Column(
             name=None,
             # Force images in the proxy column to be materialized inside the media store, in a normalized format.
@@ -159,7 +161,7 @@ class Project(ExternalStore, abc.ABC):
             stored=True,
             col_id=tbl_version.next_col_id,
             sa_col_type=col.col_type.to_sa_type(),
-            schema_version_add=tbl_version.schema_version
+            schema_version_add=tbl_version.schema_version,
         )
         proxy_col.tbl = tbl_version
         tbl_version.next_col_id += 1
@@ -197,11 +199,11 @@ class Project(ExternalStore, abc.ABC):
 
     @classmethod
     def validate_columns(
-            cls,
-            table: Table,
-            export_cols: dict[str, ts.ColumnType],
-            import_cols: dict[str, ts.ColumnType],
-            col_mapping: Optional[dict[str, str]]
+        cls,
+        table: Table,
+        export_cols: dict[str, ts.ColumnType],
+        import_cols: dict[str, ts.ColumnType],
+        col_mapping: Optional[dict[str, str]],
     ) -> dict[Column, str]:
         """
         Verifies that the specified `col_mapping` is valid. In particular, checks that:
@@ -294,7 +296,7 @@ class SyncStatus:
             external_rows_deleted=self.external_rows_deleted + other.external_rows_deleted,
             external_rows_updated=self.external_rows_updated + other.external_rows_updated,
             pxt_rows_updated=self.pxt_rows_updated + other.pxt_rows_updated,
-            num_excs=self.num_excs + other.num_excs
+            num_excs=self.num_excs + other.num_excs,
         )
 
     @classmethod
@@ -304,13 +306,14 @@ class SyncStatus:
 
 class MockProject(Project):
     """A project that cannot be synced, used mainly for testing."""
+
     def __init__(
-            self,
-            name: str,
-            export_cols: dict[str, ts.ColumnType],
-            import_cols: dict[str, ts.ColumnType],
-            col_mapping: dict[Column, str],
-            stored_proxies: Optional[dict[Column, Column]] = None
+        self,
+        name: str,
+        export_cols: dict[str, ts.ColumnType],
+        import_cols: dict[str, ts.ColumnType],
+        col_mapping: dict[Column, str],
+        stored_proxies: Optional[dict[Column, Column]] = None,
     ):
         super().__init__(name, col_mapping, stored_proxies)
         self.export_cols = export_cols
@@ -319,12 +322,12 @@ class MockProject(Project):
 
     @classmethod
     def create(
-            cls,
-            t: Table,
-            name: str,
-            export_cols: dict[str, ts.ColumnType],
-            import_cols: dict[str, ts.ColumnType],
-            col_mapping: Optional[dict[str, str]] = None
+        cls,
+        t: Table,
+        name: str,
+        export_cols: dict[str, ts.ColumnType],
+        import_cols: dict[str, ts.ColumnType],
+        col_mapping: Optional[dict[str, str]] = None,
     ) -> 'MockProject':
         col_mapping = cls.validate_columns(t, export_cols, import_cols, col_mapping)
         return cls(name, export_cols, import_cols, col_mapping)
@@ -351,7 +354,9 @@ class MockProject(Project):
             'export_cols': {k: v.as_dict() for k, v in self.export_cols.items()},
             'import_cols': {k: v.as_dict() for k, v in self.import_cols.items()},
             'col_mapping': [[self._column_as_dict(k), v] for k, v in self.col_mapping.items()],
-            'stored_proxies': [[self._column_as_dict(k), self._column_as_dict(v)] for k, v in self.stored_proxies.items()]
+            'stored_proxies': [
+                [self._column_as_dict(k), self._column_as_dict(v)] for k, v in self.stored_proxies.items()
+            ],
         }
 
     @classmethod
@@ -361,7 +366,7 @@ class MockProject(Project):
             {k: ts.ColumnType.from_dict(v) for k, v in md['export_cols'].items()},
             {k: ts.ColumnType.from_dict(v) for k, v in md['import_cols'].items()},
             {cls._column_from_dict(entry[0]): entry[1] for entry in md['col_mapping']},
-            {cls._column_from_dict(entry[0]): cls._column_from_dict(entry[1]) for entry in md['stored_proxies']}
+            {cls._column_from_dict(entry[0]): cls._column_from_dict(entry[1]) for entry in md['stored_proxies']},
         )
 
     def __eq__(self, other: Any) -> bool:

pixeltable/io/fiftyone.py

@@ -16,6 +16,7 @@ class PxtImageDatasetImporter(foud.LabeledImageDatasetImporter):
     """
     Implementation of a FiftyOne `DatasetImporter` that reads image data from a Pixeltable table.
     """
+
     __image_format: str  # format to use for any exported images that are not already stored on disk
     __labels: dict[str, tuple[exprs.Expr, type[fo.Label]]]  # label_name -> (expr, label_cls)
     __image_idx: int  # index of the image expr in the select list
@@ -34,12 +35,7 @@ class PxtImageDatasetImporter(foud.LabeledImageDatasetImporter):
         seed: Union[int, float, str, bytes, bytearray, None] = None,
         max_samples: Optional[int] = None,
     ):
-        super().__init__(
-            dataset_dir=dataset_dir,
-            shuffle=shuffle,
-            seed=seed,
-            max_samples=max_samples
-        )
+        super().__init__(dataset_dir=dataset_dir, shuffle=shuffle, seed=seed, max_samples=max_samples)
 
         self.__image_format = image_format
 
@@ -54,9 +50,9 @@ class PxtImageDatasetImporter(foud.LabeledImageDatasetImporter):
             if isinstance(exprs_, dict):
                 for label_name, expr in exprs_.items():
                     if not label_name.isidentifier():
-                        raise excs.Error(f"Invalid label name: {label_name}")
+                        raise excs.Error(f'Invalid label name: {label_name}')
                     if label_name in self.__labels:
-                        raise excs.Error(f"Duplicate label name: {label_name}")
+                        raise excs.Error(f'Duplicate label name: {label_name}')
                     self.__labels[label_name] = (expr, label_cls)
 
         # Now add the remaining labels, assigning unused default names.
@@ -137,13 +133,9 @@ class PxtImageDatasetImporter(foud.LabeledImageDatasetImporter):
     def __as_fo_classifications(self, data: list) -> list[fo.Classification]:
         if not isinstance(data, list) or any('label' not in entry for entry in data):
             raise excs.Error(
-                f'Invalid classifications data: {data}\n'
-                "(Expected a list of dicts, each containing a 'label' key)"
+                f"Invalid classifications data: {data}\n(Expected a list of dicts, each containing a 'label' key)"
             )
-        return [
-            fo.Classification(label=entry['label'], confidence=entry.get('confidence'))
-            for entry in data
-        ]
+        return [fo.Classification(label=entry['label'], confidence=entry.get('confidence')) for entry in data]
 
     def __as_fo_detections(self, data: list) -> list[fo.Detections]:
         if not isinstance(data, list) or any('label' not in entry or 'bounding_box' not in entry for entry in data):

pixeltable/io/globals.py

@@ -11,15 +11,15 @@ if TYPE_CHECKING:
 
 
 def create_label_studio_project(
-        t: Table,
-        label_config: str,
-        name: Optional[str] = None,
-        title: Optional[str] = None,
-        media_import_method: Literal['post', 'file', 'url'] = 'post',
-        col_mapping: Optional[dict[str, str]] = None,
-        sync_immediately: bool = True,
-        s3_configuration: Optional[dict[str, Any]] = None,
-        **kwargs: Any
+    t: Table,
+    label_config: str,
+    name: Optional[str] = None,
+    title: Optional[str] = None,
+    media_import_method: Literal['post', 'file', 'url'] = 'post',
+    col_mapping: Optional[dict[str, str]] = None,
+    sync_immediately: bool = True,
+    s3_configuration: Optional[dict[str, Any]] = None,
+    **kwargs: Any,
 ) -> SyncStatus:
     """
     Create a new Label Studio project and link it to the specified [`Table`][pixeltable.Table].
@@ -125,14 +125,7 @@ def create_label_studio_project(
     from pixeltable.io.label_studio import LabelStudioProject
 
     ls_project = LabelStudioProject.create(
-        t,
-        label_config,
-        name,
-        title,
-        media_import_method,
-        col_mapping,
-        s3_configuration,
-        **kwargs
+        t, label_config, name, title, media_import_method, col_mapping, s3_configuration, **kwargs
     )
 
     # Link the project to `t`, and sync if appropriate.
@@ -150,8 +143,8 @@ def import_rows(
     schema_overrides: Optional[dict[str, pxt.ColumnType]] = None,
     primary_key: Optional[Union[str, list[str]]] = None,
     num_retained_versions: int = 10,
-    comment: str = ''
-    ) -> Table:
+    comment: str = '',
+) -> Table:
     """
     Creates a new base table from a list of dictionaries. The dictionaries must be of the
     form `{column_name: value, ...}`. Pixeltable will attempt to infer the schema of the table from the
@@ -194,7 +187,9 @@ def import_rows(
                 # The column type will always be nullable by default.
                 col_type = pxt.ColumnType.infer_literal_type(value, nullable=True)
                 if col_type is None:
-                    raise excs.Error(f'Could not infer type for column `{col_name}`; the value in row {n} has an unsupported type: {type(value)}')
+                    raise excs.Error(
+                        f'Could not infer type for column `{col_name}`; the value in row {n} has an unsupported type: {type(value)}'
+                    )
                 if col_name not in schema:
                     schema[col_name] = col_type
                 else:
@@ -210,7 +205,9 @@ def import_rows(
 
     extraneous_keys = schema_overrides.keys() - schema.keys()
     if len(extraneous_keys) > 0:
-        raise excs.Error(f'The following columns specified in `schema_overrides` are not present in the data: {", ".join(extraneous_keys)}')
+        raise excs.Error(
+            f'The following columns specified in `schema_overrides` are not present in the data: {", ".join(extraneous_keys)}'
+        )
 
     entirely_none_cols = cols_with_nones - schema.keys()
     if len(entirely_none_cols) > 0:
@@ -221,7 +218,9 @@ def import_rows(
             'Consider specifying the type(s) explicitly in `schema_overrides`.'
         )
 
-    t = pxt.create_table(tbl_path, schema, primary_key=primary_key, num_retained_versions=num_retained_versions, comment=comment)
+    t = pxt.create_table(
+        tbl_path, schema, primary_key=primary_key, num_retained_versions=num_retained_versions, comment=comment
+    )
     t.insert(rows)
     return t
 
@@ -234,7 +233,7 @@ def import_json(
     primary_key: Optional[Union[str, list[str]]] = None,
     num_retained_versions: int = 10,
     comment: str = '',
-    **kwargs: Any
+    **kwargs: Any,
 ) -> Table:
     """
     Creates a new base table from a JSON file. This is a convenience method and is
@@ -272,7 +271,14 @@ def import_json(
         # URL
         contents = urllib.request.urlopen(filepath_or_url).read()
     data = json.loads(contents, **kwargs)
-    return import_rows(tbl_path, data, schema_overrides=schema_overrides, primary_key=primary_key, num_retained_versions=num_retained_versions, comment=comment)
+    return import_rows(
+        tbl_path,
+        data,
+        schema_overrides=schema_overrides,
+        primary_key=primary_key,
+        num_retained_versions=num_retained_versions,
+        comment=comment,
+    )
 
 
 def export_images_as_fo_dataset(
@@ -358,6 +364,6 @@ def export_images_as_fo_dataset(
     if not images.col_type.is_image_type():
         raise excs.Error(f'`images` must be an expression of type Image (got {images.col_type._to_base_str()})')
 
-    return fo.Dataset.from_importer(PxtImageDatasetImporter(
-        tbl, images, image_format, classifications=classifications, detections=detections
-    ))
+    return fo.Dataset.from_importer(
+        PxtImageDatasetImporter(tbl, images, image_format, classifications=classifications, detections=detections)
+    )

pixeltable/io/hf_datasets.py

@@ -4,7 +4,7 @@ import logging
 import math
 import random
 import typing
-from typing import Union, Optional, Any
+from typing import Any, Optional, Union
 
 import pixeltable as pxt
 import pixeltable.type_system as ts
@@ -103,6 +103,7 @@ def import_huggingface_dataset(
         A handle to the newly created [`Table`][pixeltable.Table].
     """
     import datasets
+
     import pixeltable as pxt
 
     if table_path in pxt.list_tables():

pixeltable/io/label_studio.py

@@ -47,12 +47,12 @@ class LabelStudioProject(Project):
     """
 
     def __init__(
-            self,
-            name: str,
-            project_id: int,
-            media_import_method: Literal['post', 'file', 'url'],
-            col_mapping: dict[Column, str],
-            stored_proxies: Optional[dict[Column, Column]] = None
+        self,
+        name: str,
+        project_id: int,
+        media_import_method: Literal['post', 'file', 'url'],
+        col_mapping: dict[Column, str],
+        stored_proxies: Optional[dict[Column, Column]] = None,
     ):
         """
         The constructor will NOT create a new Label Studio project; it is also used when loading
@@ -70,8 +70,10 @@ class LabelStudioProject(Project):
             try:
                 self._project = _label_studio_client().get_project(self.project_id)
             except HTTPError as exc:
-                raise excs.Error(f'Could not locate Label Studio project: {self.project_id} '
-                                 '(cannot connect to server or project no longer exists)') from exc
+                raise excs.Error(
+                    f'Could not locate Label Studio project: {self.project_id} '
+                    '(cannot connect to server or project no longer exists)'
+                ) from exc
         return self._project
 
     @property
@@ -105,8 +107,10 @@ class LabelStudioProject(Project):
         return {ANNOTATIONS_COLUMN: pxt.JsonType(nullable=True)}
 
     def sync(self, t: Table, export_data: bool, import_data: bool) -> SyncStatus:
-        _logger.info(f'Syncing Label Studio project "{self.project_title}" with table `{t._name}`'
-                     f' (export: {export_data}, import: {import_data}).')
+        _logger.info(
+            f'Syncing Label Studio project "{self.project_title}" with table `{t._name}`'
+            f' (export: {export_data}, import: {import_data}).'
+        )
         # Collect all existing tasks into a dict with entries `rowid: task`
         tasks = {tuple(task['meta']['rowid']): task for task in self.__fetch_all_tasks()}
         sync_status = SyncStatus.empty()
@@ -148,18 +152,14 @@ class LabelStudioProject(Project):
         config = self.__project_config
 
         # Columns in `t` that map to Label Studio data keys
-        t_data_cols = [
-            t_col for t_col, ext_col_name in self.col_mapping.items()
-            if ext_col_name in config.data_keys
-        ]
+        t_data_cols = [t_col for t_col, ext_col_name in self.col_mapping.items() if ext_col_name in config.data_keys]
 
         if len(t_data_cols) == 0:
             return SyncStatus.empty()
 
         # Columns in `t` that map to `rectanglelabels` preannotations
         t_rl_cols = [
-            t_col for t_col, ext_col_name in self.col_mapping.items()
-            if ext_col_name in config.rectangle_labels
+            t_col for t_col, ext_col_name in self.col_mapping.items() if ext_col_name in config.rectangle_labels
         ]
 
         # Destinations for `rectanglelabels` preannotations
@@ -180,12 +180,12 @@ class LabelStudioProject(Project):
             assert False
 
     def __update_tasks_by_post(
-            self,
-            t: Table,
-            existing_tasks: dict[tuple, dict],
-            media_col: Column,
-            t_rl_cols: list[Column],
-            rl_info: list['_RectangleLabel']
+        self,
+        t: Table,
+        existing_tasks: dict[tuple, dict],
+        media_col: Column,
+        t_rl_cols: list[Column],
+        rl_info: list['_RectangleLabel'],
     ) -> SyncStatus:
         is_stored = media_col.is_stored
         # If it's a stored column, we can use `localpath`
@@ -197,7 +197,7 @@ class LabelStudioProject(Project):
 
         for row in rows._exec():
             media_col_idx = rows._select_list_exprs[0].slot_idx
-            rl_col_idxs = [expr.slot_idx for expr in rows._select_list_exprs[1: 1 + len(t_rl_cols)]]
+            rl_col_idxs = [expr.slot_idx for expr in rows._select_list_exprs[1 : 1 + len(t_rl_cols)]]
             row_ids_in_pxt.add(row.rowid)
             if row.rowid not in existing_tasks:
                 # Upload the media file to Label Studio
@@ -239,12 +239,12 @@ class LabelStudioProject(Project):
         return sync_status.combine(deletion_sync_status)
 
     def __update_tasks_by_files(
-            self,
-            t: Table,
-            existing_tasks: dict[tuple, dict],
-            t_data_cols: list[Column],
-            t_rl_cols: list[Column],
-            rl_info: list['_RectangleLabel']
+        self,
+        t: Table,
+        existing_tasks: dict[tuple, dict],
+        t_data_cols: list[Column],
+        t_rl_cols: list[Column],
+        rl_info: list['_RectangleLabel'],
     ) -> SyncStatus:
         ext_data_cols = [self.col_mapping[col] for col in t_data_cols]
         expr_refs: dict[str, Expr] = {}  # kwargs for the select statement
@@ -301,21 +301,23 @@ class LabelStudioProject(Project):
             return {
                 'data': dict(zip(ext_data_cols, data_vals)),
                 'meta': {'rowid': row.rowid},
-                'predictions': predictions
+                'predictions': predictions,
             }
 
         for row in df._exec():
             if rl_col_idxs is None:
-                rl_col_idxs = [expr.slot_idx for expr in df._select_list_exprs[:len(t_rl_cols)]]
-                data_col_idxs = [expr.slot_idx for expr in df._select_list_exprs[len(t_rl_cols):]]
+                rl_col_idxs = [expr.slot_idx for expr in df._select_list_exprs[: len(t_rl_cols)]]
+                data_col_idxs = [expr.slot_idx for expr in df._select_list_exprs[len(t_rl_cols) :]]
             row_ids_in_pxt.add(row.rowid)
             task_info = create_task_info(row)
             # TODO(aaron-siegel): Implement more efficient update logic (currently involves a full table scan)
             if row.rowid in existing_tasks:
                 # A task for this row already exists; see if it needs an update.
                 existing_task = existing_tasks[row.rowid]
-                if task_info['data'] != existing_task['data'] or \
-                        task_info['predictions'] != existing_task['predictions']:
+                if (
+                    task_info['data'] != existing_task['data']
+                    or task_info['predictions'] != existing_task['predictions']
+                ):
                     _logger.debug(f'Updating task for rowid {row.rowid}.')
                     self.project.update_task(existing_tasks[row.rowid]['id'], **task_info)
                     tasks_updated += 1
@@ -330,7 +332,9 @@ class LabelStudioProject(Project):
         if len(page) > 0:
             self.project.import_tasks(page)
 
-        env.Env.get().console_logger.info(f'Created {tasks_created} new task(s) and updated {tasks_updated} existing task(s) in {self}.')
+        env.Env.get().console_logger.info(
+            f'Created {tasks_created} new task(s) and updated {tasks_updated} existing task(s) in {self}.'
+        )
 
         sync_status = SyncStatus(external_rows_created=tasks_created, external_rows_updated=tasks_updated)
 
@@ -355,7 +359,9 @@ class LabelStudioProject(Project):
         relpath = Path(localpath).relative_to(env.Env.get().home)
         return f'/data/local-files/?d={str(relpath)}'
 
-    def __delete_stale_tasks(self, existing_tasks: dict[tuple, dict], row_ids_in_pxt: set[tuple], tasks_created: int) -> SyncStatus:
+    def __delete_stale_tasks(
+        self, existing_tasks: dict[tuple, dict], row_ids_in_pxt: set[tuple], tasks_created: int
+    ) -> SyncStatus:
         deleted_rowids = set(existing_tasks.keys()) - row_ids_in_pxt
         # Sanity check the math
         assert len(deleted_rowids) == len(existing_tasks) + tasks_created - len(row_ids_in_pxt)
@@ -363,7 +369,9 @@ class LabelStudioProject(Project):
 
         if len(tasks_to_delete) > 0:
             self.project.delete_tasks(tasks_to_delete)
-            env.Env.get().console_logger.info(f'Deleted {len(tasks_to_delete)} tasks(s) in {self} that are no longer present in Pixeltable.')
+            env.Env.get().console_logger.info(
+                f'Deleted {len(tasks_to_delete)} tasks(s) in {self} that are no longer present in Pixeltable.'
+            )
 
         # Remove them from the `existing_tasks` dict so that future updates are applied correctly
         for rowid in deleted_rowids:
@@ -417,7 +425,9 @@ class LabelStudioProject(Project):
             'project_id': self.project_id,
             'media_import_method': self.media_import_method,
             'col_mapping': [[self._column_as_dict(k), v] for k, v in self.col_mapping.items()],
-            'stored_proxies': [[self._column_as_dict(k), self._column_as_dict(v)] for k, v in self.stored_proxies.items()]
+            'stored_proxies': [
+                [self._column_as_dict(k), self._column_as_dict(v)] for k, v in self.stored_proxies.items()
+            ],
         }
 
     @classmethod
@@ -427,7 +437,7 @@ class LabelStudioProject(Project):
             md['project_id'],
             md['media_import_method'],
             {cls._column_from_dict(entry[0]): entry[1] for entry in md['col_mapping']},
-            {cls._column_from_dict(entry[0]): cls._column_from_dict(entry[1]) for entry in md['stored_proxies']}
+            {cls._column_from_dict(entry[0]): cls._column_from_dict(entry[1]) for entry in md['stored_proxies']},
         )
 
     def __repr__(self) -> str:
@@ -444,8 +454,7 @@ class LabelStudioProject(Project):
         if root.tag.lower() != 'view':
             raise excs.Error('Root of Label Studio config must be a `View`')
         config = _LabelStudioConfig(
-            data_keys=cls.__parse_data_keys_config(root),
-            rectangle_labels=cls.__parse_rectangle_labels_config(root)
+            data_keys=cls.__parse_data_keys_config(root), rectangle_labels=cls.__parse_rectangle_labels_config(root)
         )
         config.validate()
         return config
@@ -474,10 +483,7 @@ class LabelStudioProject(Project):
             if element.tag.lower() == 'rectanglelabels':
                 name = element.attrib['name']
                 to_name = element.attrib['toName']
-                labels = [
-                    child.attrib['value']
-                    for child in element if child.tag.lower() == 'label'
-                ]
+                labels = [child.attrib['value'] for child in element if child.tag.lower() == 'label']
                 for label in labels:
                     if label not in coco.COCO_2017_CATEGORIES.values():
                         raise excs.Error(f'Label in `rectanglelabels` config is not a valid COCO object name: {label}')
@@ -486,11 +492,7 @@ class LabelStudioProject(Project):
 
     @classmethod
     def __coco_to_predictions(
-            cls,
-            coco_annotations: dict[str, Any],
-            from_name: str,
-            rl_info: '_RectangleLabel',
-            task_id: Optional[int] = None
+        cls, coco_annotations: dict[str, Any], from_name: str, rl_info: '_RectangleLabel', task_id: Optional[int] = None
     ) -> dict[str, Any]:
         width = coco_annotations['image']['width']
         height = coco_annotations['image']['height']
@@ -510,8 +512,8 @@ class LabelStudioProject(Project):
                     'y': entry['bbox'][1] * 100.0 / height,
                     'width': entry['bbox'][2] * 100.0 / width,
                     'height': entry['bbox'][3] * 100.0 / height,
-                    'rectanglelabels': [coco.COCO_2017_CATEGORIES[entry['category']]]
-                }
+                    'rectanglelabels': [coco.COCO_2017_CATEGORIES[entry['category']]],
+                },
             }
             for i, entry in enumerate(coco_annotations['annotations'])
             # include only the COCO labels that match a rectanglelabel name
@@ -539,15 +541,15 @@ class LabelStudioProject(Project):
 
     @classmethod
     def create(
-            cls,
-            t: Table,
-            label_config: str,
-            name: Optional[str],
-            title: Optional[str],
-            media_import_method: Literal['post', 'file', 'url'],
-            col_mapping: Optional[dict[str, str]],
-            s3_configuration: Optional[dict[str, Any]],
-            **kwargs: Any
+        cls,
+        t: Table,
+        label_config: str,
+        name: Optional[str],
+        title: Optional[str],
+        media_import_method: Literal['post', 'file', 'url'],
+        col_mapping: Optional[dict[str, str]],
+        s3_configuration: Optional[dict[str, Any]],
+        **kwargs: Any,
     ) -> 'LabelStudioProject':
         """
         Creates a new Label Studio project, using the Label Studio client configured in Pixeltable.
@@ -577,7 +579,8 @@ class LabelStudioProject(Project):
                 t.add_columns({local_annotations_column: pxt.JsonType(nullable=True)})
 
         resolved_col_mapping = cls.validate_columns(
-            t, config.export_columns, {ANNOTATIONS_COLUMN: pxt.JsonType(nullable=True)}, col_mapping)
+            t, config.export_columns, {ANNOTATIONS_COLUMN: pxt.JsonType(nullable=True)}, col_mapping
+        )
 
         # Perform some additional validation
         if media_import_method == 'post' and len(config.data_keys) > 1:
@@ -591,12 +594,15 @@ class LabelStudioProject(Project):
                 raise excs.Error('`s3_configuration` must contain a `bucket` field')
             if not 'title' in s3_configuration:
                 s3_configuration['title'] = 'Pixeltable-S3-Import-Storage'
-            if ('aws_access_key_id' not in s3_configuration and
-                'aws_secret_access_key' not in s3_configuration and
-                'aws_session_token' not in s3_configuration):
+            if (
+                'aws_access_key_id' not in s3_configuration
+                and 'aws_secret_access_key' not in s3_configuration
+                and 'aws_session_token' not in s3_configuration
+            ):
                 # Attempt to fill any missing credentials from the environment
                 try:
                     import boto3
+
                     s3_credentials = boto3.Session().get_credentials().get_frozen_credentials()
                     _logger.info(f'Using AWS credentials from the environment for Label Studio project: {title}')
                     s3_configuration['aws_access_key_id'] = s3_credentials.access_key
@@ -618,8 +624,11 @@ class LabelStudioProject(Project):
             except HTTPError as exc:
                 if exc.errno == 400:
                     response: dict = json.loads(exc.response.text)
-                    if 'validation_errors' in response and 'non_field_errors' in response['validation_errors'] \
-                            and 'LOCAL_FILES_SERVING_ENABLED' in response['validation_errors']['non_field_errors'][0]:
+                    if (
+                        'validation_errors' in response
+                        and 'non_field_errors' in response['validation_errors']
+                        and 'LOCAL_FILES_SERVING_ENABLED' in response['validation_errors']['non_field_errors'][0]
+                    ):
                         raise excs.Error(
                             '`media_import_method` is set to `file`, but your Label Studio server is not configured '
                             'for local file storage.\nPlease set the `LABEL_STUDIO_LOCAL_FILES_SERVING_ENABLED` '
@@ -675,5 +684,5 @@ _LS_TAG_MAP = {
     'text': pxt.StringType(),
     'image': pxt.ImageType(),
     'video': pxt.VideoType(),
-    'audio': pxt.AudioType()
+    'audio': pxt.AudioType(),
 }