UTCA

https://utca.knowledgator.com
Admin
UTCA is a versatile framework for integrating models (including Hugging Face) into complex programs,...
Tokens:70,727
Snippets:431
Trust Score:6.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install utca Python Package

Source: https://utca.knowledgator.com/quickstart

Installs or upgrades the utca Python library using pip, ensuring the latest version is available for use in the project.

```bash
pip install -U utca
```

--------------------------------

### Example Pipeline Output with Extracted Entities

Source: https://utca.knowledgator.com/quickstart

This JSON snippet illustrates the expected output format after running the pipeline. It includes the original input text and a list of 'entities' detected within the text, each with its start and end character positions, the extracted span, a confidence score, and the identified entity type (e.g., 'scientist', 'university', 'city').

```json
{
    "text": """Dr. Paul Hammond, a renowned neurologist at Johns Hopkins University, has recently published a paper in the prestigious journal \"Nature Neuroscience\".\nHis research focuses on a rare genetic mutation, found in less than 0.01% of the population, that appears to prevent the development of Alzheimer's disease. Collaborating with researchers at the University of California, San Francisco, the team is now working to understand the mechanism by which this mutation confers its protective effect.\nFunded by the National Institutes of Health, their research could potentially open new avenues for Alzheimer's treatment.""",
    "entities": [
        {
            "start": 4,
            "end": 16,
            "span": "Paul Hammond",
            "score": 0.5637074708938599,
            "entity": "scientist"
        },
        {
            "start": 44,
            "end": 68,
            "span": "Johns Hopkins University",
            "score": 0.8921091556549072,
            "entity": "university"
        },
        {
            "start": 347,
            "end": 371,
            "span": "University of California",
            "score": 0.7202138900756836,
            "entity": "university"
        },
        {
            "start": 373,
            "end": 386,
            "span": "San Francisco",
            "score": 0.7660449743270874,
            "entity": "city"
        }
    ]
}
```

--------------------------------

### Install UTCA framework

Source: https://utca.knowledgator.com/index

This command installs the UTCA framework using pip, the Python package installer. The -U flag ensures that the package is upgraded to the latest version if already installed.

```Python
pip install -U utca
```

--------------------------------

### Initialize Configured TokenSearcherNER Task

Source: https://utca.knowledgator.com/quickstart

Initializes the TokenSearcherNER task, linking it to the previously configured predictor. It also sets up a TokenSearcherNERPostprocessor with a specified threshold of 0.5 for post-processing the NER results.

```python
ner_task = TokenSearcherNER(
    predictor=predictor,
    postprocess=TokenSearcherNERPostprocessor(
        threshold=0.5
    )
)
```

--------------------------------

### Import Core utca Modules and Components

Source: https://utca.knowledgator.com/quickstart

Imports necessary classes from the utca.core, utca.implementation.predictors, and utca.implementation.tasks modules. These include AddData, RenameAttribute, Flush, TokenSearcherPredictor, TokenSearcherPredictorConfig, TokenSearcherNER, and TokenSearcherNERPostprocessor for building the pipeline.

```python
from utca.core import (
    AddData,
    RenameAttribute,
    Flush
)
from utca.implementation.predictors import (
    TokenSearcherPredictor, TokenSearcherPredictorConfig
)
from utca.implementation.tasks import (
    TokenSearcherNER,
    TokenSearcherNERPostprocessor,
)
```

--------------------------------

### Initialize TokenSearcherPredictor

Source: https://utca.knowledgator.com/quickstart

Initializes the TokenSearcherPredictor with a TokenSearcherPredictorConfig specifying the device to use for predictions, in this case, 'cpu'. This predictor will be used by the NER task.

```python
predictor = TokenSearcherPredictor(
    TokenSearcherPredictorConfig(
        device="cpu"
    )
)
```

--------------------------------

### Define ExecutionSchema Pipeline

Source: https://utca.knowledgator.com/quickstart

Defines a data processing pipeline using ExecutionSchema components. The pipeline adds initial labels, executes the NER task, flushes the labels, and renames the output attribute to 'entities'.

```python
pipeline = (
    AddData({"labels": ["scientist", "university", "city"]})
    | ner_task
    | Flush(keys=["labels"])
    | RenameAttribute("output", "entities")
)
```

--------------------------------

### Run Pipeline with Text Input

Source: https://utca.knowledgator.com/quickstart

This code snippet demonstrates how to execute a pre-configured pipeline by calling its `run` method. It takes a dictionary as input, where the 'text' key contains the natural language text to be processed by the pipeline. The pipeline is expected to process this text and extract relevant information.

```python
res = pipeline.run({
    "text": """Dr. Paul Hammond, a renowned neurologist at Johns Hopkins University, has recently published a paper in the prestigious journal \"Nature Neuroscience\".\nHis research focuses on a rare genetic mutation, found in less than 0.01% of the population, that appears to prevent the development of Alzheimer's disease. Collaborating with researchers at the University of California, San Francisco, the team is now working to understand the mechanism by which this mutation confers its protective effect.\nFunded by the National Institutes of Health, their research could potentially open new avenues for Alzheimer's treatment."""
})
```

--------------------------------

### Initialize Default TokenSearcherNER Task

Source: https://utca.knowledgator.com/quickstart

Initializes the TokenSearcherNER task without explicit configuration. This creates a default task instance, using default values for its predictor and post-processing parameters, including the threshold.

```python
ner_task = TokenSearcherNER()
```

--------------------------------

### Generic Execute Method Input/Output Specification

Source: https://utca.knowledgator.com/tasks/glinerqanda

Describes the API for a generic 'execute' method, detailing its expected input data structure (text, question) and the output format (model inputs, labels, chunk start positions, and threshold).

```APIDOC
execute:
  Arguments:
    input_data (Dict[str, Any]):
      Expected keys:
        "text" (str): Text to process;
        "question" (str): Question to answer;
  Returns:
    Dict[str, Any]:
      Expected keys:
        "texts" (List[str]): Model inputs;
        "labels" (List[str]): Labels model inputs;
        "chunks_starts" (List[int]): Chunks start positions. Used by postprocessor;
        "threshold" (float): Minimal score for an entity to put into output;
```

--------------------------------

### GLiNERQandAPostprocessor Class and Execute Method API

Source: https://utca.knowledgator.com/tasks/glinerqanda

Documents the 'GLiNERQandAPostprocessor' class, a subclass of 'Action', responsible for formatting output. It details the 'execute' method's specific input (model output, chunk starts, text, question) and output (processed text, question, and answers as Entity objects).

```APIDOC
GLiNERQandAPostprocessor:
  Description: Format output. Subclass of Action. Type of Action[Dict[str, Any], Dict[str, Any]].
  Methods:
    execute:
      Arguments:
        input_data (Dict[str, Any]):
          Expected keys:
            "output" (List[List[Dict[str, Any]]]): Model output;
            "chunks_starts" (List[int]): Chunks starts;
            "text" (str): Processed text;
            "question" (str): Answered question.
      Returns:
        Dict[str, Any]:
          Expected keys:
            "text" (str): Processed text;
            "question" (str): Answered question.
            "output" (List[Entity]): Answers;
```

--------------------------------

### MemoryManager Class API

Source: https://utca.knowledgator.com/core/memory-management

Documents the MemoryManager class, responsible for comprehensive memory management operations. It provides methods for initialization, getting, setting, deleting, and flushing data from memory.

```APIDOC
class MemoryManager:
  Manage memory

  __init__(directory: Optional[str] = None, initial_data: Optional[Dict[str, Any]] = None):
    directory: Path to directory. Defaults to None.
    initial_data: Data for initialization of memory. Defaults to None.

  get(register: Transformable, identifiers: List[Union[str, Tuple[str, str]]], default: Dict[str, Any], delete: bool = False) -> Transformable:
    Get data from memory
    register: Current data.
    identifiers: Key/keys that will be used to access data in memory and for setting to register.
    default: A map of values to be returned for each provided identifier if the identifier(s) are not found. If an identifier is not found and no default value is provided for it, an exception will be raised. Defaults to None.
    delete: If equals to True, deletes accessed memory identifiers. Defaults to False.

  set(register: Transformable, get_key: str, set_key: str):
    Set data to memory
    register: Current data.
    get_key: Source of data.
    set_key: Destination in memory.

  delete(identifier: str):
    Delete specified identifier from memory
    identifier: Identifier to delete.

  flush():
    Clean memory
```

--------------------------------

### ChromaDBGetOrCreateCollection API

Source: https://utca.knowledgator.com/datasources/db/chroma

API for getting or creating a ChromaDB collection. This class allows initialization with client, embedding function, metadata, and name, and provides an execute method to retrieve or create a collection by name.

```APIDOC
class ChromaDBGetOrCreateCollection(Action[str, Collection]):
  __init__(client: ClientAPI, embedding_function: Optional[EmbeddingFunction[Embeddable]] = None, metadata: Optional[Dict[str, Any]] = None, name: Optional[str] = None)
    client: ChromaDB client to use.
    embedding_function: Embedding function to use. If equals to None, default will be used. Defaults to None.
    metadata: Collection metadata. Defaults to None.
    name: Name for identification. If equals to None, class name will be used. Defaults to None.

  execute(input_data: str) -> Collection
    input_data: The name of the collection to get or create.
    Returns: Retrieved collection.
```

--------------------------------

### Define Entity Class

Source: https://utca.knowledgator.com/tasks/objects

Defines the base Entity class, representing a span of text with a start, end, text value, and a probability score. This class is fundamental for text processing and information extraction.

```APIDOC
Entity:
  __init__(start: int, end: int, span: str, score: float):
    start: Start position of entity in text.
    end: End position of entity in text.
    span: Text value of entity.
    score: Probability score.
```

--------------------------------

### TransformersDocumentQandA __init__ Method API

Source: https://utca.knowledgator.com/tasks/transformersdocumentqanda

API documentation for the `__init__` method of the `TransformersDocumentQandA` class, detailing its parameters for initializing the task with custom predictors, pre/post-processing components, input/output schemas, and an optional name.

```APIDOC
TransformersDocumentQandA.__init__(
  predictor: Predictor[Any, Any] = None,
  preprocess: Optional[Component] = None,
  postprocess: Optional[Component] = None,
  input_class: Type[Input] = TransformersVisualQandAInput,
  output_class: Type[Output] = TransformersBasicOutput,
  name: Optional[str] = None
)
  predictor: Predictor that will be used in task. If equals to None, default predictor will be used.
  preprocess: Component executed before predictor.
  postprocess: Component executed after predictor.
  input_class: Class for input validation.
  output_class: Class for output validation.
  name: Name for identification. If equals to None, class name will be used.
```

--------------------------------

### BaseExecutor Class Initialization Method (__init__)

Source: https://utca.knowledgator.com/core/baseexecutor

Documents the __init__ method of the BaseExecutor class, detailing its parameters for wrapping components, handling input/output keys, and defining replacement strategy.

```APIDOC
BaseExecutor.__init__(
  component: ExecutorComponent,
  get_key: Optional[str] = None,
  set_key: Optional[str] = None,
  default_key: str = "output",
  replace: ReplacingScope = ReplacingScope.INPLACE
)
  component: Wrapped component.
  get_key: Which key value of input_data will be used. If value equal to None, root dict will be used. Defaults to None.
  set_key: Which key will be used to set result value. If set_key value equal to None:
    - if result of type Dict[str, Any], update root dict;
    - else, set result to default_key.
    Defaults to None.
  default_key: Default key used for results that is not of type Dict. Defaults to "output".
  replace: Replacing strategy for executor. Defaults to ReplacingScope.INPLACE.
```

--------------------------------

### TokenSearcherQandAPostprocessor Class Initialization Method

Source: https://utca.knowledgator.com/tasks/tokensearcherqanda

Initializes the TokenSearcherQandAPostprocessor. This component is responsible for formatting the output of the TokenSearcherQandA task.

```APIDOC
TokenSearcherQandAPostprocessor:
  __init__()
```

--------------------------------

### GLiNERPreprocessor Execute Method

Source: https://utca.knowledgator.com/tasks/gliner

Executes the pre-processing logic, transforming input text into a format suitable for the GLiNER predictor. It prepares model inputs, chunk start positions, and the threshold for subsequent processing.

```APIDOC
GLiNERPreprocessor.execute(
  input_data: Dict[str, Any]
) -> Dict[str, Any]
  input_data: Expected keys:
    \"text\" (str): Text to process;
  Returns: Expected keys:
    \"texts\" (List[str]): Model inputs;
    \"chunks_starts\" (List[int]): Chunks start positions. Used by postprocessor;
    \"threshold\" (List[int]): Minimial score to put entities into the output;
```

--------------------------------

### API Documentation for IndexCreate Class

Source: https://utca.knowledgator.com/datasources/index

Documentation for the `IndexCreate` class, a subclass of `Action`, responsible for creating new FAISS indexes. It details the constructor parameters and the `execute` method's behavior, including its input and expected output.

```APIDOC
Class: IndexCreate (Subclass of Action[Any, Dict[str, Any]])
  Description: Creates a FAISS index.

  Method: __init__
    Arguments:
      dataset_dimensions (int, optional): Dataset dimension. Defaults to 1024.
      name (Optional[str], optional): Name for identification. If None, class name is used. Defaults to None.

  Method: execute
    Arguments:
      input_data (Any): Ignored.
    Returns:
      Dict[str, Any]:
        "index" (faiss.IndexFlatL2): Created index.
```

--------------------------------

### WhisperSpeechToText Task __init__ Method

Source: https://utca.knowledgator.com/tasks/whisperspeechtotext

Documents the `__init__` method of the `WhisperSpeechToText` task, detailing its parameters for configuring the speech-to-text process. It covers the predictor, pre/post-processing components, input/output validation classes, and an optional name for identification.

```APIDOC
WhisperSpeechToText:
  __init__:
    Arguments:
      predictor (Predictor[Any, Any], optional): Predictor that will be used in task. If equals to None, default predictor will be used. Defaults to None.
      preprocess (Optional[Component], optional): Component executed before predictor. Defaults to None.
      postprocess (Optional[Component], optional): Component executed after predictor. Defaults to None.
      input_class (Type[Input], optional): Class for input validation. Defaults to WhisperInput.
      output_class (Type[Output], optional): Class for output validation. Defaults to WhisperOutput.
      name (Optional[str], optional): Name for identification. If equals to None, class name will be used. Defaults to None.
```

--------------------------------

### API Reference: MemoryGetInstruction Enum for Memory Retrieval Strategies

Source: https://utca.knowledgator.com/core/memory-management

Defines the MemoryGetInstruction enum, specifying strategies for retrieving data from memory. It includes GET for simple retrieval and POP for retrieving data while simultaneously deleting it from memory.

```APIDOC
class MemoryGetInstruction:
  GET
  POP
```

--------------------------------

### TokenSearcherQandAOutput Class Initialization Method

Source: https://utca.knowledgator.com/tasks/tokensearcherqanda

Initializes the output model for the TokenSearcherQandA task, structuring the returned text, question, and answers (entities).

```APIDOC
TokenSearcherQandAOutput:
  __init__(
    text: str,
    question: List[str],
    output: List[Entity]
  )
    text: Input text.
    question: Answered question.
    output: Answers.
```

--------------------------------

### GLiNERRelationExtraction __init__ Method API

Source: https://utca.knowledgator.com/tasks/glinerrelationextraction

Documents the constructor for the GLiNERRelationExtraction task. It allows customization of the predictor, preprocessor, postprocessor, input/output classes, and task name, with sensible defaults provided for each parameter to ensure flexible task setup.

```APIDOC
__init__(
  predictor: Predictor[Any, Any] = None,
  preprocess: Optional[Component] = None,
  postprocess: Optional[Component] = None,
  input_class: Type[Input] = RelationExtractionInput,
  output_class: Type[Output] = RelationExtractionOutput,
  name: Optional[str] = None
)
  predictor: Predictor that will be used in task. If equals to None, default predictor will be used. Defaults to None.
  preprocess: Component executed before predictor. If equals to None, default component will be used. Default component: GLiNERPreprocessor | GLiNERRelationExtractionPreprocessor
  postprocess: Component executed after predictor. If equals to None, default component will be used. Default component: GLiNERRelationExtractionPostprocessor
  input_class: Class for input validation. Defaults to RelationExtractionInput.
  output_class: Class for output validation. Defaults to RelationExtractionOutput.
  name: Name for identification. If equals to None, class name will be used. Defaults to None.
```

--------------------------------

### QdrantUpsert Constructor API Documentation

Source: https://utca.knowledgator.com/datasources/db/qdrant

Details the `__init__` method for the QdrantUpsert class. It specifies the required Qdrant client, an optional name for identification, and a default key for results not of type Dict.

```APIDOC
Method: QdrantUpsert.__init__
Arguments:
  client (QdrantClient): Qdrant client to use
  name (Optional[str], optional): Name for identification. If equals to None, class name will be used. Defaults to None.
  default_key (str, optional): Default key used for results that is not of type Dict. Defaults to "output".
```

--------------------------------

### Import necessary modules for Text-to-Speech pipeline

Source: https://utca.knowledgator.com/examples/text-to-speech

This snippet imports `pathlib` for resolving file paths and specific components from `utca.implementation.tasks` and `utca.implementation.datasources.audio` required for building a text-to-speech pipeline.

```python
import pathlib
PATH = pathlib.Path(__file__).parent.resolve()

from utca.implementation.tasks import (
    TransformersTextToSpeech
)
from utca.implementation.datasources.audio import (
    AudioWrite
)
```

--------------------------------

### Example Transformable State Structure

Source: https://utca.knowledgator.com/concepts/scopes

Illustrates the hierarchical organization of data within a Transformable object, showing global and inner scopes. The global scope encompasses the entire dictionary, while specific keys like 'prompt' and 'messages' represent inner scopes.

```Python
{
    "prompt": "Some prompt value",
    "messages": ["message1", "message2"],
    "images": [{
        "image": PIL.Image
    }],
    "search_results": {
        "indexes": [1, 2],
        "scores": [0.9, 0.7]
    }
}
```

--------------------------------

### TokenSearcherQandAInput Class Initialization Method

Source: https://utca.knowledgator.com/tasks/tokensearcherqanda

Initializes the input model for the TokenSearcherQandA task, defining the required text and question fields.

```APIDOC
TokenSearcherQandAInput:
  __init__(
    text: str,
    question: str
  )
    text: Input text.
    question: Question to answer.
```

--------------------------------

### API Reference: MemoryManager Class for Centralized Memory Operations

Source: https://utca.knowledgator.com/core/memory-management

Documents the MemoryManager class, which provides a centralized interface for memory operations. It includes methods for initialization, getting, setting, deleting, and flushing memory, though their specific arguments are not detailed in this documentation.

```APIDOC
class MemoryManager:
  __init__()
  get()
  set()
  delete()
  flush()
```

--------------------------------

### RePattern match Method for Beginning of String Match

Source: https://utca.knowledgator.com/conditions/repattern

Checks if the regular expression pattern matches zero or more characters at the beginning of `input_data`. It returns `True` if a match is found at the start, indicating the condition is fulfilled. Requires `Transformable` input data and an `Evaluator` context.

```APIDOC
RePattern.match(input_data: Transformable, evaluator: Evaluator) -> bool
  input_data: Data for processing
  evaluator: Evaluator in context of which Condition executed.
  Returns: Result of evaluation. Define that condition is fulfilled or not.
```

--------------------------------

### TransformersObjectDetectionInput Class Constructor API

Source: https://utca.knowledgator.com/tasks/transformersobjectdetection

API documentation for the `__init__` method of the `TransformersObjectDetectionInput` class, which defines the input schema for object detection tasks, specifically requiring an image.

```APIDOC
TransformersObjectDetectionInput:
  __init__(image: Image.Image)
    image: Image to process.
```

--------------------------------

### Action.__init__ Method

Source: https://utca.knowledgator.com/core/action

Initializes the Action class instance. Allows setting a custom name, a default key for non-dictionary results, and a replacing strategy for data processing.

```APIDOC
__init__(name: Optional[str] = None, default_key: str = "output", replace: ReplacingScope = ReplacingScope.INPLACE)
  name: Name for identification. If equals to None, class name will be used. Defaults to None.
  default_key: Default key used for results that is not of type Dict. Defaults to "output".
  replace: Replacing strategy. Defaults to ReplacingScope.INPLACE.
```

--------------------------------

### Imports for Basic Image Classification Example

Source: https://utca.knowledgator.com/examples/basic-image-classification

This snippet imports the pathlib module to handle file paths and specific components from the utca library: TransformersImageClassification for the classification task and ImageRead for image data source handling. It also defines a PATH variable.

```python
import pathlib
PATH = pathlib.Path(__file__).parent.resolve()

from utca.implementation.tasks import TransformersImageClassification
from utca.implementation.datasources.image import ImageRead
```

--------------------------------

### API Reference: Executable Schemas

Source: https://utca.knowledgator.com/base-actions/setvalue

Describes specialized executable schemas within the Knowledgator UTCA framework, which encapsulate complex workflows or functionalities. Examples include SemanticSearchSchema, Web2Meaning, and RequestsHTML for specific data processing or web interaction patterns.

```APIDOC
Executable Schemas:
  - SemanticSearchSchema
  - Web2Meaning
  - RequestsHTML
```

--------------------------------

### Initialize TransformersChartsAndPlotsAnalysis Task

Source: https://utca.knowledgator.com/tasks/transformerschartsandplotsanalysis

Documents the `__init__` method for the `TransformersChartsAndPlotsAnalysis` task. It details the various optional arguments such as `predictor`, `preprocess`, `postprocess`, `input_class`, `output_class`, and `name`, explaining their purpose and default behaviors. This allows for flexible customization of the task's components and validation schemas.

```APIDOC
__init__(
  predictor: Predictor[Any, Any] = None,
  preprocess: Optional[Component] = None,
  postprocess: Optional[Component] = None,
  input_class: Type[Input] = ChartsAndPlotsAnalysisInput,
  output_class: Type[Output] = TransformersBasicOutput,
  name: Optional[str] = None
)
  Arguments:
    predictor (Predictor[Any, Any], optional): Predictor that will be used in task. If equals to None, default predictor will be used. Defaults to None.
    preprocess (Optional[Component], optional): Component executed before predictor. If equals to None, default component will be used. Defaults to None.
      Default component: ChartsAndPlotsAnalysisPreprocessor.
      If default chain is used, ChartsAndPlotsAnalysisPreprocessor will use Pix2StructProcessor from model used in predictor.
    postprocess (Optional[Component], optional): Component executed after predictor. If equals to None, default component will be used. Defaults to None.
      Default component: ChartsAndPlotsAnalysisPostprocessor.
      If default chain is used, ChartsAndPlotsAnalysisPostprocessor will use Pix2StructProcessor from model used in predictor.
    input_class (Type[Input], optional): Class for input validation. Defaults to ChartsAndPlotsAnalysisInput.
    output_class (Type[Output], optional): Class for output validation. Defaults to TransformersBasicOutput.
    name (Optional[str], optional): Name for identification. If equals to None, class name will be used. Defaults to None.
```

--------------------------------

### Data Processing Function API Specification

Source: https://utca.knowledgator.com/tasks/gliner

Defines the structure of the `input_data` dictionary, including keys for model output, processed text, and chunk start indices. Also specifies the structure of the returned dictionary, detailing processed text and classified entities.

```APIDOC
Arguments:
  input_data (Dict[str, Any]):
    output (List[List[Dict[str, Any]]]): Model output
    text (str): Processed text
    chunks_starts (List[int]): Chunks starts

Returns:
  Dict[str, Any]:
    text (str): Processed text
    output (List[ClassifiedEntity]): Classified entities
```

--------------------------------

### Module: implementation.datasources.index Overview

Source: https://utca.knowledgator.com/datasources/index

This entry describes the overall purpose and structure of the `implementation.datasources.index` module, which encapsulates functionalities related to FAISS index management.

```APIDOC
Module: implementation.datasources.index
Description: This module provides actions for managing FAISS indexes, including creation, data indexing, searching, and result retrieval.
```

--------------------------------

### Web2Meaning Class and Constructor

Source: https://utca.knowledgator.com/executable-schemas/web2meaning

Defines the Web2Meaning executable schema, a subclass of Executable. Its constructor initializes the API client with a RapidAPI key, optional configuration, and input/output validation classes.

```APIDOC
Web2Meaning:
  Subclass of Executable[Web2MeaningInput, Web2MeaningOutput]
  Module: implementation.schemas
  __init__(rapid_api_key: str, cfg: Optional[Web2MeaningParameters], input_class: Type[Web2MeaningInput], output_class: Type[Web2MeaningOutput], name: Optional[str])
    rapid_api_key (str): API access key.
    cfg (Optional[Web2MeaningParameters], optional): API parameters.
    input_class (Type[Web2MeaningInput], optional): Class for input validation. Defaults to Web2MeaningInput.
    output_class (Type[Web2MeaningOutput], optional): Class for output validation. Defaults to Web2MeaningOutput.
    name (Optional[str], optional): Name for identification. If equals to None, class name will be used. Defaults to None.
```

--------------------------------

### QdrantRecreateCollection Class API Reference

Source: https://utca.knowledgator.com/datasources/db/qdrant

Detailed API documentation for the `QdrantRecreateCollection` class, a specialized `Action` subclass for managing Qdrant collections. It outlines the class's purpose, inheritance, and the parameters required for its initialization.

```APIDOC
Class: QdrantRecreateCollection
  Description: Delete and create empty collection with given parameters. Subclass of Action. Type of Action[Dict[str, Any], bool]
  Methods:
    __init__(client: QdrantClient, name: Optional[str] = None, default_key: str = "output"):
      client: Qdrant client to use
      name: Name for identification. If equals to None, class name will be used. Defaults to None.
      default_key: Default key used for results that is not of type Dict. Defaults to "output".
    execute():
      # No arguments or return type specified in the provided text.
```

--------------------------------

### ChromaDBCreateCollection API Reference

Source: https://utca.knowledgator.com/datasources/db/chroma

Detailed API documentation for the `ChromaDBCreateCollection` class, which is used to create new collections in ChromaDB. It outlines the constructor parameters and the `execute` method's arguments and return type.

```APIDOC
ChromaDBCreateCollection:
  Description: Create collection. Subclass of Action. Type of Action[str, Collection]
  __init__(client: ClientAPI, embedding_function: Optional[EmbeddingFunction[Embeddable]] = None, metadata: Optional[Dict[str, Any]] = None, name: Optional[str] = None):
    client: ChromaDB client to use.
    embedding_function: Embedding function to use. If equals to None, default will be used. Defaults to None.
    metadata: Collection metadata. Defaults to None.
    name: Name for identification. If equals to None, class name will be used. Defaults to None.
  execute(input_data: str) -> Collection:
    input_data: The name of the collection to create.
    Returns: The newly created collection.
```

--------------------------------

### QdrantDelete Constructor API Documentation

Source: https://utca.knowledgator.com/datasources/db/qdrant

Details the `__init__` method for the QdrantDelete class. It specifies the required Qdrant client, an optional name for identification, and a default key for results not of type Dict.

```APIDOC
Method: QdrantDelete.__init__
Arguments:
  client (QdrantClient): Qdrant client to use
  name (Optional[str], optional): Name for identification. If equals to None, class name will be used. Defaults to None.
  default_key (str, optional): Default key used for results that is not of type Dict. Defaults to "output".
```

--------------------------------

### Executable Class API Reference

Source: https://utca.knowledgator.com/core/executable

Detailed API documentation for the `Executable` base class, including its constructor and main methods. This class is the foundation for all executable components in the system.

```APIDOC
class Executable(Component):
  """
  Base class of executables.
  Module: core
  """

  def __init__(self,
               input_class: Type[Input],
               output_class: Type[Output],
               name: Optional[str] = None,
               replace: ReplacingScope = ReplacingScope.INPLACE):
    """
    Initializes the Executable instance.
    Args:
      input_class (Type[Input]): Class for input validation.
      output_class (Type[Output]): Class for output validation.
      name (Optional[str], optional): Name for identification. If equals to None, class name will be used. Defaults to None.
      replace (ReplacingScope, optional): Replacing strategy. Defaults to ReplacingScope.INPLACE.
    """
    pass

  def invoke(self, input_data: Input, evaluator: Evaluator) -> Dict[str, Any]:
    """
    Main logic. This method should be overwritten when custom executable created.
    Args:
      input_data (Input): Validated input.
      evaluator (Evaluator): Evaluator in context of which executed.
    Returns:
      Dict[str, Any]: Result of execution.
    """
    pass

  def validate(self, data: Dict[str, Any], validation_class: Type[ValidationClass]) -> ValidationClass:
    """
    Validation of input/output.
    Args:
      data (Dict[str, Any]): Input/output data.
      validation_class (Type[ValidationClass]): Class used for validation.
    Raises:
      IvalidInputDataValue: If data is invalid.
    Returns:
      ValidationClass: Validated data.
    """
    pass

  def validate_input(self, data: Dict[str, Any]) -> Input:
    """
    Validation of input.
    Args:
      data (Dict[str, Any]): Input data.
    Returns:
      Input: Validated input.
    """
    pass

  def validate_output(self, data: Dict[str, Any]) -> Output:
    """
    Validation of output.
    Args:
      data (Dict[str, Any]): Output data.
    Returns:
      Output: Validated output.
    """
    pass

  def execute(self, input_data: Dict[str, Any], evaluator: Evaluator) -> Dict[str, Any]:
    """
    Validate input, invoke and validate output.
    Args:
      input_data (Dict[str, Any]): Data for processing.
      evaluator (Evaluator): Evaluator in context of which executed.
    Raises:
      ExecutableError: If any error occurs.
    Returns:
      Dict[str, Any]: Result of execution.
    """
    pass

  def use(self,
          get_key: Optional[str] = None,
          set_key: Optional[str] = None,
          default_key: str = "output",
          replace: Optional[ReplacingScope] = None) -> ExecutableExecutor:
    """
    Creates ExecutableExecutor which manages context.
    Args:
      get_key (Optional[str], optional): Which key value of input_data will be used. If value equal to None, root dict will be used. Defaults to None.
      set_key (Optional[str], optional): Which key will be used to set result value. If set_key value equal to None:
        - if result of type Dict[str, Any], update root dict;
        - else, set result to default_key.
        Defaults to None.
      default_key (str, optional): Default key used for results that is not of type Dict. Defaults to "output".
      replace (Optional[ReplacingScope], optional): Replacing strategy for executor. If equals to None, this executable strategy will be used. Defaults to None.
    Returns:
      ExecutableExecutor: Wrapper of Executable.
    """
    pass
```

--------------------------------

### Execute Text-to-Speech pipeline with inputs

Source: https://utca.knowledgator.com/examples/text-to-speech

This snippet demonstrates how to run the defined text-to-speech pipeline by providing a text input and a file path where the resulting audio will be saved. The `PATH` variable ensures the output file is relative to the script's location.

```python
pipeline.run({
    "text_inputs": "Hello world!",
    "path_to_file": f"{PATH}/test.wav"
})
```

--------------------------------

### Qdrant Collection Creation Arguments

Source: https://utca.knowledgator.com/datasources/db/qdrant

Defines the input parameters for creating or reconfiguring a Qdrant collection, including vector storage, sharding, replication, write consistency, payload storage, and various configuration settings for HNSW, optimizers, WAL, quantization, and initialization from existing data.

```APIDOC
Arguments for Collection Creation:
  input_data (Dict[str, Any]):
    collection_name: Name of the collection to recreate.
    vectors_config: Configuration of the vector storage. Vector params contains size and distance for the vector storage. If dict is passed, service will create a vector storage for each key in the dict. If single VectorParams is passed, service will create a single anonymous vector storage.
    sparse_vectors_config: Configuration of the sparse vector storage. The service will create a sparse vector storage for each key in the dict.
    shard_number: Number of shards in collection. Default is 1, minimum is 1.
    sharding_method: Defines strategy for shard creation. Option auto (default) creates defined number of shards automatically. Data will be distributed between shards automatically. After creation, shards could be additionally replicated, but new shards could not be created. Option custom allows to create shards manually, each shard should be created with assigned unique shard_key. Data will be distributed between based on shard_key value.
    replication_factor: Replication factor for collection. Default is 1, minimum is 1. Defines how many copies of each shard will be created. Have effect only in distributed mode.
    write_consistency_factor: Write consistency factor for collection. Default is 1, minimum is 1. Defines how many replicas should apply the operation for us to consider it successful. Increasing this number will make the collection more resilient to inconsistencies, but will also make it fail if not enough replicas are available. Does not have any performance impact. Have effect only in distributed mode.
    on_disk_payload: If true - point's payload will not be stored in memory. It will be read from the disk every time it is requested. This setting saves RAM by (slightly) increasing the response time.
      Note: those payload values that are involved in filtering and are indexed - remain in RAM.
    hnsw_config: Params for HNSW index
    optimizers_config: Params for optimizer
    wal_config: Params for Write-Ahead-Log
    quantization_config: Params for quantization, if None - quantization will be disabled
    init_from: Use data stored in another collection to initialize this collection
    timeout: Wait for operation commit timeout in seconds. If timeout is reached - request will return with service error.
Returns:
  bool: Operation result.
```

--------------------------------

### APIDOC: NEROutput Class Constructor (__init__)

Source: https://utca.knowledgator.com/tasks/task

Initializes an `NEROutput` instance with a list of detected entities.

```APIDOC
NEROutput:
  __init__(output: List[EntityType])
    output: List of entities.
```

--------------------------------

### Log Component Initialization (__init__)

Source: https://utca.knowledgator.com/structural-components/log

This section describes the constructor for the Log component, detailing all available arguments for configuring logging behavior. It allows setting the logging level, specifying a logger object, defining the log message, and customizing the surrounding strings for the log output. Additionally, it controls whether input data should be included in the log.

```APIDOC
Log:
  __init__(level: int = logging.NOTSET, logger: Optional[logging.Logger] = None, message: str = "", open: str = "-"*40, close: str = "-"*40, include_input_data: bool = True, name: Optional[str] = None)
    level: Logging level. Defaults to logging.NOTSET.
    logger: Logger object. If value equals to None, evaluator logger will be used. Defaults to None.
    message: Message that will be logged. Defaults to "".
    open: String that will be inserted before message (new line). Defaults to "-"*40.
    close: String that will be inserted after message (new line). Defaults to "-"*40.
    include_input_data: Include data representation in log. Defaults to True.
    name: Name for identification. If equals to None, class name will be used. Defaults to None.
```

--------------------------------

### TransformersObjectDetectionOutput Class Constructor API

Source: https://utca.knowledgator.com/tasks/transformersobjectdetection

API documentation for the `__init__` method of the `TransformersObjectDetectionOutput` class, defining the output schema for object detection tasks.

```APIDOC
TransformersObjectDetectionOutput:
  __init__()
```

--------------------------------

### API Documentation for ImagePad Class

Source: https://utca.knowledgator.com/datasources/image

Documents the ImagePad class, which is used for padding images. It describes the initialization parameters for controlling padding dimensions, method, and centering, as well as the execute method for applying the padding.

```APIDOC
ImagePad (Subclass of Action[Image.Image, Image.Image]):
  __init__(
    width: int,
    height: int,
    method: Image.Resampling = Resampling.BICUBIC,
    centering: Tuple[float, float] = (0.5, 0.5),
    name: Optional[str] = None,
    default_key: str = "image"
  )
    width: New width in pixels.
    height: New height in pixels.
    method: Resampling method to use. Default is Resampling.BICUBIC.
    centering: Control the position of the original image within the padded version. (0.5, 0.5) will keep the image centered (0, 0) will keep the image aligned to the top left (1, 1) will keep the image aligned to the bottom right.
    name: Name for identification. If equals to None, class name will be used. Defaults to None.
    default_key: What key will be used by default. Defaults to "image".

  execute(
    input_data: Image.Image
  ) -> Image.Image
    input_data: Image.
    Returns: Resized image.
```

--------------------------------

### ComprehendIt Task __init__ Method API

Source: https://utca.knowledgator.com/tasks/comprehendit

The constructor for the ComprehendIt task, allowing configuration of the predictor, optional preprocessing and postprocessing components, input and output validation classes, and an optional name for the task instance.

```APIDOC
__init__(
  predictor: Predictor[Any, Any] = None,
  preprocess: Optional[Component] = None,
  postprocess: Optional[Component] = None,
  input_class: Type[Input] = ComprehendItPredictorInput,
  output_class: Type[Output] = ComprehendItPredictorOutput,
  name: Optional[str] = None
)
  predictor: Predictor that will be used in task. If equals to None, default ComprehendItPredictor will be used. Defaults to None.
  preprocess: Component executed before predictor. Defaults to None.
  postprocess: Component executed after predictor. Defaults to None.
  input_class: Class for input validation. Defaults to ComprehendItPredictorInput.
  output_class: Class for output validation. Defaults to ComprehendItPredictorOutput.
  name: Name for identification. If equals to None, class name will be used. Defaults to None.
```

--------------------------------

### TransformersTextToSpeech __init__ Method API Documentation

Source: https://utca.knowledgator.com/tasks/transformerstexttospeech

API documentation for the `__init__` method of the `TransformersTextToSpeech` class. It outlines the various optional parameters available for initializing the task, including the predictor, preprocessing/postprocessing components, input/output validation classes, and an optional name.

```APIDOC
__init__(
  predictor: Predictor[Any, Any] = None,
  preprocess: Optional[Component] = None,
  postprocess: Optional[Component] = None,
  input_class: Type[Input] = TransformersTextToSpeechInput,
  output_class: Type[Output] = TransformersTextToSpeechOutput,
  name: Optional[str] = None
)
Arguments:
  predictor (Predictor[Any, Any], optional): Predictor that will be used in task. If equals to None, default predictor will be used. Defaults to None.
  preprocess (Optional[Component], optional): Component executed before predictor. Defaults to None.
  postprocess (Optional[Component], optional): Component executed after predictor. Defaults to None.
  input_class (Type[Input], optional): Class for input validation. Defaults to TransformersTextToSpeechInput.
  output_class (Type[Output], optional): Class for output validation. Defaults to TransformersTextToSpeechOutput.
  name (Optional[str], optional): Name for identification. If equals to None, class name will be used. Defaults to None.
```

--------------------------------

### TokenSearcherNERPostprocessor Class API Documentation

Source: https://utca.knowledgator.com/tasks/tokensearcherner

API documentation for the TokenSearcherNERPostprocessor class, detailing its constructor (__init__) and execute method, including arguments, types, and expected return values.

```APIDOC
TokenSearcherNERPostprocessor:
  __init__(threshold: float = 0, name: Optional[str] = None)
    threshold: Entities threshold score. Defaults to 0.
    name: Name for identification. If equals to None, class name will be used. Defaults to None.
  execute(input_data: Dict[str, Any]) -> Dict[str, Any]
    input_data:
      Expected keys:
        "output": Model output; (List[List[Dict[str, Any]]])
        "labels": Labels for classification; (List[str])
        "text": Processed text; (str)
        "chunks_starts": Chunks start positions; (List[int])
        "prompt_lengths": Prompt lenghts; (List[int])
    Returns:
      Expected keys:
        "text": Processed text; (str)
        "output": Classified entities; (List[ClassifiedEntity])
```

--------------------------------

### TokenSearcherQandA Class Initialization Method

Source: https://utca.knowledgator.com/tasks/tokensearcherqanda

Initializes the TokenSearcherQandA task. It allows specifying a custom predictor, preprocessor, postprocessor, and input/output validation classes. Default components are used if not provided.

```APIDOC
TokenSearcherQandA:
  __init__(
    predictor: Predictor[Any, Any] = None,
    preprocess: Optional[Component] = None,
    postprocess: Optional[Component] = None,
    input_class: Type[Input] = TokenSearcherQandAInput,
    output_class: Type[NEROutputType] = TokenSearcherQandAOutput,
    name: Optional[str] = None
  )
    predictor: Predictor that will be used in task. If equals to None, default TokenSearcherPredictor will be used.
    preprocess: Component executed before predictor. If equals to None, default component TokenSearcherQandAPreprocessor will be used.
    postprocess: Component executed after predictor. If equals to None, default component TokenSearcherQandAPostprocessor will be used.
    input_class: Class for input validation.
    output_class: Class for output validation.
    name: Name for identification. If equals to None, class name will be used.
```

--------------------------------

### Initialize GoogleCloudClient

Source: https://utca.knowledgator.com/apis/googlecloudclient

Initializes the GoogleCloudClient with the provided configuration object. This client is used for authorization and data access to Google Cloud services.

```APIDOC
GoogleCloudClient:
  __init__(cfg: GoogleCloudClientConfig)
    cfg: Client configuration.
```
Tokens:
Raw