haystack-pixeltable 0.1.0__py3-none-any.whl

haystack_pixeltable/__init__.py

@@ -0,0 +1,8 @@
+"""Haystack Document Store and Retriever backed by Pixeltable."""
+
+from haystack_pixeltable.document_store import PixeltableDocumentStore
+from haystack_pixeltable.retriever import PixeltableRetriever
+
+__all__ = ["PixeltableDocumentStore", "PixeltableRetriever"]
+
+__version__ = "0.1.0"

haystack_pixeltable/document_store.py

@@ -0,0 +1,294 @@
+"""Pixeltable Document Store for Haystack.
+
+Implements the Haystack ``DocumentStore`` protocol, mapping CRUD operations
+to a Pixeltable table with an optional embedding index for similarity search.
+
+Key Pixeltable advantages:
+- ``.table`` property exposes the underlying Pixeltable table for computed
+  columns, version history, multimodal joins, and arbitrary predicates.
+- Metadata is stored as a JSON column, supporting Haystack's nested filter spec.
+- Embedding vectors are stored in a dedicated array column with an HNSW index.
+"""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import Any
+
+import numpy as np
+import pixeltable as pxt
+from haystack import Document, default_from_dict, default_to_dict
+from haystack.document_stores.errors import DocumentStoreError, DuplicateDocumentError
+from haystack.document_stores.types import DuplicatePolicy
+
+logger = logging.getLogger(__name__)
+
+_TEXT_COL = "content"
+_META_COL = "meta"
+_ID_COL = "doc_id"
+_EMBEDDING_COL = "embedding"
+
+
+class PixeltableDocumentStore:
+    """Haystack Document Store backed by a Pixeltable table.
+
+    Stores documents with content, metadata, and optional embedding vectors.
+    Supports the four mandatory ``DocumentStore`` protocol methods plus
+    serialization via ``to_dict`` / ``from_dict``.
+
+    Args:
+        table_name: Pixeltable table path (e.g. ``'haystack.docs'``).
+        embedding_dimension: Dimension of embedding vectors. Required if
+            embeddings will be stored. If ``None``, the embedding column
+            and index are not created.
+        metric: Distance metric for the embedding index
+            (``'cosine'``, ``'ip'``, or ``'l2'``).
+    """
+
+    def __init__(
+        self,
+        table_name: str = "haystack.documents",
+        *,
+        embedding_dimension: int | None = None,
+        metric: str = "cosine",
+    ):
+        self._table_name = table_name
+        self._embedding_dimension = embedding_dimension
+        self._metric = metric
+        self._table: pxt.Table | None = None
+
+    @property
+    def table(self) -> pxt.Table:
+        """Direct access to the underlying Pixeltable table.
+
+        Use for Pixeltable-native operations beyond the Haystack interface:
+        computed columns, ``.where()`` with arbitrary predicates, version
+        history, joins, and multimodal column types.
+        """
+        return self._get_or_create_table()
+
+    def _get_or_create_table(self) -> pxt.Table:
+        if self._table is not None:
+            return self._table
+
+        try:
+            self._table = pxt.get_table(self._table_name)
+            return self._table
+        except Exception:
+            pass
+
+        parts = self._table_name.rsplit(".", 1)
+        if len(parts) == 2:
+            pxt.create_dir(parts[0], if_exists="ignore")
+
+        schema: dict[str, Any] = {
+            _ID_COL: pxt.String,
+            _TEXT_COL: pxt.String,
+            _META_COL: pxt.Json,
+        }
+        if self._embedding_dimension is not None:
+            schema[_EMBEDDING_COL] = pxt.Array[(self._embedding_dimension,), pxt.Float]
+
+        self._table = pxt.create_table(self._table_name, schema, if_exists="ignore")
+
+        if self._embedding_dimension is not None:
+            self._table.add_embedding_index(
+                _EMBEDDING_COL,
+                metric=self._metric,
+                if_exists="ignore",
+            )
+        return self._table
+
+    def count_documents(self) -> int:
+        """Return the number of documents stored."""
+        t = self._get_or_create_table()
+        return t.count()
+
+    def filter_documents(self, filters: dict[str, Any] | None = None) -> list[Document]:
+        """Return documents matching the provided filters.
+
+        Supports the Haystack filter specification with ``field``,
+        ``operator``, and ``value`` keys, plus compound ``AND`` / ``OR`` /
+        ``NOT`` conditions.
+
+        Args:
+            filters: Haystack filter dict or ``None`` for all documents.
+
+        Returns:
+            List of matching Haystack ``Document`` objects.
+        """
+        t = self._get_or_create_table()
+
+        cols = [getattr(t, _ID_COL), getattr(t, _TEXT_COL), getattr(t, _META_COL)]
+        if self._embedding_dimension is not None:
+            cols.append(getattr(t, _EMBEDDING_COL))
+
+        chain = t.select(*cols)
+        predicate = self._build_predicate(filters)
+        if predicate is not None:
+            chain = t.where(predicate).select(*cols)
+
+        rows = chain.collect()
+        return [self._row_to_document(row) for row in rows]
+
+    def write_documents(
+        self,
+        documents: list[Document],
+        policy: DuplicatePolicy = DuplicatePolicy.NONE,
+    ) -> int:
+        """Write documents to the store.
+
+        Args:
+            documents: List of Haystack ``Document`` objects to write.
+            policy: How to handle duplicates: ``OVERWRITE``, ``SKIP``,
+                ``NONE`` (raise on duplicate), or ``FAIL`` (raise on duplicate).
+
+        Returns:
+            Number of documents written.
+        """
+        if not documents:
+            return 0
+
+        t = self._get_or_create_table()
+        id_col = getattr(t, _ID_COL)
+        written = 0
+
+        for doc in documents:
+            doc_id = doc.id or str(uuid.uuid4())
+
+            existing = t.where(id_col == doc_id).select(id_col).collect()
+            exists = len(existing) > 0
+
+            if exists:
+                if policy == DuplicatePolicy.FAIL:
+                    raise DuplicateDocumentError(f"Document with id {doc_id!r} already exists.")
+                if policy in (DuplicatePolicy.NONE, DuplicatePolicy.SKIP):
+                    continue
+                # OVERWRITE: delete then re-insert
+                t.delete(where=(id_col == doc_id))
+
+            row: dict[str, Any] = {
+                _ID_COL: doc_id,
+                _TEXT_COL: doc.content or "",
+                _META_COL: doc.meta or {},
+            }
+            if doc.embedding is not None and self._embedding_dimension is not None:
+                row[_EMBEDDING_COL] = doc.embedding
+            elif self._embedding_dimension is not None:
+                row[_EMBEDDING_COL] = [0.0] * self._embedding_dimension
+
+            t.insert([row])
+            written += 1
+
+        return written
+
+    def delete_documents(self, document_ids: list[str]) -> None:
+        """Delete documents by ID.
+
+        Args:
+            document_ids: List of document IDs to delete.
+        """
+        if not document_ids:
+            return
+        t = self._get_or_create_table()
+        id_col = getattr(t, _ID_COL)
+        for doc_id in document_ids:
+            t.delete(where=(id_col == doc_id))
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize this store to a dictionary."""
+        return default_to_dict(
+            self,
+            table_name=self._table_name,
+            embedding_dimension=self._embedding_dimension,
+            metric=self._metric,
+        )
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> PixeltableDocumentStore:
+        """Deserialize a store from a dictionary."""
+        return default_from_dict(cls, data)
+
+    def _row_to_document(self, row: dict[str, Any]) -> Document:
+        embedding = None
+        if self._embedding_dimension is not None and _EMBEDDING_COL in row:
+            val = row[_EMBEDDING_COL]
+            if val is not None:
+                embedding = list(np.asarray(val, dtype=np.float32))
+
+        return Document(
+            id=row[_ID_COL],
+            content=row[_TEXT_COL],
+            meta=row[_META_COL] or {},
+            embedding=embedding,
+        )
+
+    def _build_predicate(self, filters: dict[str, Any] | None) -> Any | None:
+        """Translate Haystack filter spec to a Pixeltable predicate."""
+        if not filters:
+            return None
+
+        t = self._get_or_create_table()
+
+        if "conditions" in filters:
+            return self._compound_predicate(t, filters)
+
+        if "field" in filters:
+            return self._comparison_predicate(t, filters)
+
+        return None
+
+    def _comparison_predicate(self, t: pxt.Table, f: dict[str, Any]) -> Any:
+        field = f["field"]
+        op = f["operator"]
+        value = f["value"]
+
+        if field.startswith("meta."):
+            meta_key = field[5:]
+            col = getattr(t, _META_COL)[meta_key]
+        elif field == "content":
+            col = getattr(t, _TEXT_COL)
+        elif field == "id":
+            col = getattr(t, _ID_COL)
+        else:
+            raise DocumentStoreError(f"Unsupported filter field: {field!r}")
+
+        ops = {
+            "==": lambda c, v: c == v,
+            "!=": lambda c, v: c != v,
+            ">": lambda c, v: c > v,
+            ">=": lambda c, v: c >= v,
+            "<": lambda c, v: c < v,
+            "<=": lambda c, v: c <= v,
+            "in": lambda c, v: c.isin(v),
+            "not in": lambda c, v: ~c.isin(v),
+        }
+
+        if op not in ops:
+            raise DocumentStoreError(f"Unsupported filter operator: {op!r}")
+
+        return ops[op](col, value)
+
+    def _compound_predicate(self, t: pxt.Table, f: dict[str, Any]) -> Any:
+        op = f.get("operator", "AND")
+        conditions = f["conditions"]
+
+        preds = [self._build_predicate(c) for c in conditions if self._build_predicate(c) is not None]
+        if not preds:
+            return None
+
+        if op == "AND":
+            result = preds[0]
+            for p in preds[1:]:
+                result = result & p
+            return result
+        elif op == "OR":
+            result = preds[0]
+            for p in preds[1:]:
+                result = result | p
+            return result
+        elif op == "NOT":
+            return ~preds[0]
+        else:
+            raise DocumentStoreError(f"Unsupported compound operator: {op!r}")

haystack_pixeltable/retriever.py

@@ -0,0 +1,117 @@
+"""Pixeltable Retriever for Haystack.
+
+A Haystack component that performs embedding-based similarity search on a
+``PixeltableDocumentStore``.  Designed to be used in Haystack pipelines
+alongside ``DocumentWriter``, embedders, and generators.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from haystack import Document, component, default_from_dict, default_to_dict
+
+from haystack_pixeltable.document_store import PixeltableDocumentStore
+
+_EMBEDDING_COL = "embedding"
+_TEXT_COL = "content"
+_META_COL = "meta"
+_ID_COL = "doc_id"
+
+
+@component
+class PixeltableRetriever:
+    """Retriever for ``PixeltableDocumentStore`` using embedding similarity.
+
+    Runs vector similarity search against the Pixeltable embedding index
+    and returns the top-k most relevant documents.
+
+    Args:
+        document_store: A ``PixeltableDocumentStore`` instance.
+        top_k: Maximum number of documents to return.
+        filters: Optional default filters applied to every query.
+    """
+
+    def __init__(
+        self,
+        document_store: PixeltableDocumentStore,
+        *,
+        top_k: int = 10,
+        filters: dict[str, Any] | None = None,
+    ):
+        self._document_store = document_store
+        self._top_k = top_k
+        self._filters = filters
+
+    @component.output_types(documents=list[Document])
+    def run(
+        self,
+        query_embedding: list[float],
+        *,
+        top_k: int | None = None,
+        filters: dict[str, Any] | None = None,
+    ) -> dict[str, list[Document]]:
+        """Retrieve documents by embedding similarity.
+
+        Args:
+            query_embedding: Query vector to search against.
+            top_k: Override the default top_k for this query.
+            filters: Override the default filters for this query.
+
+        Returns:
+            Dictionary with key ``"documents"`` containing the results.
+        """
+        k = top_k or self._top_k
+        active_filters = filters or self._filters
+
+        t = self._document_store.table
+        embed_col = getattr(t, _EMBEDDING_COL)
+        text_col = getattr(t, _TEXT_COL)
+        meta_col = getattr(t, _META_COL)
+        id_col = getattr(t, _ID_COL)
+
+        query_vec = np.array(query_embedding, dtype=np.float32)
+        sim = embed_col.similarity(vector=query_vec)
+
+        chain = t
+        predicate = self._document_store._build_predicate(active_filters)
+        if predicate is not None:
+            chain = chain.where(predicate)
+
+        rows = chain.order_by(sim, asc=False).limit(k).select(id_col, text_col, meta_col, embed_col, sim=sim).collect()
+
+        documents = []
+        for row in rows:
+            embedding = None
+            val = row.get(_EMBEDDING_COL)
+            if val is not None:
+                embedding = list(np.asarray(val, dtype=np.float32))
+
+            doc = Document(
+                id=row[_ID_COL],
+                content=row[_TEXT_COL],
+                meta=row[_META_COL] or {},
+                embedding=embedding,
+                score=float(row["sim"]),
+            )
+            documents.append(doc)
+
+        return {"documents": documents}
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize this retriever to a dictionary."""
+        return default_to_dict(
+            self,
+            document_store=self._document_store.to_dict(),
+            top_k=self._top_k,
+            filters=self._filters,
+        )
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> PixeltableRetriever:
+        """Deserialize a retriever from a dictionary."""
+        data["init_parameters"]["document_store"] = PixeltableDocumentStore.from_dict(
+            data["init_parameters"]["document_store"]
+        )
+        return default_from_dict(cls, data)

haystack_pixeltable-0.1.0.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: haystack-pixeltable
+Version: 0.1.0
+Summary: Haystack Document Store and Retriever backed by Pixeltable multimodal data infrastructure.
+Author-email: Pixeltable <contact@pixeltable.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/pixeltable/haystack-pixeltable
+Project-URL: Repository, https://github.com/pixeltable/haystack-pixeltable
+Project-URL: Documentation, https://docs.pixeltable.com/
+Project-URL: Issues, https://github.com/pixeltable/haystack-pixeltable/issues
+Project-URL: Discord, https://discord.gg/QPyqFYx2UN
+Keywords: haystack,pixeltable,document-store,retriever,multimodal,embeddings,rag
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: haystack-ai>=2.6.0
+Requires-Dist: pixeltable>=0.2.28
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Dynamic: license-file
+
+# pixeltable-haystack
+
+[![PyPI](https://img.shields.io/pypi/v/pixeltable-haystack)](https://pypi.org/project/pixeltable-haystack/)
+[![CI](https://github.com/pixeltable/haystack-pixeltable/actions/workflows/ci.yml/badge.svg)](https://github.com/pixeltable/haystack-pixeltable/actions/workflows/ci.yml)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+
+Haystack Document Store and Retriever backed by [Pixeltable](https://pixeltable.com/) — persistent, versioned, multimodal data infrastructure for AI applications.
+
+## Installation
+
+```bash
+pip install pixeltable-haystack
+```
+
+## Quick Start
+
+### Document Store
+
+```python
+from haystack import Document
+from haystack_pixeltable import PixeltableDocumentStore
+
+store = PixeltableDocumentStore(
+    table_name="myproject.docs",
+    embedding_dimension=1536,
+)
+
+# Write documents
+store.write_documents([
+    Document(content="Pixeltable is multimodal data infrastructure.", embedding=[...]),
+    Document(content="Haystack is a framework for building RAG pipelines.", embedding=[...]),
+])
+
+# Filter documents
+results = store.filter_documents(
+    filters={"field": "meta.category", "operator": "==", "value": "docs"}
+)
+
+# Count
+print(store.count_documents())
+```
+
+### Retriever (Similarity Search)
+
+```python
+from haystack_pixeltable import PixeltableDocumentStore, PixeltableRetriever
+
+store = PixeltableDocumentStore(
+    table_name="myproject.docs",
+    embedding_dimension=1536,
+)
+retriever = PixeltableRetriever(document_store=store, top_k=5)
+
+# Search by embedding vector
+result = retriever.run(query_embedding=[0.1, 0.2, ...])
+for doc in result["documents"]:
+    print(f"{doc.content} (score: {doc.score:.3f})")
+```
+
+### In a Haystack Pipeline
+
+```python
+from haystack import Pipeline
+from haystack.components.embedders import SentenceTransformersTextEmbedder, SentenceTransformersDocumentEmbedder
+from haystack.components.writers import DocumentWriter
+from haystack_pixeltable import PixeltableDocumentStore, PixeltableRetriever
+
+store = PixeltableDocumentStore(
+    table_name="rag.knowledge",
+    embedding_dimension=384,
+)
+
+# Indexing pipeline
+indexing = Pipeline()
+indexing.add_component("embedder", SentenceTransformersDocumentEmbedder())
+indexing.add_component("writer", DocumentWriter(document_store=store))
+indexing.connect("embedder", "writer")
+
+# Query pipeline
+query = Pipeline()
+query.add_component("embedder", SentenceTransformersTextEmbedder())
+query.add_component("retriever", PixeltableRetriever(document_store=store, top_k=5))
+query.connect("embedder.embedding", "retriever.query_embedding")
+```
+
+## Filtering
+
+The Document Store supports the [Haystack filter specification](https://docs.haystack.deepset.ai/docs/metadata-filtering):
+
+```python
+# Simple equality
+store.filter_documents(filters={"field": "meta.category", "operator": "==", "value": "science"})
+
+# Comparison operators: ==, !=, >, >=, <, <=
+store.filter_documents(filters={"field": "meta.score", "operator": ">", "value": 0.8})
+
+# Compound AND
+store.filter_documents(filters={
+    "operator": "AND",
+    "conditions": [
+        {"field": "meta.category", "operator": "==", "value": "science"},
+        {"field": "meta.score", "operator": ">", "value": 0.5},
+    ],
+})
+
+# Compound OR
+store.filter_documents(filters={
+    "operator": "OR",
+    "conditions": [
+        {"field": "meta.source", "operator": "==", "value": "arxiv"},
+        {"field": "meta.source", "operator": "==", "value": "pubmed"},
+    ],
+})
+```
+
+## Pixeltable Escape Hatch: `.table`
+
+The `.table` property gives direct access to the underlying Pixeltable table for operations beyond the Haystack interface:
+
+```python
+store = PixeltableDocumentStore(table_name="myproject.docs", embedding_dimension=1536)
+t = store.table
+
+# Add a computed column
+import pixeltable.functions.openai as openai
+t.add_computed_column(
+    summary=openai.chat_completions(
+        messages=[{"role": "user", "content": t.content}],
+        model="gpt-4o-mini",
+    )
+)
+
+# Use arbitrary Pixeltable queries
+results = t.where(t.meta["category"] == "science").select(t.content, t.summary).collect()
+
+# Version history
+print(t.count(version=-1))  # row count at previous version
+```
+
+## Why Pixeltable?
+
+| Feature | Pixeltable | Chroma | Qdrant | pgvector |
+|---------|-----------|--------|--------|----------|
+| Persistent storage | Built-in | Opt-in | Opt-in | Built-in |
+| Computed columns | Native | No | No | No |
+| Version history | Native | No | No | No |
+| Multimodal types | Image, Video, Audio, Document | Text only | Text only | Text only |
+| Metadata filtering | JSON + SQL predicates | Limited | Rich | SQL |
+| Embedding auto-compute | Via computed columns | Manual | Manual | Manual |
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest tests/ -v
+ruff check . && ruff format --check .
+```
+
+## License
+
+Apache 2.0

haystack_pixeltable-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+haystack_pixeltable/__init__.py,sha256=ozoF_MAB4W7M_-0lkqje5CnYveETF2fzFKQc2r8xwio,285
+haystack_pixeltable/document_store.py,sha256=lfNQBHnZaFuLmhKhcPEheKRvvAstOGJlfetXOigBAtU,9818
+haystack_pixeltable/retriever.py,sha256=U8N8miK0zWMF-i1TOKjlLRp0Kap2Jf_8p91kLHk5Q5g,3749
+haystack_pixeltable-0.1.0.dist-info/licenses/LICENSE,sha256=Lv1r3wd8fcY9xjdHLrJDE2yt7_JzPko2E-F6HTK_c1g,5346
+haystack_pixeltable-0.1.0.dist-info/METADATA,sha256=lyWvM85YzDUhW0ey7HXxw8dW0QkSE_adGavmROogES0,6165
+haystack_pixeltable-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+haystack_pixeltable-0.1.0.dist-info/top_level.txt,sha256=dh7ri7i02q4wye4hDD25fEFi38zpgCbCOOlerrEotVI,20
+haystack_pixeltable-0.1.0.dist-info/RECORD,,

haystack_pixeltable-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

haystack_pixeltable-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,112 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work.
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work, that is intentionally submitted to the Licensor for
+      inclusion in the Work by the copyright owner or by an individual or
+      Legal Entity authorized to submit on behalf of the copyright owner.
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file.
+
+   5. Submission of Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor.
+
+   7. Disclaimer of Warranty.
+
+   8. Limitation of Liability.
+
+   9. Accepting Warranty or Additional Liability.
+
+   Copyright 2024-2026 Pixeltable, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

haystack_pixeltable-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+haystack_pixeltable