mseep-txtai 9.1.1__py3-none-any.whl

txtai/api/routers/__init__.py

@@ -0,0 +1,25 @@
+"""
+Router imports
+"""
+
+from . import agent
+from . import caption
+from . import embeddings
+from . import entity
+from . import extractor
+from . import labels
+from . import llm
+from . import objects
+from . import openai
+from . import rag
+from . import reranker
+from . import segmentation
+from . import similarity
+from . import summary
+from . import tabular
+from . import textractor
+from . import texttospeech
+from . import transcription
+from . import translation
+from . import workflow
+from . import upload

txtai/api/routers/agent.py

@@ -0,0 +1,38 @@
+"""
+Defines API paths for agent endpoints.
+"""
+
+from typing import Optional
+
+from fastapi import APIRouter, Body
+from fastapi.responses import StreamingResponse
+
+from .. import application
+from ..route import EncodingAPIRoute
+
+router = APIRouter(route_class=EncodingAPIRoute)
+
+
+@router.post("/agent")
+def agent(name: str = Body(...), text: str = Body(...), maxlength: Optional[int] = Body(default=None), stream: Optional[bool] = Body(default=None)):
+    """
+    Executes a named agent for input text.
+
+    Args:
+        name: agent name
+        text: instructions to run
+        maxlength: maximum sequence length
+        stream: stream response if True, defaults to False
+
+    Returns:
+        response text
+    """
+
+    # Build keyword arguments
+    kwargs = {key: value for key, value in [("stream", stream), ("maxlength", maxlength)] if value}
+
+    # Run agent
+    result = application.get().agent(name, text, **kwargs)
+
+    # Handle both standard and streaming responses
+    return StreamingResponse(result) if stream else result

txtai/api/routers/caption.py

@@ -0,0 +1,42 @@
+"""
+Defines API paths for caption endpoints.
+"""
+
+from typing import List
+
+from fastapi import APIRouter, Body
+
+from .. import application
+from ..route import EncodingAPIRoute
+
+router = APIRouter(route_class=EncodingAPIRoute)
+
+
+@router.get("/caption")
+def caption(file: str):
+    """
+    Builds captions for images.
+
+    Args:
+        file: file to process
+
+    Returns:
+        list of captions
+    """
+
+    return application.get().pipeline("caption", (file,))
+
+
+@router.post("/batchcaption")
+def batchcaption(files: List[str] = Body(...)):
+    """
+    Builds captions for images.
+
+    Args:
+        files: list of files to process
+
+    Returns:
+        list of captions
+    """
+
+    return application.get().pipeline("caption", (files,))

txtai/api/routers/embeddings.py

@@ -0,0 +1,280 @@
+"""
+Defines API paths for embeddings endpoints.
+"""
+
+from io import BytesIO
+from typing import List, Optional
+
+import PIL
+
+from fastapi import APIRouter, Body, File, Form, HTTPException, Request, UploadFile
+from fastapi.encoders import jsonable_encoder
+
+from .. import application
+from ..responses import ResponseFactory
+from ..route import EncodingAPIRoute
+
+from ...app import ReadOnlyError
+from ...graph import Graph
+
+router = APIRouter(route_class=EncodingAPIRoute)
+
+
+@router.get("/search")
+def search(query: str, request: Request):
+    """
+    Finds documents most similar to the input query. This method will run either an index search
+    or an index + database search depending on if a database is available.
+
+    Args:
+        query: input query
+        request: FastAPI request
+
+    Returns:
+        list of {id: value, score: value} for index search, list of dict for an index + database search
+    """
+
+    # Execute search
+    results = application.get().search(query, request=request)
+
+    # Encode using standard FastAPI encoder but skip certain classes
+    results = jsonable_encoder(
+        results, custom_encoder={bytes: lambda x: x, BytesIO: lambda x: x, PIL.Image.Image: lambda x: x, Graph: lambda x: x.savedict()}
+    )
+
+    # Return raw response to prevent duplicate encoding
+    response = ResponseFactory.create(request)
+    return response(results)
+
+
+# pylint: disable=W0621
+@router.post("/batchsearch")
+def batchsearch(
+    request: Request,
+    queries: List[str] = Body(...),
+    limit: int = Body(default=None),
+    weights: float = Body(default=None),
+    index: str = Body(default=None),
+    parameters: List[dict] = Body(default=None),
+    graph: bool = Body(default=False),
+):
+    """
+    Finds documents most similar to the input queries. This method will run either an index search
+    or an index + database search depending on if a database is available.
+
+    Args:
+        queries: input queries
+        limit: maximum results
+        weights: hybrid score weights, if applicable
+        index: index name, if applicable
+        parameters: list of dicts of named parameters to bind to placeholders
+        graph: return graph results if True
+
+    Returns:
+        list of {id: value, score: value} per query for index search, list of dict per query for an index + database search
+    """
+
+    # Execute search
+    results = application.get().batchsearch(queries, limit, weights, index, parameters, graph)
+
+    # Encode using standard FastAPI encoder but skip certain classes
+    results = jsonable_encoder(
+        results, custom_encoder={bytes: lambda x: x, BytesIO: lambda x: x, PIL.Image.Image: lambda x: x, Graph: lambda x: x.savedict()}
+    )
+
+    # Return raw response to prevent duplicate encoding
+    response = ResponseFactory.create(request)
+    return response(results)
+
+
+@router.post("/add")
+def add(documents: List[dict] = Body(...)):
+    """
+    Adds a batch of documents for indexing.
+
+    Args:
+        documents: list of {id: value, text: value, tags: value}
+    """
+
+    try:
+        application.get().add(documents)
+    except ReadOnlyError as e:
+        raise HTTPException(status_code=403, detail=e.args[0]) from e
+
+
+@router.post("/addobject")
+def addobject(data: List[bytes] = File(), uid: List[str] = Form(default=None), field: str = Form(default=None)):
+    """
+    Adds a batch of binary documents for indexing.
+
+    Args:
+        data: list of binary objects
+        uid: list of corresponding ids
+        field: optional object field name
+    """
+
+    if uid and len(data) != len(uid):
+        raise HTTPException(status_code=422, detail="Length of data and document lists must match")
+
+    try:
+        # Add objects
+        application.get().addobject(data, uid, field)
+    except ReadOnlyError as e:
+        raise HTTPException(status_code=403, detail=e.args[0]) from e
+
+
+@router.post("/addimage")
+def addimage(data: List[UploadFile] = File(), uid: List[str] = Form(), field: str = Form(default=None)):
+    """
+    Adds a batch of images for indexing.
+
+    Args:
+        data: list of images
+        uid: list of corresponding ids
+        field: optional object field name
+    """
+
+    if uid and len(data) != len(uid):
+        raise HTTPException(status_code=422, detail="Length of data and uid lists must match")
+
+    try:
+        # Add images
+        application.get().addobject([PIL.Image.open(content.file) for content in data], uid, field)
+    except ReadOnlyError as e:
+        raise HTTPException(status_code=403, detail=e.args[0]) from e
+
+
+@router.get("/index")
+def index():
+    """
+    Builds an embeddings index for previously batched documents.
+    """
+
+    try:
+        application.get().index()
+    except ReadOnlyError as e:
+        raise HTTPException(status_code=403, detail=e.args[0]) from e
+
+
+@router.get("/upsert")
+def upsert():
+    """
+    Runs an embeddings upsert operation for previously batched documents.
+    """
+
+    try:
+        application.get().upsert()
+    except ReadOnlyError as e:
+        raise HTTPException(status_code=403, detail=e.args[0]) from e
+
+
+@router.post("/delete")
+def delete(ids: List = Body(...)):
+    """
+    Deletes from an embeddings index. Returns list of ids deleted.
+
+    Args:
+        ids: list of ids to delete
+
+    Returns:
+        ids deleted
+    """
+
+    try:
+        return application.get().delete(ids)
+    except ReadOnlyError as e:
+        raise HTTPException(status_code=403, detail=e.args[0]) from e
+
+
+@router.post("/reindex")
+def reindex(config: dict = Body(...), function: str = Body(default=None)):
+    """
+    Recreates this embeddings index using config. This method only works if document content storage is enabled.
+
+    Args:
+        config: new config
+        function: optional function to prepare content for indexing
+    """
+
+    try:
+        application.get().reindex(config, function)
+    except ReadOnlyError as e:
+        raise HTTPException(status_code=403, detail=e.args[0]) from e
+
+
+@router.get("/count")
+def count():
+    """
+    Total number of elements in this embeddings index.
+
+    Returns:
+        number of elements in embeddings index
+    """
+
+    return application.get().count()
+
+
+@router.post("/explain")
+def explain(query: str = Body(...), texts: List[str] = Body(default=None), limit: int = Body(default=None)):
+    """
+    Explains the importance of each input token in text for a query.
+
+    Args:
+        query: query text
+        texts: list of text
+
+    Returns:
+        list of dict where a higher scores represents higher importance relative to the query
+    """
+
+    return application.get().explain(query, texts, limit)
+
+
+@router.post("/batchexplain")
+def batchexplain(queries: List[str] = Body(...), texts: List[str] = Body(default=None), limit: int = Body(default=None)):
+    """
+    Explains the importance of each input token in text for a query.
+
+    Args:
+        query: query text
+        texts: list of text
+
+    Returns:
+        list of dict where a higher scores represents higher importance relative to the query
+    """
+
+    return application.get().batchexplain(queries, texts, limit)
+
+
+@router.get("/transform")
+def transform(text: str, category: Optional[str] = None, index: Optional[str] = None):
+    """
+    Transforms text into an embeddings array.
+
+    Args:
+        text: input text
+        category: category for instruction-based embeddings
+        index: index name, if applicable
+
+    Returns:
+        embeddings array
+    """
+
+    return application.get().transform(text, category, index)
+
+
+@router.post("/batchtransform")
+def batchtransform(texts: List[str] = Body(...), category: Optional[str] = None, index: Optional[str] = None):
+    """
+    Transforms list of text into embeddings arrays.
+
+    Args:
+        texts: list of text
+        category: category for instruction-based embeddings
+        index: index name, if applicable
+
+    Returns:
+        embeddings arrays
+    """
+
+    return application.get().batchtransform(texts, category, index)

txtai/api/routers/entity.py

@@ -0,0 +1,42 @@
+"""
+Defines API paths for entity endpoints.
+"""
+
+from typing import List
+
+from fastapi import APIRouter, Body
+
+from .. import application
+from ..route import EncodingAPIRoute
+
+router = APIRouter(route_class=EncodingAPIRoute)
+
+
+@router.get("/entity")
+def entity(text: str):
+    """
+    Applies a token classifier to text.
+
+    Args:
+        text: input text
+
+    Returns:
+        list of (entity, entity type, score) per text element
+    """
+
+    return application.get().pipeline("entity", (text,))
+
+
+@router.post("/batchentity")
+def batchentity(texts: List[str] = Body(...)):
+    """
+    Applies a token classifier to text.
+
+    Args:
+        texts: list of text
+
+    Returns:
+        list of (entity, entity type, score) per text element
+    """
+
+    return application.get().pipeline("entity", (texts,))

txtai/api/routers/extractor.py

@@ -0,0 +1,28 @@
+"""
+Defines API paths for extractor endpoints.
+"""
+
+from typing import List, Optional
+
+from fastapi import APIRouter, Body
+
+from .. import application
+from ..route import EncodingAPIRoute
+
+router = APIRouter(route_class=EncodingAPIRoute)
+
+
+@router.post("/extract")
+def extract(queue: List[dict] = Body(...), texts: Optional[List[str]] = Body(default=None)):
+    """
+    Extracts answers to input questions.
+
+    Args:
+        queue: list of {name: value, query: value, question: value, snippet: value}
+        texts: optional list of text
+
+    Returns:
+        list of {name: value, answer: value}
+    """
+
+    return application.get().extract(queue, texts)

txtai/api/routers/labels.py

@@ -0,0 +1,47 @@
+"""
+Defines API paths for labels endpoints.
+"""
+
+from typing import List
+
+from fastapi import APIRouter, Body
+
+from .. import application
+from ..route import EncodingAPIRoute
+
+router = APIRouter(route_class=EncodingAPIRoute)
+
+
+@router.post("/label")
+def label(text: str = Body(...), labels: List[str] = Body(...)):
+    """
+    Applies a zero shot classifier to text using a list of labels. Returns a list of
+    {id: value, score: value} sorted by highest score, where id is the index in labels.
+
+    Args:
+        text: input text
+        labels: list of labels
+
+    Returns:
+        list of {id: value, score: value} per text element
+    """
+
+    return application.get().label(text, labels)
+
+
+@router.post("/batchlabel")
+def batchlabel(texts: List[str] = Body(...), labels: List[str] = Body(...)):
+    """
+    Applies a zero shot classifier to list of text using a list of labels. Returns a list of
+    {id: value, score: value} sorted by highest score, where id is the index in labels per
+    text element.
+
+    Args:
+        texts: list of text
+        labels: list of labels
+
+    Returns:
+        list of {id: value score: value} per text element
+    """
+
+    return application.get().label(texts, labels)

txtai/api/routers/llm.py

@@ -0,0 +1,61 @@
+"""
+Defines API paths for llm endpoints.
+"""
+
+from typing import List, Optional
+
+from fastapi import APIRouter, Body
+from fastapi.responses import StreamingResponse
+
+from .. import application
+from ..route import EncodingAPIRoute
+
+router = APIRouter(route_class=EncodingAPIRoute)
+
+
+@router.get("/llm")
+def llm(text: str, maxlength: Optional[int] = None, stream: Optional[bool] = False):
+    """
+    Runs a LLM pipeline for the input text.
+
+    Args:
+        text: input text
+        maxlength: optional response max length
+        stream: streams response if True
+
+    Returns:
+        response text
+    """
+
+    # Build keyword arguments
+    kwargs = {key: value for key, value in [("stream", stream), ("maxlength", maxlength)] if value}
+
+    # Run pipeline
+    result = application.get().pipeline("llm", text, **kwargs)
+
+    # Handle both standard and streaming responses
+    return StreamingResponse(result) if stream else result
+
+
+@router.post("/batchllm")
+def batchllm(texts: List[str] = Body(...), maxlength: Optional[int] = Body(default=None), stream: Optional[bool] = Body(default=False)):
+    """
+    Runs a LLM pipeline for the input texts.
+
+    Args:
+        texts: input texts
+        maxlength: optional response max length
+        stream: streams response if True
+
+    Returns:
+        response texts
+    """
+
+    # Build keyword arguments
+    kwargs = {key: value for key, value in [("stream", stream), ("maxlength", maxlength)] if value}
+
+    # Run pipeline
+    result = application.get().pipeline("llm", texts, **kwargs)
+
+    # Handle both standard and streaming responses
+    return StreamingResponse(result) if stream else result

txtai/api/routers/objects.py

@@ -0,0 +1,42 @@
+"""
+Defines API paths for objects endpoints.
+"""
+
+from typing import List
+
+from fastapi import APIRouter, Body
+
+from .. import application
+from ..route import EncodingAPIRoute
+
+router = APIRouter(route_class=EncodingAPIRoute)
+
+
+@router.get("/objects")
+def objects(file: str):
+    """
+    Applies object detection/image classification models to images.
+
+    Args:
+        file: file to process
+
+    Returns:
+        list of (label, score) elements
+    """
+
+    return application.get().pipeline("objects", (file,))
+
+
+@router.post("/batchobjects")
+def batchobjects(files: List[str] = Body(...)):
+    """
+    Applies object detection/image classification models to images.
+
+    Args:
+        files: list of files to process
+
+    Returns:
+        list of (label, score) elements
+    """
+
+    return application.get().pipeline("objects", (files,))