pixeltable 0.2.12__py3-none-any.whl → 0.2.13__py3-none-any.whl

pixeltable/functions/video.py

@@ -1,3 +1,16 @@
+"""
+Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs) for `VideoType`.
+
+Example:
+```python
+import pixeltable as pxt
+from pixeltable.functions import video as pxt_video
+
+t = pxt.get_table(...)
+t.select(pxt_video.extract_audio(t.video_col)).collect()
+```
+"""
+
 import tempfile
 import uuid
 from pathlib import Path
@@ -43,6 +56,9 @@ _format_defaults = {  # format -> (codec, ext)
     allows_window=False,
 )
 class make_video(func.Aggregator):
+    """
+    Aggregator that creates a video from a sequence of images.
+    """
     def __init__(self, fps: int = 25):
         """follows https://pyav.org/docs/develop/cookbook/numpy.html#generating-video"""
         self.container: Optional[av.container.OutputContainer] = None
@@ -84,7 +100,14 @@ _extract_audio_param_types = [
 def extract_audio(
     video_path: str, stream_idx: int = 0, format: str = 'wav', codec: Optional[str] = None
 ) -> Optional[str]:
-    """Extract an audio stream from a video file, save it as a media file and return its path"""
+    """
+    Extract an audio stream from a video file, save it as a media file and return its path.
+
+    Args:
+        stream_idx: Index of the audio stream to extract.
+        format: The target audio format. (`'wav'`, `'mp3'`, `'flac'`).
+        codec: The codec to use for the audio stream. If not provided, a default codec will be used.
+    """
     if format not in _format_defaults:
         raise ValueError(f'extract_audio(): unsupported audio format: {format}')
     default_codec, ext = _format_defaults[format]
@@ -107,13 +130,8 @@ def extract_audio(
 
 @func.udf(return_type=ts.JsonType(nullable=False), param_types=[ts.VideoType(nullable=False)])
 def get_metadata(video: str) -> dict:
-    """Gets various metadata associated with a video file.
-
-    Args:
-        video (str): Path to the video file.
-
-    Returns:
-        A dictionary containing the associated metadata.
+    """
+    Gets various metadata associated with a video file and returns it as a dictionary.
     """
     with av.open(video) as container:
         assert isinstance(container, av.container.InputContainer)

pixeltable/globals.py

@@ -7,10 +7,10 @@ import sqlalchemy as sql
 from sqlalchemy.util.preloaded import orm
 
 import pixeltable.exceptions as excs
+import pixeltable.exprs as exprs
 from pixeltable import catalog, func, DataFrame
 from pixeltable.catalog import Catalog
 from pixeltable.env import Env
-from pixeltable.exprs import Predicate
 from pixeltable.iterators import ComponentIterator
 from pixeltable.metadata import schema
 
@@ -81,7 +81,7 @@ def create_view(
     base: Union[catalog.Table, DataFrame],
     *,
     schema: Optional[dict[str, Any]] = None,
-    filter: Optional[Predicate] = None,
+    filter: Optional[exprs.Expr] = None,
     is_snapshot: bool = False,
     iterator: Optional[tuple[type[ComponentIterator], dict[str, Any]]] = None,
     num_retained_versions: int = 10,
@@ -94,7 +94,7 @@ def create_view(
         path_str: Path to the view.
         base: Table (i.e., table or view or snapshot) or DataFrame to base the view on.
         schema: dictionary mapping column names to column types, value expressions, or to column specifications.
-        filter: Predicate to filter rows of the base table.
+        filter: predicate to filter rows of the base table.
         is_snapshot: Whether the view is a snapshot.
         iterator: The iterator to use for this view. If specified, then this view will be a one-to-many view of
             the base table.

pixeltable/io/globals.py

@@ -13,11 +13,14 @@ def create_label_studio_project(
         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:
-    # TODO(aaron-siegel): Add link in docstring to a Label Studio howto
     """
-    Creates a new Label Studio project and links it to the specified `Table`.
+    Create a new Label Studio project and link it to the specified `Table`.
+
+    - A tutorial notebook with fully worked examples can be found here:
+      [Using Label Studio for Annotations with Pixeltable](https://pixeltable.readme.io/docs/label-studio)
 
     The required parameter `label_config` specifies the Label Studio project configuration,
     in XML format, as described in the Label Studio documentation. The linked project will
@@ -41,6 +44,11 @@ def create_label_studio_project(
     * Set the `LABEL_STUDIO_API_KEY` and `LABEL_STUDIO_URL` environment variables; or
     * Specify `api_key` and `url` fields in the `label-studio` section of `$PIXELTABLE_HOME/config.yaml`.
 
+    __Requirements:__
+
+    - `pip install label-studio-sdk`
+    - `pip install boto3` (if using S3 import storage)
+
     Args:
         t: The Table to link to.
         label_config: The Label Studio project configuration, in XML format.
@@ -52,6 +60,7 @@ def create_label_studio_project(
             will see inside Label Studio. Unlike `name`, it does not need to be an identifier and
             does not need to be unique. If not specified, the table name `t.name` will be used.
         media_import_method: The method to use when transferring media files to Label Studio:
+
             - `post`: Media will be sent to Label Studio via HTTP post. This should generally only be used for
                 prototyping; due to restrictions in Label Studio, it can only be used with projects that have
                 just one data field, and does not scale well.
@@ -63,9 +72,48 @@ def create_label_studio_project(
         col_mapping: An optional mapping of local column names to Label Studio fields.
         sync_immediately: If `True`, immediately perform an initial synchronization by
             exporting all rows of the `Table` as Label Studio tasks.
+        s3_configuration: If specified, S3 import storage will be configured for the new project. This can only
+            be used with `media_import_method='url'`, and if `media_import_method='url'` and any of the media data is
+            referenced by `s3://` URLs, then it must be specified in order for such media to display correctly
+            in the Label Studio interface.
+
+            The items in the `s3_configuration` dictionary correspond to kwarg
+            parameters of the Label Studio `connect_s3_import_storage` method, as described in the
+            [Label Studio connect_s3_import_storage docs](https://labelstud.io/sdk/project.html#label_studio_sdk.project.Project.connect_s3_import_storage).
+            `bucket` must be specified; all other parameters are optional. If credentials are not specified explicitly,
+            Pixeltable will attempt to retrieve them from the environment (such as from `~/.aws/credentials`). If a title is not
+            specified, Pixeltable will use the default `'Pixeltable-S3-Import-Storage'`. All other parameters use their Label
+            Studio defaults.
         kwargs: Additional keyword arguments are passed to the `start_project` method in the Label
-            Studio SDK, as described here:
-            https://labelstud.io/sdk/project.html#label_studio_sdk.project.Project.start_project
+            Studio SDK, as described in the
+            [Label Studio start_project docs](https://labelstud.io/sdk/project.html#label_studio_sdk.project.Project.start_project).
+
+    Returns:
+        A `SyncStatus` representing the status of any synchronization operations that occurred.
+
+    Examples:
+        Create a Label Studio project whose tasks correspond to videos stored in the `video_col` column of the table `tbl`:
+
+        >>> config = \"\"\"
+            <View>
+                <Video name="video_obj" value="$video_col"/>
+                <Choices name="video-category" toName="video" showInLine="true">
+                    <Choice value="city"/>
+                    <Choice value="food"/>
+                    <Choice value="sports"/>
+                </Choices>
+            </View>\"\"\"
+            create_label_studio_project(tbl, config)
+
+        Create a Label Studio project with the same configuration, using `media_import_method='url'`,
+        whose media are stored in an S3 bucket:
+
+        >>> create_label_studio_project(
+                tbl,
+                config,
+                media_import_method='url',
+                s3_configuration={'bucket': 'my-bucket', 'region_name': 'us-east-2'}
+            )
     """
     from pixeltable.io.label_studio import LabelStudioProject
 
@@ -76,6 +124,7 @@ def create_label_studio_project(
         title,
         media_import_method,
         col_mapping,
+        s3_configuration,
         **kwargs
     )
 

pixeltable/io/label_studio.py

@@ -1,3 +1,4 @@
+import copy
 import json
 import logging
 import os
@@ -18,6 +19,15 @@ from pixeltable.exprs import ColumnRef, DataRow, Expr
 from pixeltable.io.external_store import Project, SyncStatus
 from pixeltable.utils import coco
 
+# label_studio_sdk>=1 and label_studio_sdk<1 are not compatible, so we need to try
+# the import two different ways to insure intercompatibility
+try:
+    # label_studio_sdk<1 compatibility
+    import label_studio_sdk.project as ls_project  # type: ignore
+except ImportError:
+    # label_studio_sdk>=1 compatibility
+    import label_studio_sdk._legacy.project as ls_project  # type: ignore
+
 _logger = logging.getLogger('pixeltable')
 
 
@@ -50,11 +60,11 @@ class LabelStudioProject(Project):
         """
         self.project_id = project_id
         self.media_import_method = media_import_method
-        self._project: Optional[label_studio_sdk.project.Project] = None
+        self._project: Optional[ls_project.Project] = None
         super().__init__(name, col_mapping, stored_proxies)
 
     @property
-    def project(self) -> label_studio_sdk.project.Project:
+    def project(self) -> ls_project.Project:
         """The `Project` object corresponding to this Label Studio project."""
         if self._project is None:
             try:
@@ -536,6 +546,7 @@ class LabelStudioProject(Project):
             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':
         """
@@ -572,6 +583,31 @@ class LabelStudioProject(Project):
         if media_import_method == 'post' and len(config.data_keys) > 1:
             raise excs.Error('`media_import_method` cannot be `post` if there is more than one data key')
 
+        if s3_configuration is not None:
+            if media_import_method != 'url':
+                raise excs.Error("`s3_configuration` is only valid when `media_import_method == 'url'`")
+            s3_configuration = copy.copy(s3_configuration)
+            if not 'bucket' in s3_configuration:
+                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):
+                # 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
+                    s3_configuration['aws_secret_access_key'] = s3_credentials.secret_key
+                    s3_configuration['aws_session_token'] = s3_credentials.token
+                except Exception as exc:
+                    # This is not necessarily a problem, but we should log that it happened
+                    _logger.debug(f'Unable to retrieve AWS credentials from the environment: {exc}')
+                    pass
+
+        _logger.info(f'Creating Label Studio project: {title}')
         project = _label_studio_client().start_project(title=title, label_config=label_config, **kwargs)
 
         if media_import_method == 'file':
@@ -591,6 +627,10 @@ class LabelStudioProject(Project):
                         ) from exc
                 raise  # Handle any other exception type normally
 
+        if s3_configuration is not None:
+            _logger.info(f'Setting up S3 import storage for Label Studio project: {title}')
+            project.connect_s3_import_storage(**s3_configuration)
+
         project_id = project.get_params()['id']
         return LabelStudioProject(name, project_id, media_import_method, resolved_col_mapping)
 

pixeltable/io/pandas.py

@@ -1,4 +1,4 @@
-from typing import Optional, Any, Iterable
+from typing import Optional, Any, Iterable, Union
 
 import numpy as np
 import pandas as pd
@@ -9,7 +9,10 @@ import pixeltable.type_system as ts
 
 
 def import_pandas(
-    tbl_name: str, df: pd.DataFrame, *, schema_overrides: Optional[dict[str, pxt.ColumnType]] = None
+    tbl_name: str, df: pd.DataFrame, *, schema_overrides: Optional[dict[str, pxt.ColumnType]] = None,
+    primary_key: Optional[Union[str, list[str]]] = None,
+    num_retained_versions: int = 10,
+    comment: str = ''
 ) -> pxt.catalog.InsertableTable:
     """Creates a new `Table` from a Pandas `DataFrame`, with the specified name. The schema of the table
     will be inferred from the `DataFrame`, unless `schema` is specified.
@@ -31,13 +34,17 @@ def import_pandas(
     """
     schema = _df_to_pxt_schema(df, schema_overrides)
     tbl_rows = (dict(_df_row_to_pxt_row(row, schema)) for row in df.itertuples())
-    table = pxt.create_table(tbl_name, schema)
+    table = pxt.create_table(tbl_name, schema, primary_key=primary_key, num_retained_versions=num_retained_versions, comment=comment)
     table.insert(tbl_rows)
     return table
 
 
 def import_csv(
-    table_path: str, filepath_or_buffer, schema_overrides: Optional[dict[str, ts.ColumnType]] = None, **kwargs
+    tbl_name: str, filepath_or_buffer, schema_overrides: Optional[dict[str, ts.ColumnType]] = None,
+    primary_key: Optional[Union[str, list[str]]] = None,
+    num_retained_versions: int = 10,
+    comment: str = '',
+    **kwargs
 ) -> pxt.catalog.InsertableTable:
     """
     Creates a new `Table` from a csv file. This is a convenience method and is equivalent
@@ -45,11 +52,15 @@ def import_csv(
     See the Pandas documentation for `read_csv` for more details.
     """
     df = pd.read_csv(filepath_or_buffer, **kwargs)
-    return import_pandas(table_path, df, schema_overrides=schema_overrides)
+    return import_pandas(tbl_name, df, schema_overrides=schema_overrides, primary_key=primary_key, num_retained_versions=num_retained_versions, comment=comment)
 
 
 def import_excel(
-    table_path: str, io, *args, schema_overrides: Optional[dict[str, ts.ColumnType]] = None, **kwargs
+    tbl_name: str, io, *args, schema_overrides: Optional[dict[str, ts.ColumnType]] = None,
+    primary_key: Optional[Union[str, list[str]]] = None,
+    num_retained_versions: int = 10,
+    comment: str = '',
+    **kwargs
 ) -> pxt.catalog.InsertableTable:
     """
     Creates a new `Table` from an excel (.xlsx) file. This is a convenience method and is equivalent
@@ -57,7 +68,7 @@ def import_excel(
     See the Pandas documentation for `read_excel` for more details.
     """
     df = pd.read_excel(io, *args, **kwargs)
-    return import_pandas(table_path, df, schema_overrides=schema_overrides)
+    return import_pandas(tbl_name, df, schema_overrides=schema_overrides, primary_key=primary_key, num_retained_versions=num_retained_versions, comment=comment)
 
 
 def _df_to_pxt_schema(

pixeltable/plan.py

@@ -40,7 +40,7 @@ class Analyzer:
 
     def __init__(
             self, tbl: catalog.TableVersionPath, select_list: List[exprs.Expr],
-            where_clause: Optional[exprs.Predicate] = None, group_by_clause: Optional[List[exprs.Expr]] = None,
+            where_clause: Optional[exprs.Expr] = None, group_by_clause: Optional[List[exprs.Expr]] = None,
             order_by_clause: Optional[List[Tuple[exprs.Expr, bool]]] = None):
         if group_by_clause is None:
             group_by_clause = []
@@ -58,7 +58,7 @@ class Analyzer:
         # Where clause of the Select stmt of the SQL scan
         self.sql_where_clause: Optional[exprs.Expr] = None
         # filter predicate applied to output rows of the SQL scan
-        self.filter: Optional[exprs.Predicate] = None
+        self.filter: Optional[exprs.Expr] = None
         # not executable
         #self.similarity_clause: Optional[exprs.ImageSimilarityPredicate] = None
         if where_clause is not None:
@@ -183,7 +183,7 @@ class Planner:
     # TODO: create an exec.CountNode and change this to create_count_plan()
     @classmethod
     def create_count_stmt(
-            cls, tbl: catalog.TableVersionPath, where_clause: Optional[exprs.Predicate] = None
+            cls, tbl: catalog.TableVersionPath, where_clause: Optional[exprs.Expr] = None
     ) -> sql.Select:
         stmt = sql.select(sql.func.count('*'))
         refd_tbl_ids: Set[UUID] = set()
@@ -239,7 +239,7 @@ class Planner:
             cls, tbl: catalog.TableVersionPath,
             update_targets: dict[catalog.Column, exprs.Expr],
             recompute_targets: List[catalog.Column],
-            where_clause: Optional[exprs.Predicate], cascade: bool
+            where_clause: Optional[exprs.Expr], cascade: bool
     ) -> Tuple[exec.ExecNode, List[str], List[catalog.Column]]:
         """Creates a plan to materialize updated rows.
         The plan:
@@ -505,7 +505,7 @@ class Planner:
     @classmethod
     def create_query_plan(
             cls, tbl: catalog.TableVersionPath, select_list: Optional[List[exprs.Expr]] = None,
-            where_clause: Optional[exprs.Predicate] = None, group_by_clause: Optional[List[exprs.Expr]] = None,
+            where_clause: Optional[exprs.Expr] = None, group_by_clause: Optional[List[exprs.Expr]] = None,
             order_by_clause: Optional[List[Tuple[exprs.Expr, bool]]] = None, limit: Optional[int] = None,
             with_pk: bool = False, ignore_errors: bool = False, exact_version_only: Optional[List[catalog.TableVersion]] = None
     ) -> exec.ExecNode:
@@ -597,7 +597,7 @@ class Planner:
         return plan
 
     @classmethod
-    def analyze(cls, tbl: catalog.TableVersionPath, where_clause: exprs.Predicate) -> Analyzer:
+    def analyze(cls, tbl: catalog.TableVersionPath, where_clause: exprs.Expr) -> Analyzer:
         return Analyzer(tbl, [], where_clause=where_clause)
 
     @classmethod

pixeltable/tool/create_test_db_dump.py

@@ -208,7 +208,7 @@ class Dumper:
         add_column('not', ~(t.c2 > 20))
 
         # function_call
-        add_column('function_call', pxt.functions.string.str_format('{0} {key}', t.c1, key=t.c1))  # library function
+        add_column('function_call', pxt.functions.string.format('{0} {key}', t.c1, key=t.c1))  # library function
         add_column('test_udf', test_udf_stored(t.c2))  # stored udf
         add_column('test_udf_batched', test_udf_stored_batched(t.c1, upper=False))  # batched stored udf
         if include_expensive_functions:

pixeltable/tool/doc_plugins/griffe.py

@@ -0,0 +1,77 @@
+import ast
+from typing import Optional, Union
+
+import griffe
+import griffe.expressions
+from griffe import Extension, Object, ObjectNode
+
+import pixeltable as pxt
+
+logger = griffe.get_logger(__name__)
+
+class PxtGriffeExtension(Extension):
+    """Implementation of a Pixeltable custom griffe extension."""
+
+    def on_instance(self, node: Union[ast.AST, ObjectNode], obj: Object) -> None:
+        if obj.docstring is None:
+            # Skip over entities without a docstring
+            return
+
+        if isinstance(obj, griffe.Function):
+            # See if the (Python) function has a @pxt.udf decorator
+            if any(
+                isinstance(dec.value, griffe.expressions.Expr) and dec.value.canonical_path in ['pixeltable.func.udf', 'pixeltable.udf']
+                for dec in obj.decorators
+            ):
+                # Update the template
+                self.__modify_pxt_udf(obj)
+
+    def __modify_pxt_udf(self, func: griffe.Function) -> None:
+        """
+        Instructs the doc snippet for `func` to use the custom Pixeltable UDF jinja template, and
+        converts all type hints to Pixeltable column type references, in accordance with the @udf
+        decorator behavior.
+        """
+        func.extra['mkdocstrings']['template'] = 'udf.html.jinja'
+        # Dynamically load the UDF reference so we can inspect the Pixeltable signature directly
+        udf = griffe.dynamic_import(func.path)
+        assert isinstance(udf, pxt.Function)
+        # Convert the return type to a Pixeltable type reference
+        func.returns = self.__column_type_to_display_str(udf.signature.get_return_type())
+        # Convert the parameter types to Pixeltable type references
+        for griffe_param in func.parameters:
+            assert isinstance(griffe_param.annotation, griffe.expressions.Expr)
+            if griffe_param.name not in udf.signature.parameters:
+                logger.warning(f'Parameter `{griffe_param.name}` not found in signature for UDF: {udf.display_name}')
+                continue
+            pxt_param = udf.signature.parameters[griffe_param.name]
+            griffe_param.annotation = self.__column_type_to_display_str(pxt_param.col_type)
+
+    def __column_type_to_display_str(self, column_type: Optional[pxt.ColumnType]) -> str:
+        # TODO: When we enhance the Pixeltable type system, we may want to refactor some of this logic out.
+        #   I'm putting it here for now though.
+        if column_type is None:
+            return 'None'
+        if column_type.is_string_type():
+            base = 'str'
+        elif column_type.is_int_type():
+            base = 'int'
+        elif column_type.is_float_type():
+            base = 'float'
+        elif column_type.is_bool_type():
+            base = 'bool'
+        elif column_type.is_array_type():
+            base = 'ArrayT'
+        elif column_type.is_json_type():
+            base = 'JsonT'
+        elif column_type.is_image_type():
+            base = 'ImageT'
+        elif column_type.is_video_type():
+            base = 'VideoT'
+        elif column_type.is_audio_type():
+            base = 'AudioT'
+        elif column_type.is_document_type():
+            base = 'DocumentT'
+        else:
+            assert False
+        return f'Optional[{base}]' if column_type.nullable else base

pixeltable/tool/doc_plugins/mkdocstrings.py

@@ -0,0 +1,6 @@
+from pathlib import Path
+
+
+def get_templates_path() -> Path:
+    """Implementation of the 'mkdocstrings.python.templates' plugin for custom jinja templates."""
+    return Path(__file__).parent / "templates"

pixeltable/tool/doc_plugins/templates/material/udf.html.jinja

@@ -0,0 +1,135 @@
+{#- Template for Pixeltable UDFs. Cargo-culted (with modification) from _base/function.html.jinja. -#}
+
+{% block logs scoped %}
+  {#- Logging block.
+
+  This block can be used to log debug messages, deprecation messages, warnings, etc.
+  -#}
+  {{ log.debug("Rendering " + function.path) }}
+{% endblock logs %}
+
+{% import "language"|get_template as lang with context %}
+{#- Language module providing the `t` translation method. -#}
+
+<div class="doc doc-object doc-function">
+  {% with obj = function, html_id = function.path %}
+
+    {% if root %}
+      {% set show_full_path = config.show_root_full_path %}
+      {% set root_members = True %}
+    {% elif root_members %}
+      {% set show_full_path = config.show_root_members_full_path or config.show_object_full_path %}
+      {% set root_members = False %}
+    {% else %}
+      {% set show_full_path = config.show_object_full_path %}
+    {% endif %}
+
+    {% set function_name = function.path if show_full_path else function.name %}
+    {#- Brief or full function name depending on configuration. -#}
+    {% set symbol_type = "udf" %}
+    {#- Symbol type: method when parent is a class, function otherwise. -#}
+
+    {% if not root or config.show_root_heading %}
+      {% filter heading(
+          heading_level,
+          role="function",
+          id=html_id,
+          class="doc doc-heading",
+          toc_label=(('<code class="doc-symbol doc-symbol-toc doc-symbol-' + symbol_type + '"></code>&nbsp;')|safe if config.show_symbol_type_toc else '') + function.name,
+        ) %}
+
+        {% block heading scoped %}
+          {#- Heading block.
+
+          This block renders the heading for the function.
+          -#}
+          {% if config.show_symbol_type_heading %}<code class="doc-symbol doc-symbol-heading doc-symbol-{{ symbol_type }}"></code>{% endif %}
+          {% if config.separate_signature %}
+            <span class="doc doc-object-name doc-function-name">{{ function_name }}</span>
+          {% else %}
+            {%+ filter highlight(language="python", inline=True) %}
+              {{ function_name }}{% include "signature"|get_template with context %}
+            {% endfilter %}
+          {% endif %}
+        {% endblock heading %}
+
+        {% block labels scoped %}
+          {#- Labels block.
+
+          This block renders the labels for the function.
+          -#}
+          {% with labels = function.labels %}
+            {% include "labels"|get_template with context %}
+          {% endwith %}
+        {% endblock labels %}
+
+      {% endfilter %}
+
+      {% block signature scoped %}
+        {#- Signature block.
+
+        This block renders the signature for the function.
+        -#}
+        {% if config.separate_signature %}
+          {% filter format_signature(function, config.line_length, crossrefs=config.signature_crossrefs) %}
+            {{ function.name }}
+          {% endfilter %}
+        {% endif %}
+      {% endblock signature %}
+
+    {% else %}
+
+      {% if config.show_root_toc_entry %}
+        {% filter heading(
+            heading_level,
+            role="function",
+            id=html_id,
+            toc_label=(('<code class="doc-symbol doc-symbol-toc doc-symbol-' + symbol_type + '"></code>&nbsp;')|safe if config.show_symbol_type_toc else '') + function.name,
+            hidden=True,
+          ) %}
+        {% endfilter %}
+      {% endif %}
+      {% set heading_level = heading_level - 1 %}
+    {% endif %}
+
+    <div class="doc doc-contents {% if root %}first{% endif %}">
+      {% block contents scoped %}
+        {#- Contents block.
+
+        This block renders the contents of the function.
+        It contains other blocks that users can override.
+        Overriding the contents block allows to rearrange the order of the blocks.
+        -#}
+        {% block docstring scoped %}
+          {#- Docstring block.
+
+          This block renders the docstring for the function.
+          -#}
+          {% with docstring_sections = function.docstring.parsed %}
+            {% include "docstring"|get_template with context %}
+          {% endwith %}
+        {% endblock docstring %}
+
+        {% block source scoped %}
+          {#- Source block.
+
+          This block renders the source code for the function.
+          -#}
+          {% if config.show_source and function.source %}
+            <details class="quote">
+              <summary>{{ lang.t("Source code in") }} <code>
+                {%- if function.relative_filepath.is_absolute() -%}
+                  {{ function.relative_package_filepath }}
+                {%- else -%}
+                  {{ function.relative_filepath }}
+                {%- endif -%}
+              </code></summary>
+              {{ function.source|highlight(language="python", linestart=function.lineno, linenums=True) }}
+            </details>
+          {% endif %}
+        {% endblock source %}
+      {% endblock contents %}
+    </div>
+
+  {% endwith %}
+</div>

pixeltable/utils/s3.py

@@ -10,4 +10,4 @@ def get_client() -> Any:
     except AttributeError:
         # No credentials available, use unsigned mode
         config = botocore.config.Config(signature_version=botocore.UNSIGNED)
-        return boto3.client('s3', config=config)
+        return boto3.client('s3', config=config)