hamtaa-texttools 1.0.5__py3-none-any.whl → 1.1.16__py3-none-any.whl

hamtaa_texttools-1.0.5.dist-info/METADATA

@@ -1,192 +0,0 @@
-Metadata-Version: 2.4
-Name: hamtaa-texttools
-Version: 1.0.5
-Summary: TextTools is a high-level NLP toolkit built on top of modern LLMs.
-Author-email: Tohidi <the.mohammad.tohidi@gmail.com>, Montazer <montazerh82@gmail.com>, Givechi <mohamad.m.givechi@gmail.com>, MoosaviNejad <erfanmoosavi84@gmail.com>
-License: MIT License
-        
-        Copyright (c) 2025 Hamtaa
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-Keywords: nlp,llm,text-processing,openai
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: openai==1.97.1
-Requires-Dist: PyYAML>=6.0
-Dynamic: license-file
-
-# TextTools
-
-## 📌 Overview
-
-**TextTools** is a high-level **NLP toolkit** built on top of modern **LLMs**.  
-
-It provides both **sync (`TheTool`)** and **async (`AsyncTheTool`)** APIs for maximum flexibility.
-
-It provides ready-to-use utilities for **translation, question detection, keyword extraction, categorization, NER extractor, and more** — designed to help you integrate AI-powered text processing into your applications with minimal effort.
-
-**Thread Safety:** All methods in AsyncTheTool are thread-safe, allowing concurrent usage across multiple threads without conflicts.
-
----
-
-## ✨ Features
-
-TextTools provides a rich collection of high-level NLP utilities built on top of LLMs.  
-Each tool is designed to work out-of-the-box with structured outputs (JSON / Pydantic).
-
-- **Categorizer** → Zero-finetuning text categorization for fast, scalable classification.  
-- **Keyword Extractor** → Identify the most important keywords in a text.  
-- **Question Merger** → Merge the provided questions, preserving all the main points 
-- **NER (Named Entity Recognition) Extractor** → Extract people, places, organizations, and other entities.  
-- **Question Detector** → Determine whether a text is a question or not.  
-- **Question Generator From Text** → Generate high-quality, context-relevant questions from provided text.
-- **Question Generator From Subject** → Generate high-quality, context-relevant questions from a subject.
-- **Rewriter** → Rewrite text while preserving meaning or without it.
-- **Summarizer** → Condense long passages into clear, structured summaries. 
-- **Translator** → Translate text across multiple languages, with support for custom rules.
-- **Custom Tool** → Allows users to define a custom tool with arbitrary BaseModel. 
-
----
-
-## ⚙️ `with_analysis`, `logprobs`, `output_lang`, and `user_prompt` parameters
-
-TextTools provides several optional flags to customize LLM behavior:
-
-- **`with_analysis=True`** → Adds a reasoning step before generating the final output. Useful for debugging, improving prompts, or understanding model behavior.  
-Note: This doubles token usage per call because it triggers an additional LLM request.
-
-- **`logprobs=True`** → Returns token-level probabilities for the generated output. You can also specify `top_logprobs=<N>` to get the top N alternative tokens and their probabilities.  
-
-- **`output_lang="en"`** → Forces the model to respond in a specific language. The model will ignore other instructions about language and respond strictly in the requested language.
-
-- **`user_prompt="..."`** → Allows you to inject a custom instruction or prompt into the model alongside the main template. This gives you fine-grained control over how the model interprets or modifies the input text.
-
-All these flags can be used individually or together to tailor the behavior of any tool in **TextTools**.
-
----
-
-## 🚀 Installation
-
-Install the latest release via PyPI:
-
-```bash
-pip install -U hamta-texttools
-```
-
----
-
-## Sync vs Async
-| Tool         | Style   | Use case                                    |
-|--------------|---------|---------------------------------------------|
-| `TheTool`    | Sync    | Simple scripts, sequential workflows        |
-| `AsyncTheTool` | Async | High-throughput apps, APIs, concurrent tasks |
-
----
-
-## ⚡ Quick Start (Sync)
-
-```python
-from openai import OpenAI
-from pydantic import BaseModel
-from texttools import TheTool
-
-# Create your OpenAI client
-client = OpenAI(base_url = "your_url", API_KEY = "your_api_key")
-
-# Specify the model
-model = "gpt-4o-mini"
-
-# Create an instance of TheTool
-# Note: You can give parameters to TheTool so that you don't need to give them to each tool
-the_tool = TheTool(client=client, model=model, with_analysis=True, output_lang="English")
-
-# Example: Question Detection
-detection = the_tool.detect_question("Is this project open source?", logpobs=True, top_logprobs=2)
-print(detection["result"])
-print(detection["logprobs"])
-# Output: True
-
-# Example: Translation
-# Note: You can overwrite with_analysis if defined at TheTool
-print(the_tool.translate("سلام، حالت چطوره؟", target_language="English", with_analysis=False)["result"])
-# Output: "Hi! How are you?"
-
-# Example: Custom Tool
-# Note: Output model should only contain result key
-# Everything else will be ignored
-class Custom(BaseModel):
-  result: list[list[dict[str, int]]]
-
-custom_prompt = "Something"
-custom_result = the_tool.custom_tool(custom_prompt, Custom)
-print(custom_result)
-```
-
----
-
-## ⚡ Quick Start (Async)
-
-```python
-import asyncio
-from openai import AsyncOpenAI
-from texttools import AsyncTheTool
-
-async def main():
-    # Create your async OpenAI client
-    async_client = AsyncOpenAI(base_url="your_url", api_key="your_api_key")
-
-    # Specify the model
-    model = "gpt-4o-mini"
-
-    # Create an instance of AsyncTheTool
-    the_tool = AsyncTheTool(client=async_client, model=model)
-
-    # Example: Async Translation
-    result = await the_tool.translate("سلام، حالت چطوره؟", target_language="English")
-    print(result["result"])
-    # Output: "Hi! How are you?"
-
-asyncio.run(main())
-```
-
----
-
-## 📚 Use Cases
-
-Use **TextTools** when you need to:
-
-- 🔍 **Classify** large datasets quickly without model training  
-- 🌍 **Translate** and process multilingual corpora with ease  
-- 🧩 **Integrate** LLMs into production pipelines (structured outputs)  
-- 📊 **Analyze** large text collections using embeddings and categorization  
-- 👍 **Automate** common text-processing tasks without reinventing the wheel  
-
----
-
-## 🤝 Contributing
-
-Contributions are welcome!  
-Feel free to **open issues, suggest new features, or submit pull requests**.  
-
----
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

hamtaa_texttools-1.0.5.dist-info/RECORD

@@ -1,30 +0,0 @@
-hamtaa_texttools-1.0.5.dist-info/licenses/LICENSE,sha256=Hb2YOBKy2MJQLnyLrX37B4ZVuac8eaIcE71SvVIMOLg,1082
-texttools/__init__.py,sha256=v3tQCH_Cjj47fCpuhK6sKSVAqEjNkc-cZbY4OJa4IZw,202
-texttools/batch/__init__.py,sha256=q50JsQsmQGp_8RW0KNasYeYWVV0R4FUNZ-ujXwEJemY,143
-texttools/batch/batch_manager.py,sha256=aYnHy82b4FJmhi2TWjXtxg67dN6PZOu2gQSusx373vE,9328
-texttools/batch/batch_runner.py,sha256=OHxeFT0YhEuDwZVAE07PUEC_7cuICWnnim3SuyZsx4U,7814
-texttools/formatters/base_formatter.py,sha256=xxnbujAr01NqZ49Y61LVFpIbj6kTEmV6JiUH_qCsIFk,1180
-texttools/formatters/user_merge_formatter.py,sha256=U_d7npTkC9QDgtEFjAjIuDlPfxVj3S1RyziidKqjciw,1086
-texttools/prompts/README.md,sha256=z8XW7ovh0yT1WGhkSPzYKixEtiGuDzeof6MALXaxUUY,1365
-texttools/prompts/categorizer.yaml,sha256=GMqIIzQFhgnlpkgU1qi3FAD3mD4A2jiWD5TilQ2XnnE,1204
-texttools/prompts/custom_tool.yaml,sha256=38OkCoVITbuuS9c08UZSP1jZW4WjSmRIi8fR0RAiPu4,108
-texttools/prompts/keyword_extractor.yaml,sha256=R05Ac_qnP4sUvhOGCW3XpjlJFdz1KgU4CgVCOXflY8M,775
-texttools/prompts/ner_extractor.yaml,sha256=KiKjeDpHaeh3JVtZ6q1pa3k4DYucUIU9WnEcRTCA-SE,651
-texttools/prompts/question_detector.yaml,sha256=d0-vKRbXWkxvO64ikvxRjEmpAXGpCYIPGhgexvPPjws,471
-texttools/prompts/question_generator.yaml,sha256=UheKYpDn6iyKI8NxunHZtFpNyfCLZZe5cvkuXpurUJY,783
-texttools/prompts/question_merger.yaml,sha256=b72QAk9Gs8k1xb2lSDXx44u-3Ku5vIuWL_6han4UaO0,1797
-texttools/prompts/rewriter.yaml,sha256=LO7He_IA3MZKz8a-LxH9DHJpOjpYwaYN1pbjp1Y0tFo,5392
-texttools/prompts/subject_question_generator.yaml,sha256=C7x7rNNm6U_ZG9HOn6zuzYOtvJUZ2skuWbL1-aYdd3E,1147
-texttools/prompts/summarizer.yaml,sha256=o6rxGPfWtZd61Duvm8NVvCJqfq73b-wAuMSKR6UYUqY,459
-texttools/prompts/translator.yaml,sha256=mGT2uBCei6uucWqVbs4silk-UV060v3G0jnt0P6sr50,634
-texttools/tools/__init__.py,sha256=hG1I28Q7BJ1Dbs95x6QMKXdsAlC5Eh_tqC-EbAibwiU,114
-texttools/tools/async_the_tool.py,sha256=m5b8t1eAGDDN44nOf-h9l-8rLxg7a859nZ9QePVlRzI,8827
-texttools/tools/the_tool.py,sha256=oRDsg8ZqMcUiWX6WXdtw9C1XkgWdi93GcBXCqTcUCMo,19406
-texttools/tools/internals/async_operator.py,sha256=jvpeVffRYnm6inUB7jncbmiOAztayMPzsIi7UH1IrHs,9910
-texttools/tools/internals/operator.py,sha256=4lrV8UisJoSUKGI23iL8IjK_MWg-ev43ywAXxCob3nU,10033
-texttools/tools/internals/output_models.py,sha256=Rf2x-UuGlmQHrvYIqnD11YuzMH_mPuir62HoMJQa2uk,1528
-texttools/tools/internals/prompt_loader.py,sha256=8RFhZE3HOcnQdtndSP2qULD6YQbZ34EVsTbXR-Zr-NM,2510
-hamtaa_texttools-1.0.5.dist-info/METADATA,sha256=l2qrSuF_s2JHwcybcGdq4c2hhcE-D6eqNzPvJZPyHaE,7780
-hamtaa_texttools-1.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hamtaa_texttools-1.0.5.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
-hamtaa_texttools-1.0.5.dist-info/RECORD,,

texttools/batch/__init__.py

@@ -1,4 +0,0 @@
-from .batch_manager import SimpleBatchManager
-from .batch_runner import BatchJobRunner
-
-__all__ = ["SimpleBatchManager", "BatchJobRunner"]

texttools/formatters/base_formatter.py

@@ -1,33 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any
-
-
-class BaseFormatter(ABC):
-    """
-    Adapter to convert a conversation into a specific LLM API's input format.
-
-    Concrete implementations transform standardized messages (e.g., list[dict]) into the
-    exact payload required by a provider (e.g., OpenAI's message list, a single string, etc.).
-    """
-
-    @abstractmethod
-    def format(
-        self,
-        messages: Any,
-    ) -> Any:
-        """
-        Transform the input messages into a provider-specific payload.
-
-        Args:
-            messages: The input conversation. While often a list of dicts with
-                      'role' and 'content' keys, the exact type and structure may vary
-                      by implementation.
-
-        Returns:
-            A payload in the format expected by the target LLM API. This could be:
-            - A list of role-content dictionaries (e.g., for OpenAI)
-            - A single formatted string (e.g., for completion-style APIs)
-            - A complex dictionary with additional parameters
-            - Any other provider-specific data structure
-        """
-        pass

texttools/formatters/user_merge_formatter.py

@@ -1,30 +0,0 @@
-from texttools.formatters.base_formatter import BaseFormatter
-
-
-class UserMergeFormatter(BaseFormatter):
-    """
-    Merges consecutive user messages into a single message, separated by newlines.
-
-    This is useful for condensing a multi-turn user input into a single coherent
-    message for the LLM. Assistant and system messages are left unchanged and
-    act as separators between user message groups.
-
-    Raises:
-        ValueError: If the input messages have invalid structure or roles.
-    """
-
-    def format(self, messages: list[dict[str, str]]) -> list[dict[str, str]]:
-        merged: list[dict[str, str]] = []
-
-        for message in messages:
-            role, content = message["role"], message["content"].strip()
-
-            # Merge with previous user turn
-            if merged and role == "user" and merged[-1]["role"] == "user":
-                merged[-1]["content"] += "\n" + content
-
-            # Otherwise, start a new turn
-            else:
-                merged.append({"role": role, "content": content})
-
-        return merged

texttools/prompts/categorizer.yaml

@@ -1,28 +0,0 @@
-main_template: |
-  تو یک متخصص علوم دینی هستی
-  من یک متن به تو میدهم و تو باید
-  آن متن را در یکی از دسته بندی های زیر طبقه بندی کنی
-  دسته بندی ها:
-  "باورهای دینی",
-  "اخلاق اسلامی",
-  "احکام و فقه",
-  "تاریخ اسلام و شخصیت ها",
-  "منابع دینی",
-  "دین و جامعه/سیاست",
-  "عرفان و معنویت",
-  "هیچکدام",
-  فقط با این فرمت json پاسخ بده:
-  {{
-  	  "reason": "<دلیل انتخابت رو به صورت خلاصه بگو>",
-      "result": "<یکی از دسته بندی ها>"
-  }}
-  متنی که باید طبقه بندی کنی:
-  {input}
-
-analyze_template: |
-  ما میخواهیم متنی که داده می شود را طبقه بندی کنیم.
-  برای بهبود طبقه بندی، نیاز به آنالیز متن داریم.
-  متنی که داده می شود را آنالیز کن و ایده اصلی و آنالیزی کوتاه از آن را بنویس.
-  آنالیز باید بسیار خلاصه باشد
-  نهایتا 20 کلمه
-  {input}

texttools/prompts/keyword_extractor.yaml

@@ -1,18 +0,0 @@
-main_template: |
-  You are an expert keyword extractor.
-  Extract the most relevant keywords from the given text.
-  Guidelines:
-  1. Keywords must represent the main concepts of the text.  
-  2. If two words have overlapping meanings, choose only one.  
-  3. Do not include generic or unrelated words.  
-  4. Keywords must be single, self-contained words (no phrases).
-  5. Output between 3 and 7 keywords based on the input length.
-  6. Respond only in JSON format:
-  {{"result": ["keyword1", "keyword2", etc.]}}
-  Here is the text:
-  {input}
-
-analyze_template: |
-  Analyze the following text to identify its main topics, concepts, and important terms.
-  Provide a concise summary of your findings that will help in extracting relevant keywords.
-  {input}

texttools/tools/__init__.py

@@ -1,4 +0,0 @@
-from .async_the_tool import AsyncTheTool
-from .the_tool import TheTool
-
-__all__ = ["TheTool", "AsyncTheTool"]

texttools/tools/async_the_tool.py

@@ -1,277 +0,0 @@
-from typing import Literal
-
-from openai import AsyncOpenAI
-
-import texttools.tools.internals.output_models as OutputModels
-from texttools.tools.internals.async_operator import AsyncOperator
-
-
-class AsyncTheTool:
-    """
-    Async counterpart to TheTool.
-
-    Usage:
-        async_client = AsyncOpenAI(...)
-        tool = TheToolAsync(async_client, model="gemma-3")
-        result = await tool.categorize("متن ...", with_analysis=True)
-    """
-
-    def __init__(
-        self,
-        client: AsyncOpenAI,
-        *,
-        model: str,
-        temperature: float = 0.0,
-    ):
-        self.operator = AsyncOperator(
-            client=client,
-            model=model,
-            temperature=temperature,
-        )
-
-    async def categorize(
-        self,
-        text: str,
-        with_analysis: bool = False,
-        user_prompt: str = "",
-        logprobs: bool = False,
-        top_logprobs: int = 8,
-        max_tokens: int | None = None,
-    ) -> dict[str, str]:
-        results = await self.operator.run(
-            text,
-            prompt_file="categorizer.yaml",
-            output_model=OutputModels.CategorizerOutput,
-            with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
-        )
-        return results
-
-    async def extract_keywords(
-        self,
-        text: str,
-        output_lang: str | None = None,
-        with_analysis: bool = False,
-        user_prompt: str = "",
-        logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
-    ) -> dict[str, list[str]]:
-        results = await self.operator.run(
-            text,
-            prompt_file="keyword_extractor.yaml",
-            output_model=OutputModels.ListStrOutput,
-            with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
-            output_lang=output_lang,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
-        )
-        return results
-
-    async def extract_entities(
-        self,
-        text: str,
-        output_lang: str | None = None,
-        with_analysis: bool = False,
-        user_prompt: str = "",
-        logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
-    ) -> dict[str, list[dict[str, str]]]:
-        results = await self.operator.run(
-            text,
-            prompt_file="ner_extractor.yaml",
-            output_model=OutputModels.ListDictStrStrOutput,
-            with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
-            output_lang=output_lang,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
-        )
-        return results
-
-    async def detect_question(
-        self,
-        question: str,
-        output_lang: str | None = None,
-        with_analysis: bool = False,
-        user_prompt: str = "",
-        logprobs: bool = False,
-        top_logprobs: int = 2,
-        max_tokens: int | None = None,
-    ) -> dict[str, bool]:
-        results = await self.operator.run(
-            question,
-            prompt_file="question_detector.yaml",
-            output_model=OutputModels.BoolOutput,
-            with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
-            output_lang=output_lang,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
-        )
-        return results
-
-    async def generate_question_from_text(
-        self,
-        text: str,
-        output_lang: str | None = None,
-        with_analysis: bool = False,
-        user_prompt: str = "",
-        logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
-    ) -> dict[str, str]:
-        results = await self.operator.run(
-            text,
-            prompt_file="question_generator.yaml",
-            output_model=OutputModels.StrOutput,
-            with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
-            output_lang=output_lang,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
-        )
-        return results
-
-    async def merge_questions(
-        self,
-        questions: list[str],
-        output_lang: str | None = None,
-        mode: Literal["default", "reason"] = "default",
-        with_analysis: bool = False,
-        user_prompt: str = "",
-        logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
-    ) -> dict[str, str]:
-        question_str = ", ".join(questions)
-        results = await self.operator.run(
-            question_str,
-            prompt_file="question_merger.yaml",
-            output_model=OutputModels.StrOutput,
-            with_analysis=with_analysis,
-            use_modes=True,
-            mode=mode,
-            resp_format="parse",
-            user_prompt=user_prompt,
-            output_lang=output_lang,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
-        )
-        return results
-
-    async def rewrite(
-        self,
-        question: str,
-        output_lang: str | None = None,
-        mode: Literal["positive", "negative", "hard_negative"] = "positive",
-        with_analysis: bool = False,
-        user_prompt: str = "",
-        logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
-    ) -> dict[str, str]:
-        results = await self.operator.run(
-            question,
-            prompt_file="rewriter.yaml",
-            output_model=OutputModels.StrOutput,
-            with_analysis=with_analysis,
-            use_modes=True,
-            mode=mode,
-            resp_format="parse",
-            user_prompt=user_prompt,
-            output_lang=output_lang,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
-        )
-        return results
-
-    async def generate_questions_from_subject(
-        self,
-        subject: str,
-        number_of_questions: int,
-        output_lang: str | None = None,
-        with_analysis: bool = False,
-        user_prompt: str = "",
-        logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
-    ) -> dict[str, list[str]]:
-        results = await self.operator.run(
-            subject,
-            prompt_file="subject_question_generator.yaml",
-            output_model=OutputModels.ReasonListStrOutput,
-            with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
-            number_of_questions=number_of_questions,
-            output_lang=output_lang,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
-        )
-        return results
-
-    async def summarize(
-        self,
-        text: str,
-        output_lang: str | None = None,
-        with_analysis: bool = False,
-        user_prompt: str = "",
-        logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
-    ) -> dict[str, str]:
-        results = await self.operator.run(
-            text,
-            prompt_file="summarizer.yaml",
-            output_model=OutputModels.StrOutput,
-            with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
-            output_lang=output_lang,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
-        )
-        return results
-
-    async def translate(
-        self,
-        text: str,
-        target_language: str,
-        with_analysis: bool = False,
-        user_prompt: str = "",
-        logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
-    ) -> dict[str, str]:
-        results = await self.operator.run(
-            text,
-            prompt_file="translator.yaml",
-            output_model=OutputModels.StrOutput,
-            with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
-            target_language=target_language,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
-        )
-        return results