pixeltable 0.2.26__py3-none-any.whl → 0.5.7__py3-none-any.whl

pixeltable/iterators/document.py

@@ -1,13 +1,17 @@
 import dataclasses
 import enum
 import logging
-from typing import Any, Iterable, Iterator, Optional, Union
+from typing import Any, ClassVar, Iterable, Iterator, Literal
 
 import ftfy
+import PIL.Image
+from bs4.element import NavigableString, Tag
+from deprecated import deprecated
+from pypdfium2 import PdfDocument  # type: ignore[import-untyped]
 
 from pixeltable.env import Env
 from pixeltable.exceptions import Error
-from pixeltable.type_system import ColumnType, DocumentType, IntType, JsonType, StringType
+from pixeltable.type_system import ColumnType, DocumentType, ImageType, IntType, JsonType, StringType
 from pixeltable.utils.documents import get_document_handle
 
 from .base import ComponentIterator
@@ -15,6 +19,11 @@ from .base import ComponentIterator
 _logger = logging.getLogger('pixeltable')
 
 
+class Element(enum.Enum):
+    TEXT = 1
+    IMAGE = 2
+
+
 class ChunkMetadata(enum.Enum):
     TITLE = 1
     HEADING = 2
@@ -35,27 +44,30 @@ class Separator(enum.Enum):
 @dataclasses.dataclass
 class DocumentSectionMetadata:
     """Metadata for a subsection of a document (ie, a structural element like a heading or paragraph)"""
+
     # html and markdown metadata
-    sourceline: Optional[int] = None
+    sourceline: int | None = None
     # the stack of headings up to the most recently observed one;
     # eg, if the most recent one was an h2, 'headings' would contain keys 1 and 2, but nothing below that
-    heading: Optional[dict[str, str]] = None
+    heading: dict[str, str] | None = None
 
     # pdf-specific metadata
-    page: Optional[int] = None
+    page: int | None = None
     # bounding box as an {x1, y1, x2, y2} dictionary
-    bounding_box: Optional[dict[str, float]] = None
+    bounding_box: dict[str, float] | None = None
 
 
 @dataclasses.dataclass
 class DocumentSection:
     """A single document chunk, according to some of the splitting criteria"""
-    text: Optional[str]
-    metadata: Optional[DocumentSectionMetadata]
+
+    text: str | None = None
+    image: PIL.Image.Image | None = None
+    metadata: DocumentSectionMetadata | None = None
 
 
 def _parse_separators(separators: str) -> list[Separator]:
-    ret = []
+    ret: list[Separator] = []
     for s in separators.split(','):
         clean_s = s.strip().upper()
         if not clean_s:
@@ -69,7 +81,7 @@ def _parse_separators(separators: str) -> list[Separator]:
 
 
 def _parse_metadata(metadata: str) -> list[ChunkMetadata]:
-    ret = []
+    ret: list[ChunkMetadata] = []
     for m in metadata.split(','):
         clean_m = m.strip().upper()
         if not clean_m:
@@ -82,18 +94,23 @@ def _parse_metadata(metadata: str) -> list[ChunkMetadata]:
     return ret
 
 
-_HTML_HEADINGS = {'h1', 'h2', 'h3', 'h4', 'h5', 'h6'}
+def _parse_elements(elements: list[Literal['text', 'image']]) -> list[Element]:
+    result: list[Element] = []
+    for e in elements:
+        clean_e = e.strip().upper()
+        if clean_e not in Element.__members__:
+            raise Error(f'Invalid element: `{e}`. Valid elements are: {", ".join(Element.__members__).lower()}')
+        result.append(Element[clean_e])
+    if len(result) == 0:
+        raise Error('elements cannot be empty')
+    return result
 
 
-class DocumentSplitter(ComponentIterator):
-    """Iterator over chunks of a document. The document is chunked according to the specified `separators`.
+_HTML_HEADINGS = {'h1', 'h2', 'h3', 'h4', 'h5', 'h6'}
 
-    The iterator yields a `text` field containing the text of the chunk, and it may also
-    include additional metadata fields if specified in the `metadata` parameter, as explained below.
 
-    Chunked text will be cleaned with `ftfy.fix_text` to fix up common problems with unicode sequences.
-    """
-    METADATA_COLUMN_TYPES = {
+class DocumentSplitter(ComponentIterator):
+    METADATA_COLUMN_TYPES: ClassVar[dict[ChunkMetadata, ColumnType]] = {
         ChunkMetadata.TITLE: StringType(nullable=True),
         ChunkMetadata.HEADING: JsonType(nullable=True),
         ChunkMetadata.SOURCELINE: IntType(nullable=True),
@@ -101,30 +118,41 @@ class DocumentSplitter(ComponentIterator):
         ChunkMetadata.BOUNDING_BOX: JsonType(nullable=True),
     }
 
+    _doc_handle: Any
+    _separators: list[Separator]
+    _elements: list[Element]
+    _metadata_fields: list[ChunkMetadata]
+    _doc_title: str
+    _limit: int
+    _skip_tags: list[str]
+    _overlap: int
+    _tiktoken_encoding: str | None
+    _tiktoken_target_model: str | None
+    _image_dpi: int
+    _image_format: str
+
+    _sections: Iterator[DocumentSection]
+
     def __init__(
-            self, document: str, *, separators: str, limit: Optional[int] = None, overlap: Optional[int] = None,
-            metadata: str = '',
-            html_skip_tags: Optional[list[str]] = None, tiktoken_encoding: Optional[str] = 'cl100k_base',
-            tiktoken_target_model: Optional[str] = None
+        self,
+        document: str,
+        *,
+        separators: str,
+        elements: list[Literal['text', 'image']] | None = None,
+        limit: int | None = None,
+        overlap: int | None = None,
+        metadata: str = '',
+        skip_tags: list[str] | None = None,
+        tiktoken_encoding: str | None = 'cl100k_base',
+        tiktoken_target_model: str | None = None,
+        image_dpi: int = 300,
+        image_format: str = 'png',
     ):
-        """Init method for `DocumentSplitter` class.
-
-        Args:
-            separators: separators to use to chunk the document. Options are:
-                 `'heading'`, `'paragraph'`, `'sentence'`, `'token_limit'`, `'char_limit'`, `'page'`.
-                 This may be a comma-separated string, e.g., `'heading,token_limit'`.
-            limit: the maximum number of tokens or characters in each chunk, if `'token_limit'`
-                 or `'char_limit'` is specified.
-            metadata: additional metadata fields to include in the output. Options are:
-                 `'title'`, `'heading'` (HTML and Markdown), `'sourceline'` (HTML), `'page'` (PDF), `'bounding_box'`
-                 (PDF). The input may be a comma-separated string, e.g., `'title,heading,sourceline'`.
-        """
-        if html_skip_tags is None:
-            html_skip_tags = ['nav']
+        if skip_tags is None:
+            skip_tags = ['nav']
         self._doc_handle = get_document_handle(document)
+        self._elements = _parse_elements(elements.copy()) if elements is not None else [Element.TEXT]
         assert self._doc_handle is not None
-        # calling the output_schema method to validate the input arguments
-        self.output_schema(separators=separators, metadata=metadata, limit=limit, overlap=overlap)
         self._separators = _parse_separators(separators)
         self._metadata_fields = _parse_metadata(metadata)
         if self._doc_handle.bs_doc is not None:
@@ -136,10 +164,12 @@ class DocumentSplitter(ComponentIterator):
         else:
             self._doc_title = ''
         self._limit = 0 if limit is None else limit
-        self._skip_tags = html_skip_tags
+        self._skip_tags = skip_tags
         self._overlap = 0 if overlap is None else overlap
         self._tiktoken_encoding = tiktoken_encoding
         self._tiktoken_target_model = tiktoken_target_model
+        self._image_dpi = image_dpi
+        self._image_format = image_format
 
         # set up processing pipeline
         if self._doc_handle.format == DocumentType.DocumentFormat.HTML:
@@ -151,8 +181,11 @@ class DocumentSplitter(ComponentIterator):
         elif self._doc_handle.format == DocumentType.DocumentFormat.PDF:
             assert self._doc_handle.pdf_doc is not None
             self._sections = self._pdf_sections()
+        elif self._doc_handle.format == DocumentType.DocumentFormat.TXT:
+            assert self._doc_handle.txt_doc is not None
+            self._sections = self._txt_sections()
         else:
-            assert False, f'Unsupported document format: {self._doc_handle.format}'
+            raise AssertionError(f'Unsupported document format: {self._doc_handle.format}')
 
         if Separator.SENTENCE in self._separators:
             self._sections = self._sentence_sections(self._sections)
@@ -166,19 +199,28 @@ class DocumentSplitter(ComponentIterator):
         return {
             'document': DocumentType(nullable=False),
             'separators': StringType(nullable=False),
+            'elements': JsonType(nullable=False),
             'metadata': StringType(nullable=False),
             'limit': IntType(nullable=True),
             'overlap': IntType(nullable=True),
             'skip_tags': StringType(nullable=True),
             'tiktoken_encoding': StringType(nullable=True),
             'tiktoken_target_model': StringType(nullable=True),
+            'image_dpi': IntType(nullable=True),
+            'image_format': StringType(nullable=True),
         }
 
     @classmethod
     def output_schema(cls, *args: Any, **kwargs: Any) -> tuple[dict[str, ColumnType], list[str]]:
-        schema: dict[str, ColumnType] = {'text': StringType()}
-        md_fields = _parse_metadata(kwargs['metadata']) if 'metadata' in kwargs else []
-
+        schema: dict[str, ColumnType] = {}
+        elements = _parse_elements(kwargs.get('elements', ['text']))
+        for element in elements:
+            if element == Element.TEXT:
+                schema['text'] = StringType(nullable=False)
+            elif element == Element.IMAGE:
+                schema['image'] = ImageType(nullable=False)
+
+        md_fields = _parse_metadata(kwargs.get('metadata', ''))
         for md_field in md_fields:
             schema[md_field.name.lower()] = cls.METADATA_COLUMN_TYPES[md_field]
 
@@ -188,6 +230,8 @@ class DocumentSplitter(ComponentIterator):
         limit = kwargs.get('limit')
         overlap = kwargs.get('overlap')
 
+        if Element.IMAGE in elements and separators != [Separator.PAGE]:
+            raise Error('Image elements are only supported for the "page" separator on PDF documents')
         if limit is not None or overlap is not None:
             if Separator.TOKEN_LIMIT not in separators and Separator.CHAR_LIMIT not in separators:
                 raise Error('limit/overlap requires the "token_limit" or "char_limit" separator')
@@ -201,9 +245,8 @@ class DocumentSplitter(ComponentIterator):
             if kwargs.get('limit') is None:
                 raise Error('limit is required with "token_limit"/"char_limit" separators')
 
-        # check dependencies at the end
         if Separator.SENTENCE in separators:
-            Env.get().require_package('spacy')
+            _ = Env.get().spacy_nlp
         if Separator.TOKEN_LIMIT in separators:
             Env.get().require_package('tiktoken')
 
@@ -212,9 +255,15 @@ class DocumentSplitter(ComponentIterator):
     def __next__(self) -> dict[str, Any]:
         while True:
             section = next(self._sections)
-            if section.text is None:
+            if section.text is None and section.image is None:
                 continue
-            result: dict[str, Any] = {'text': section.text}
+            result: dict[str, Any] = {}
+            for element in self._elements:
+                if element == Element.TEXT:
+                    result['text'] = section.text
+                elif element == Element.IMAGE:
+                    result['image'] = section.image
+
             for md_field in self._metadata_fields:
                 if md_field == ChunkMetadata.TITLE:
                     result[md_field.name.lower()] = self._doc_title
@@ -226,18 +275,20 @@ class DocumentSplitter(ComponentIterator):
                     result[md_field.name.lower()] = section.metadata.page
                 elif md_field == ChunkMetadata.BOUNDING_BOX:
                     result[md_field.name.lower()] = section.metadata.bounding_box
+
             return result
 
     def _html_sections(self) -> Iterator[DocumentSection]:
         """Create DocumentSections reflecting the html-specific separators"""
         import bs4
+
         emit_on_paragraph = Separator.PARAGRAPH in self._separators or Separator.SENTENCE in self._separators
         emit_on_heading = Separator.HEADING in self._separators or emit_on_paragraph
         # current state
         accumulated_text: list[str] = []  # currently accumulated text
         # accumulate pieces then join before emit to avoid quadratic complexity of string concatenation
 
-        headings: dict[str, str] = {}   # current state of observed headings (level -> text)
+        headings: dict[str, str] = {}  # current state of observed headings (level -> text)
         sourceline = 0  # most recently seen sourceline
 
         def update_metadata(el: bs4.Tag) -> None:
@@ -246,9 +297,9 @@ class DocumentSplitter(ComponentIterator):
             sourceline = el.sourceline
             if el.name in _HTML_HEADINGS:
                 # remove the previously seen lower levels
-                lower_levels = [l for l in headings if l > el.name]
-                for l in lower_levels:
-                    del headings[l]
+                lower_levels = [lv for lv in headings if lv > el.name]
+                for lv in lower_levels:
+                    del headings[lv]
                 headings[el.name] = el.get_text().strip()
 
         def emit() -> Iterator[DocumentSection]:
@@ -260,7 +311,7 @@ class DocumentSplitter(ComponentIterator):
                 yield DocumentSection(text=full_text, metadata=md)
                 accumulated_text = []
 
-        def process_element(el: Union[bs4.element.Tag, bs4.NavigableString]) -> Iterator[DocumentSection]:
+        def process_element(el: Tag | NavigableString) -> Iterator[DocumentSection]:
             # process the element and emit sections as necessary
             nonlocal accumulated_text, headings, sourceline, emit_on_heading, emit_on_paragraph
 
@@ -297,7 +348,7 @@ class DocumentSplitter(ComponentIterator):
         # current state
         accumulated_text: list[str] = []  # currently accumulated text
         # accumulate pieces then join before emit to avoid quadratic complexity of string concatenation
-        headings: dict[str, str] = {}   # current state of observed headings (level -> text)
+        headings: dict[str, str] = {}  # current state of observed headings (level -> text)
 
         def update_headings(heading: dict) -> None:
             # update current state
@@ -307,9 +358,9 @@ class DocumentSplitter(ComponentIterator):
             level = f'h{lint}'
             text = heading['children'][0]['raw'].strip()
             # remove the previously seen lower levels
-            lower_levels = [l for l in headings.keys() if l > level]
-            for l in lower_levels:
-                del headings[l]
+            lower_levels = [lv for lv in headings if lv > level]
+            for lv in lower_levels:
+                del headings[lv]
             headings[level] = text
 
         def emit() -> Iterator[DocumentSection]:
@@ -348,47 +399,48 @@ class DocumentSplitter(ComponentIterator):
         yield from emit()
 
     def _pdf_sections(self) -> Iterator[DocumentSection]:
-        """Create DocumentSections reflecting the pdf-specific separators"""
-        import fitz  # type: ignore[import-untyped]
-        doc: fitz.Document = self._doc_handle.pdf_doc
-        assert doc is not None
+        if Separator.PARAGRAPH in self._separators:
+            raise Error(
+                'Paragraph splitting is not currently supported for PDF documents. Please contact'
+                ' us at https://github.com/pixeltable/pixeltable/issues if you need this feature.'
+            )
 
-        emit_on_paragraph = Separator.PARAGRAPH in self._separators or Separator.SENTENCE in self._separators
-        emit_on_page = Separator.PAGE in self._separators or emit_on_paragraph
+        doc: PdfDocument = self._doc_handle.pdf_doc
+        assert isinstance(doc, PdfDocument)
 
-        accumulated_text = []  # invariant: all elements are ftfy clean and non-empty
+        emit_on_page = Separator.PAGE in self._separators
+        accumulated_text: list[str] = []
 
-        def _add_cleaned_text(raw_text: str) -> None:
-            fixed = ftfy.fix_text(raw_text)
+        def _add_cleaned(raw: str) -> None:
+            fixed = ftfy.fix_text(raw)
             if fixed:
                 accumulated_text.append(fixed)
 
         def _emit_text() -> str:
-            full_text = ''.join(accumulated_text)
+            txt = ''.join(accumulated_text)
             accumulated_text.clear()
-            return full_text
-
-        for page_number, page in enumerate(doc.pages()):
-            for block in page.get_text('blocks'):
-                # there is no concept of paragraph in pdf, block is the closest thing
-                # we can get (eg a paragraph in text may cut across pages)
-                # see pymupdf docs https://pymupdf.readthedocs.io/en/latest/app1.html
-                # other libraries like pdfminer also lack an explicit paragraph concept
-                x1, y1, x2, y2, text, _, _ = block
-                _add_cleaned_text(text)
-                if accumulated_text and emit_on_paragraph:
-                    bbox = {'x1': x1, 'y1': y1, 'x2': x2, 'y2': y2}
-                    metadata = DocumentSectionMetadata(page=page_number, bounding_box=bbox)
-                    yield DocumentSection(text=_emit_text(), metadata=metadata)
-
-            if accumulated_text and emit_on_page and not emit_on_paragraph:
-                yield DocumentSection(text=_emit_text(),
-                                      metadata=DocumentSectionMetadata(page=page_number))
-                accumulated_text = []
+            return txt
+
+        for page_idx, page in enumerate(doc):
+            img = page.render().to_pil() if Element.IMAGE in self._elements else None
+            text = page.get_textpage().get_text_bounded()
+            _add_cleaned(text)
+            if accumulated_text and emit_on_page:
+                md = DocumentSectionMetadata(page=page_idx)
+                yield DocumentSection(text=_emit_text(), image=img, metadata=md)
 
         if accumulated_text and not emit_on_page:
             yield DocumentSection(text=_emit_text(), metadata=DocumentSectionMetadata())
 
+    def _txt_sections(self) -> Iterator[DocumentSection]:
+        """Create DocumentSections for text files.
+
+        Currently, it returns the entire text as a single section.
+        TODO: Add support for paragraphs.
+        """
+        assert self._doc_handle.txt_doc is not None
+        yield DocumentSection(text=ftfy.fix_text(self._doc_handle.txt_doc), metadata=DocumentSectionMetadata())
+
     def _sentence_sections(self, input_sections: Iterable[DocumentSection]) -> Iterator[DocumentSection]:
         """Split the input sections into sentences"""
         for section in input_sections:
@@ -399,6 +451,7 @@ class DocumentSplitter(ComponentIterator):
 
     def _token_chunks(self, input: Iterable[DocumentSection]) -> Iterator[DocumentSection]:
         import tiktoken
+
         if self._tiktoken_target_model is not None:
             encoding = tiktoken.encoding_for_model(self._tiktoken_target_model)
         else:
@@ -442,5 +495,9 @@ class DocumentSplitter(ComponentIterator):
     def close(self) -> None:
         pass
 
-    def set_pos(self, pos: int) -> None:
-        pass
+    @classmethod
+    @deprecated(
+        'create() is deprecated; use `pixeltable.functions.document.document_splitter` instead', version='0.5.6'
+    )
+    def create(cls, **kwargs: Any) -> tuple[type[ComponentIterator], dict[str, Any]]:
+        return super()._create(**kwargs)

pixeltable/iterators/image.py

@@ -1,6 +1,7 @@
 from typing import Any, Sequence
 
 import PIL.Image
+from deprecated import deprecated
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
@@ -8,18 +9,6 @@ from pixeltable.iterators.base import ComponentIterator
 
 
 class TileIterator(ComponentIterator):
-    """
-    Iterator over tiles of an image. Each image will be divided into tiles of size `tile_size`, and the tiles will be
-    iterated over in row-major order (left-to-right, then top-to-bottom). An optional `overlap` parameter may be
-    specified. If the tiles do not exactly cover the image, then the rightmost and bottommost tiles will be padded with
-    blackspace, so that the output images all have the exact size `tile_size`.
-
-    Args:
-        image: Image to split into tiles.
-        tile_size: Size of each tile, as a pair of integers `[width, height]`.
-        overlap: Amount of overlap between adjacent tiles, as a pair of integers `[width, height]`.
-    """
-
     __image: PIL.Image.Image
     __tile_size: Sequence[int]
     __overlap: Sequence[int]
@@ -30,15 +19,8 @@ class TileIterator(ComponentIterator):
     __i: int
     __j: int
 
-    def __init__(
-        self,
-        image: PIL.Image.Image,
-        *,
-        tile_size: tuple[int, int],
-        overlap: tuple[int, int] = (0, 0),
-    ):
-        if overlap[0] >= tile_size[0] or overlap[1] >= tile_size[1]:
-            raise excs.Error(f"overlap dimensions {overlap} are not strictly smaller than tile size {tile_size}")
+    def __init__(self, image: PIL.Image.Image, *, tile_size: tuple[int, int], overlap: tuple[int, int] = (0, 0)):
+        assert overlap[0] < tile_size[0] and overlap[1] < tile_size[1]
 
         self.__image = image
         self.__image.load()
@@ -64,11 +46,7 @@ class TileIterator(ComponentIterator):
         x2 = x1 + self.__tile_size[0]
         y2 = y1 + self.__tile_size[1]
         tile = self.__image.crop((x1, y1, x2, y2))
-        result = {
-            'tile': tile,
-            'tile_coord': [self.__i, self.__j],
-            'tile_box': [x1, y1, x2, y2]
-        }
+        result = {'tile': tile, 'tile_coord': [self.__i, self.__j], 'tile_box': [x1, y1, x2, y2]}
 
         self.__i += 1
         if self.__i >= self.__xlen:
@@ -79,22 +57,23 @@ class TileIterator(ComponentIterator):
     def close(self) -> None:
         pass
 
-    def set_pos(self, pos: int) -> None:
+    def set_pos(self, pos: int, **kwargs: Any) -> None:
         self.__j = pos // self.__xlen
         self.__i = pos % self.__xlen
 
     @classmethod
     def input_schema(cls, *args: Any, **kwargs: Any) -> dict[str, ts.ColumnType]:
-        return {
-            'image': ts.ImageType(),
-            'tile_size': ts.JsonType(),
-            'overlap': ts.JsonType(),
-        }
+        return {'image': ts.ImageType(), 'tile_size': ts.JsonType(), 'overlap': ts.JsonType()}
+
+    @classmethod
+    def output_schema(cls, *args: Any, **kwargs: Any) -> tuple[dict[str, ts.ColumnType], list[str]]:
+        tile_size = kwargs.get('tile_size')
+        overlap = kwargs.get('overlap', (0, 0))
+        if overlap[0] >= tile_size[0] or overlap[1] >= tile_size[1]:
+            raise excs.Error(f'overlap dimensions {overlap} are not strictly smaller than tile size {tile_size}')
+        return {'tile': ts.ImageType(), 'tile_coord': ts.JsonType(), 'tile_box': ts.JsonType()}, ['tile']
 
     @classmethod
-    def output_schema(cls,  *args: Any, **kwargs: Any) -> tuple[dict[str, ts.ColumnType], list[str]]:
-        return {
-            'tile': ts.ImageType(),
-            'tile_coord': ts.JsonType(),
-            'tile_box': ts.JsonType(),
-        }, ['tile']
+    @deprecated('create() is deprecated; use `pixeltable.functions.image.tile_iterator` instead', version='0.5.6')
+    def create(cls, **kwargs: Any) -> tuple[type[ComponentIterator], dict[str, Any]]:
+        return super()._create(**kwargs)

pixeltable/iterators/string.py

@@ -1,13 +1,17 @@
-from typing import Iterator, Any
+from typing import Any, Iterator
 
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
+from deprecated import deprecated
+
+from pixeltable import exceptions as excs, type_system as ts
 from pixeltable.env import Env
 from pixeltable.iterators.base import ComponentIterator
 
 
 class StringSplitter(ComponentIterator):
-    # TODO(aaron-siegel): Merge this with `DocumentSplitter` in order to provide additional capabilities.
+    _text: str
+    doc: Any  # spacy doc
+    iter: Iterator[dict[str, Any]]
+
     def __init__(self, text: str, *, separators: str):
         if separators != 'sentence':
             raise excs.Error('Only `sentence` separators are currently supported.')
@@ -25,16 +29,15 @@ class StringSplitter(ComponentIterator):
     def close(self) -> None:
         pass
 
-    def set_pos(self, pos: int) -> None:
-        pass
-
     @classmethod
     def input_schema(cls, *args: Any, **kwargs: Any) -> dict[str, ts.ColumnType]:
-        return {
-            'text': ts.StringType(),
-            'separators': ts.StringType(),
-        }
+        return {'text': ts.StringType(), 'separators': ts.StringType()}
 
     @classmethod
-    def output_schema(cls,  *args: Any, **kwargs: Any) -> tuple[dict[str, ts.ColumnType], list[str]]:
+    def output_schema(cls, *args: Any, **kwargs: Any) -> tuple[dict[str, ts.ColumnType], list[str]]:
         return {'text': ts.StringType()}, []
+
+    @classmethod
+    @deprecated('create() is deprecated; use `pixeltable.functions.string.string_splitter` instead', version='0.5.6')
+    def create(cls, **kwargs: Any) -> tuple[type[ComponentIterator], dict[str, Any]]:
+        return super()._create(**kwargs)