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

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:
@@ -253,7 +253,7 @@ class Dumper:
         add_column('c6_to_string', t.c6.apply(json.dumps))
         add_column('c6_back_to_json', t[f'{col_prefix}_c6_to_string'].apply(json.loads))
 
-        t.add_embedding_index(f'{col_prefix}_function_call', text_embed=embed_udf.clip_text_embed)
+        t.add_embedding_index(f'{col_prefix}_function_call', string_embed=embed_udf.clip_text_embed)
 
         # query()
         @t.query

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)

pixeltable-0.2.13.dist-info/METADATA

@@ -0,0 +1,206 @@
+Metadata-Version: 2.1
+Name: pixeltable
+Version: 0.2.13
+Summary: Pixeltable: The Multimodal AI Data Plane
+Author: Pixeltable, Inc.
+Author-email: contact@pixeltable.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: av (>=10.0.0)
+Requires-Dist: beautifulsoup4 (>=4.0.0,<5.0.0)
+Requires-Dist: cloudpickle (>=2.2.1,<3.0.0)
+Requires-Dist: ftfy (>=6.2.0,<7.0.0)
+Requires-Dist: jinja2 (>=3.1.3,<4.0.0)
+Requires-Dist: jmespath (>=1.0.1,<2.0.0)
+Requires-Dist: mistune (>=3.0.2,<4.0.0)
+Requires-Dist: more-itertools (>=10.2,<11.0)
+Requires-Dist: numpy (>=1.25)
+Requires-Dist: opencv-python-headless (>=4.7.0.68,<5.0.0.0)
+Requires-Dist: pandas (>=2.0,<3.0)
+Requires-Dist: pgserver (==0.1.4)
+Requires-Dist: pgvector (>=0.2.1,<0.3.0)
+Requires-Dist: pillow (>=9.3.0)
+Requires-Dist: psutil (>=5.9.5,<6.0.0)
+Requires-Dist: psycopg2-binary (>=2.9.5,<3.0.0)
+Requires-Dist: pymupdf (>=1.24.1,<2.0.0)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: setuptools (==69.1.1)
+Requires-Dist: sqlalchemy[mypy] (>=2.0.23,<3.0.0)
+Requires-Dist: tenacity (>=8.2,<9.0)
+Requires-Dist: tqdm (>=4.64)
+Description-Content-Type: text/markdown
+
+<div align="center">
+<img src="https://raw.githubusercontent.com/pixeltable/pixeltable/master/docs/release/pixeltable-banner.png" alt="Pixeltable" width="45%" />
+
+# Unifying Data, Models, and Orchestration for AI Products
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-darkblue.svg)](https://opensource.org/licenses/Apache-2.0)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pixeltable?logo=python&logoColor=white)
+[![Platform Support](https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20Windows-8A2BE2)]()
+[![pytest status](https://github.com/pixeltable/pixeltable/actions/workflows/pytest.yml/badge.svg)](https://github.com/pixeltable/pixeltable/actions)
+[![PyPI Package](https://img.shields.io/pypi/v/pixeltable?color=darkorange)](https://pypi.org/project/pixeltable/)
+
+[Installation](https://pixeltable.github.io/pixeltable/getting-started/) | [Documentation](https://pixeltable.readme.io/) | [API Reference](https://pixeltable.github.io/pixeltable/) | [Code Samples](https://pixeltable.readme.io/recipes) | [Examples](https://github.com/pixeltable/pixeltable/tree/master/docs/release/tutorials)
+</div>
+
+Pixeltable is a Python library that lets ML Engineers and Data Scientists focus on exploration, modeling, and app development without dealing with the customary data plumbing.
+
+### What problems does Pixeltable solve?
+
+Today’s solutions for AI app development require extensive custom coding and infrastructure plumbing. Tracking lineage and versions between and across data transformations, models, and deployment is cumbersome.
+
+## 💾 Installation
+
+```python
+pip install pixeltable
+```
+> [!IMPORTANT]
+> Pixeltable is persistent. Unlike in-memory Python libraries such as Pandas, Pixeltable is a database. When working locally or against an hosted version of Pixeltable, use [get_table](https://pixeltable.github.io/pixeltable/api/pixeltable/#pixeltable.get_table) at any time to retrieve an existing table.
+
+## 💡 Getting Started
+Learn how to create tables, populate them with data, and enhance them with built-in or user-defined transformations and AI operations.
+
+| Topic | Notebook | Topic | Notebook |
+|:----------|:-----------------|:-------------------------|:---------------------------------:|
+| 10-Minute Tour of Pixeltable    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/tutorials/pixeltable-basics.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a> | Tables and Data Operations    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/fundamentals/tables-and-data-operations.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+| User-Defined Functions (UDFs)    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/howto/udfs-in-pixeltable.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a> | Object Detection Models | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/tutorials/object-detection-in-videos.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+| Experimenting with Chunking (RAG) | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/tutorials/rag-operations.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> | Working with External Files    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/howto/working-with-external-files.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+| Integrating with Label Studio    | <a target="_blank" href="https://pixeltable.readme.io/docs/label-studio"> <img src="https://img.shields.io/badge/Docs-Label Studio-blue" alt="Visit our documentation"/></a> | Audio/Video Transcript Indexing    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/tutorials/audio-transcriptions.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+
+## 🧱 Code Samples
+
+### Import media data into Pixeltable (videos, images, audio...)
+```python
+import pixeltable as pxt
+
+v = pxt.create_table('external_data.videos', {'video': pxt.VideoType()})
+
+prefix = 's3://multimedia-commons/'
+paths = [
+    'data/videos/mp4/ffe/ffb/ffeffbef41bbc269810b2a1a888de.mp4',
+    'data/videos/mp4/ffe/feb/ffefebb41485539f964760e6115fbc44.mp4',
+    'data/videos/mp4/ffe/f73/ffef7384d698b5f70d411c696247169.mp4'
+]
+v.insert({'video': prefix + p} for p in paths)
+```
+Learn how to [work with data in Pixeltable](https://pixeltable.readme.io/docs/working-with-external-files).
+
+### Add an object detection model to your workflow
+```python
+table['detections'] = huggingface.detr_for_object_detection(table.input_image, model_id='facebook/detr-resnet-50')
+```
+Learn about computed columns and object detection: [Comparing object detection models](https://pixeltable.readme.io/docs/object-detection-in-videos).
+
+### Extend Pixeltable's capabilities with user-defined functions
+```python
+@pxt.udf
+def draw_boxes(img: PIL.Image.Image, boxes: list[list[float]]) -> PIL.Image.Image:
+    result = img.copy()  # Create a copy of `img`
+    d = PIL.ImageDraw.Draw(result)
+    for box in boxes:
+        d.rectangle(box, width=3)  # Draw bounding box rectangles on the copied image
+    return result
+```
+Learn more about user-defined functions: [UDFs in Pixeltable](https://pixeltable.readme.io/docs/user-defined-functions-udfs).
+
+### Automate data operations with views
+```python
+# In this example, the view is defined by iteration over the chunks of a DocumentSplitter.
+chunks_table = pxt.create_view(
+    'rag_demo.chunks',
+    documents_table,
+    iterator=DocumentSplitter.create(
+        document=documents_table.document,
+        separators='token_limit', limit=300)
+)
+```
+Learn how to leverage views to build your [RAG workflow](https://pixeltable.readme.io/docs/document-indexing-and-rag).
+
+### Evaluate model performance
+```python
+# The computation of the mAP metric can simply become a query over the evaluation output, aggregated with the mean_ap() function.
+frames_view.select(mean_ap(frames_view.eval_yolox_tiny), mean_ap(frames_view.eval_yolox_m)).show()
+```
+Learn how to leverage Pixeltable for [Model analytics](https://pixeltable.readme.io/docs/object-detection-in-videos).
+
+### Working with inference services
+```python
+chat_table = pxt.create_table('together_demo.chat', {'input': pxt.StringType()})
+
+# The chat-completions API expects JSON-formatted input:
+messages = [{'role': 'user', 'content': chat_table.input}]
+
+# This example shows how additional parameters from the Together API can be used in Pixeltable to customize the model behavior.
+chat_table['output'] = chat_completions(
+    messages=messages,
+    model='mistralai/Mixtral-8x7B-Instruct-v0.1',
+    max_tokens=300,
+    stop=['\n'],
+    temperature=0.7,
+    top_p=0.9,
+    top_k=40,
+    repetition_penalty=1.1,
+    logprobs=1,
+    echo=True
+)
+chat_table['response'] = chat_table.output.choices[0].message.content
+
+# Start a conversation
+chat_table.insert([
+    {'input': 'How many species of felids have been classified?'},
+    {'input': 'Can you make me a coffee?'}
+])
+chat_table.select(chat_table.input, chat_table.response).head()
+```
+Learn how to interact with inference services such as [Together AI](https://pixeltable.readme.io/docs/together-ai) in Pixeltable.
+
+## ❓ FAQ
+
+### What is Pixeltable?
+
+Pixeltable unifies data storage, versioning, and indexing with orchestration and model versioning under a declarative table interface, with transformations, model inference, and custom logic represented as computed columns.
+
+### What does Pixeltable provide me with? Pixeltable provides:
+
+- Data storage and versioning
+- Combined Data and Model Lineage
+- Indexing (e.g. embedding vectors) and Data Retrieval
+- Orchestration of multimodal workloads
+- Incremental updates
+- Code is automatically production-ready
+
+### Why should you use Pixeltable?
+
+- **It gives you transparency and reproducibility**
+  - All generated data is automatically recorded and versioned
+  - You will never need to re-run a workload because you lost track of the input data
+- **It saves you money**
+  - All data changes are automatically incremental
+  - You never need to re-run pipelines from scratch because you’re adding data
+- **It integrates with any existing Python code or libraries**
+  - Bring your ever-changing code and workloads
+  - You choose the models, tools, and AI practices (e.g., your embedding model for a vector index); Pixeltable orchestrates the data
+ 
+### What is Pixeltable not providing?
+
+- Pixeltable is not a low-code, prescriptive AI solution. We empower you to use the best frameworks and techniques for your specific needs.
+- We do not aim to replace your existing AI toolkit, but rather enhance it by streamlining the underlying data infrastructure and orchestration.
+
+> [!TIP]
+> Check out the [Integrations](https://pixeltable.readme.io/docs/working-with-openai) section, and feel free to submit a request for additional ones.
+
+## 🐛 Contributions & Feedback
+
+Are you experiencing issues or bugs with Pixeltable? File an [Issue](https://github.com/pixeltable/pixeltable/issues).
+</br>Do you want to contribute? Feel free to open a [PR](https://github.com/pixeltable/pixeltable/pulls).
+
+## :classical_building: License
+
+This library is licensed under the Apache 2.0 License.
+