hamtaa-texttools 1.0.6__py3-none-any.whl → 1.0.7__py3-none-any.whl

{hamtaa_texttools-1.0.6.dist-info → hamtaa_texttools-1.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamtaa-texttools
-Version: 1.0.6
+Version: 1.0.7
 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

{hamtaa_texttools-1.0.6.dist-info → hamtaa_texttools-1.0.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-hamtaa_texttools-1.0.6.dist-info/licenses/LICENSE,sha256=Hb2YOBKy2MJQLnyLrX37B4ZVuac8eaIcE71SvVIMOLg,1082
+hamtaa_texttools-1.0.7.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=leVIFkR-3HpDkQi_MK3TgFNnHYsCN-wbS4mTWoPmO3c,8828
@@ -7,24 +7,25 @@ texttools/formatters/base_formatter.py,sha256=xxnbujAr01NqZ49Y61LVFpIbj6kTEmV6Ji
 texttools/formatters/user_merge_formatter.py,sha256=U_d7npTkC9QDgtEFjAjIuDlPfxVj3S1RyziidKqjciw,1086
 texttools/prompts/README.md,sha256=rclMaCV1N8gT1KcpZu0-ka0dKGNg2f1CEcRMdQkgQOc,1379
 texttools/prompts/categorizer.yaml,sha256=GMqIIzQFhgnlpkgU1qi3FAD3mD4A2jiWD5TilQ2XnnE,1204
+texttools/prompts/extract_entities.yaml,sha256=KiKjeDpHaeh3JVtZ6q1pa3k4DYucUIU9WnEcRTCA-SE,651
+texttools/prompts/extract_keywords.yaml,sha256=0O7ypL_OsEOxtvlQ2CZjnsv9637DJwAKprZsf9Vo2_s,769
 texttools/prompts/is_question.yaml,sha256=d0-vKRbXWkxvO64ikvxRjEmpAXGpCYIPGhgexvPPjws,471
-texttools/prompts/keyword_extractor.yaml,sha256=0O7ypL_OsEOxtvlQ2CZjnsv9637DJwAKprZsf9Vo2_s,769
-texttools/prompts/ner_extractor.yaml,sha256=KiKjeDpHaeh3JVtZ6q1pa3k4DYucUIU9WnEcRTCA-SE,651
-texttools/prompts/question_merger.yaml,sha256=0J85GvTirZB4ELwH3sk8ub_WcqqpYf6PrMKr3djlZeo,1792
-texttools/prompts/rewriter.yaml,sha256=LO7He_IA3MZKz8a-LxH9DHJpOjpYwaYN1pbjp1Y0tFo,5392
+texttools/prompts/merge_questions.yaml,sha256=0J85GvTirZB4ELwH3sk8ub_WcqqpYf6PrMKr3djlZeo,1792
+texttools/prompts/rewrite.yaml,sha256=LO7He_IA3MZKz8a-LxH9DHJpOjpYwaYN1pbjp1Y0tFo,5392
 texttools/prompts/run_custom.yaml,sha256=38OkCoVITbuuS9c08UZSP1jZW4WjSmRIi8fR0RAiPu4,108
 texttools/prompts/subject_to_question.yaml,sha256=C7x7rNNm6U_ZG9HOn6zuzYOtvJUZ2skuWbL1-aYdd3E,1147
-texttools/prompts/summarizer.yaml,sha256=o6rxGPfWtZd61Duvm8NVvCJqfq73b-wAuMSKR6UYUqY,459
+texttools/prompts/summarize.yaml,sha256=o6rxGPfWtZd61Duvm8NVvCJqfq73b-wAuMSKR6UYUqY,459
 texttools/prompts/text_to_question.yaml,sha256=UheKYpDn6iyKI8NxunHZtFpNyfCLZZe5cvkuXpurUJY,783
-texttools/prompts/translator.yaml,sha256=mGT2uBCei6uucWqVbs4silk-UV060v3G0jnt0P6sr50,634
+texttools/prompts/translate.yaml,sha256=mGT2uBCei6uucWqVbs4silk-UV060v3G0jnt0P6sr50,634
 texttools/tools/__init__.py,sha256=hG1I28Q7BJ1Dbs95x6QMKXdsAlC5Eh_tqC-EbAibwiU,114
-texttools/tools/async_the_tool.py,sha256=BQdk0kyMme4fQz7aL5gcLvH7xEYYpfAaykM5wS9nonY,8785
-texttools/tools/the_tool.py,sha256=Yzt9JBK0bsMvDdsUXuWporTqqR497AmIQktTkM3RjgM,19334
-texttools/tools/internals/async_operator.py,sha256=bzXec7K_T_xwJ59zFkfuJ-zaadt6nfXjW1S4BmoHaFM,10207
-texttools/tools/internals/operator.py,sha256=ZoPL77k_voerm7vOorHU3UkC688R_KJJkQ8GoO-6gmc,10021
+texttools/tools/async_the_tool.py,sha256=EWMVgJFJdhKqeMIXHt62PBgFzAClrA0uwVXHVgLJJis,11055
+texttools/tools/the_tool.py,sha256=FiivHbCBzJPQJW-bxsLMyzKyTuHR9cRcDtLI_F7iNCI,14025
+texttools/tools/internals/async_operator.py,sha256=BIIrCVoHJijqjf0h97JXUt5C4MLxgbuqzs412PCVpoo,6376
+texttools/tools/internals/base_operator.py,sha256=lUkZ_nYmLJmop0f5A9n1RjHyoNxjRsCcaCI9uWxtEhs,2912
+texttools/tools/internals/operator.py,sha256=r2OXqQv2WNd6zzjUIC5pzyAQYd9c18EglifbNS5DTSA,6282
 texttools/tools/internals/output_models.py,sha256=Rf2x-UuGlmQHrvYIqnD11YuzMH_mPuir62HoMJQa2uk,1528
 texttools/tools/internals/prompt_loader.py,sha256=_4Tpu5aykKUwqcQEK88HPMlRvmQiokk0nP2TKmWZ924,2260
-hamtaa_texttools-1.0.6.dist-info/METADATA,sha256=GPACtX50UntjeIHgi2LNL2jdPVHG3XFVR0PhU-rWpxc,7506
-hamtaa_texttools-1.0.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hamtaa_texttools-1.0.6.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
-hamtaa_texttools-1.0.6.dist-info/RECORD,,
+hamtaa_texttools-1.0.7.dist-info/METADATA,sha256=-jY_oOC-vybOB2_BviSvm5tRCd2CGKK1ZLad2b6GFkk,7506
+hamtaa_texttools-1.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hamtaa_texttools-1.0.7.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
+hamtaa_texttools-1.0.7.dist-info/RECORD,,

texttools/tools/async_the_tool.py

@@ -1,9 +1,9 @@
-from typing import Literal
+from typing import Literal, Any
 
 from openai import AsyncOpenAI
 
-import texttools.tools.internals.output_models as OutputModels
 from texttools.tools.internals.async_operator import AsyncOperator
+import texttools.tools.internals.output_models as OutputModels
 
 
 class AsyncTheTool:
@@ -12,266 +12,327 @@ class AsyncTheTool:
 
     Usage:
         async_client = AsyncOpenAI(...)
-        tool = TheToolAsync(async_client, model="gemma-3")
-        result = await tool.categorize("متن ...", with_analysis=True)
+        tool = TheToolAsync(async_client, model="model-name")
+        result = await tool.categorize("text ...", with_analysis=True)
     """
 
     def __init__(
         self,
         client: AsyncOpenAI,
-        *,
         model: str,
-        temperature: float = 0.0,
     ):
-        self.operator = AsyncOperator(
-            client=client,
-            model=model,
-            temperature=temperature,
-        )
+        self.operator = AsyncOperator(client=client, model=model)
 
     async def categorize(
         self,
         text: str,
         with_analysis: bool = False,
-        user_prompt: str = "",
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int = 8,
-        max_tokens: int | None = None,
+        top_logprobs: int | None = None,
     ) -> dict[str, str]:
-        results = await self.operator.run(
-            text,
-            prompt_file="categorizer.yaml",
-            output_model=OutputModels.CategorizerOutput,
+        """
+        Categorize a text into a single Islamic studies domain category.
+
+        Args:
+            text: Input string to categorize.
+            with_analysis: If True, first runs an LLM "analysis" step and
+                           conditions the main prompt on that analysis.
+
+        Returns:
+            {"result": <category string>}
+            Example: {"result": "باورهای دینی"}
+        """
+        return await self.operator.run(
+            # User parameters
+            text=text,
             with_analysis=with_analysis,
-            resp_format="parse",
+            output_lang=output_lang,
             user_prompt=user_prompt,
+            temperature=temperature,
             logprobs=logprobs,
             top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
+            # Internal parameters
+            prompt_file="categorizer.yaml",
+            output_model=OutputModels.CategorizerOutput,
+            resp_format="parse",
+            mode=None,
         )
-        return results
 
     async def extract_keywords(
         self,
         text: str,
-        output_lang: str | None = None,
         with_analysis: bool = False,
-        user_prompt: str = "",
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
+        top_logprobs: int | None = None,
     ) -> dict[str, list[str]]:
-        results = await self.operator.run(
-            text,
-            prompt_file="keyword_extractor.yaml",
-            output_model=OutputModels.ListStrOutput,
+        return await self.operator.run(
+            # User parameters
+            text=text,
             with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
             output_lang=output_lang,
+            user_prompt=user_prompt,
+            temperature=temperature,
             logprobs=logprobs,
             top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
+            # Internal parameters
+            prompt_file="extract_keywords.yaml",
+            output_model=OutputModels.ListStrOutput,
+            resp_format="parse",
+            mode=None,
         )
-        return results
 
     async def extract_entities(
         self,
         text: str,
-        output_lang: str | None = None,
         with_analysis: bool = False,
-        user_prompt: str = "",
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
+        top_logprobs: int | None = None,
     ) -> dict[str, list[dict[str, str]]]:
-        results = await self.operator.run(
-            text,
-            prompt_file="ner_extractor.yaml",
-            output_model=OutputModels.ListDictStrStrOutput,
+        return await self.operator.run(
+            # User parameters
+            text=text,
             with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
             output_lang=output_lang,
+            user_prompt=user_prompt,
+            temperature=temperature,
             logprobs=logprobs,
             top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
+            # Internal parameters
+            prompt_file="extract_entities.yaml",
+            output_model=OutputModels.ListDictStrStrOutput,
+            resp_format="parse",
+            mode=None,
         )
-        return results
 
     async def is_question(
         self,
-        question: str,
-        output_lang: str | None = None,
+        text: str,
         with_analysis: bool = False,
-        user_prompt: str = "",
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int = 2,
-        max_tokens: int | None = None,
+        top_logprobs: int | None = None,
     ) -> dict[str, bool]:
-        results = await self.operator.run(
-            question,
-            prompt_file="is_question.yaml",
-            output_model=OutputModels.BoolOutput,
+        return await self.operator.run(
+            # User parameters
+            text=text,
             with_analysis=with_analysis,
-            resp_format="parse",
             user_prompt=user_prompt,
-            output_lang=output_lang,
+            temperature=temperature,
             logprobs=logprobs,
             top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
+            # Internal parameters
+            prompt_file="is_question.yaml",
+            output_model=OutputModels.BoolOutput,
+            resp_format="parse",
+            mode=None,
+            output_lang=None,
         )
-        return results
 
     async def text_to_question(
         self,
         text: str,
-        output_lang: str | None = None,
         with_analysis: bool = False,
-        user_prompt: str = "",
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
+        top_logprobs: int | None = None,
     ) -> dict[str, str]:
-        results = await self.operator.run(
-            text,
-            prompt_file="text_to_question.yaml",
-            output_model=OutputModels.StrOutput,
+        return await self.operator.run(
+            # User parameters
+            text=text,
             with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
             output_lang=output_lang,
+            user_prompt=user_prompt,
+            temperature=temperature,
             logprobs=logprobs,
             top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
+            # Internal parameters
+            prompt_file="text_to_question.yaml",
+            output_model=OutputModels.StrOutput,
+            resp_format="parse",
+            mode=None,
         )
-        return results
 
     async def merge_questions(
         self,
-        questions: list[str],
-        output_lang: str | None = None,
-        mode: Literal["default", "reason"] = "default",
+        text: list[str],
         with_analysis: bool = False,
-        user_prompt: str = "",
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
+        top_logprobs: int | None = None,
+        mode: Literal["default", "reason"] = "default",
     ) -> dict[str, str]:
-        question_str = ", ".join(questions)
-        results = await self.operator.run(
-            question_str,
-            prompt_file="question_merger.yaml",
-            output_model=OutputModels.StrOutput,
+        text = ", ".join(text)
+        return await self.operator.run(
+            # User parameters
+            text=text,
             with_analysis=with_analysis,
-            use_modes=True,
-            mode=mode,
-            resp_format="parse",
-            user_prompt=user_prompt,
             output_lang=output_lang,
+            user_prompt=user_prompt,
+            temperature=temperature,
             logprobs=logprobs,
             top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
+            # Internal parameters
+            prompt_file="merge_questions.yaml",
+            output_model=OutputModels.StrOutput,
+            resp_format="parse",
+            mode=mode,
         )
-        return results
 
     async def rewrite(
         self,
-        question: str,
-        output_lang: str | None = None,
-        mode: Literal["positive", "negative", "hard_negative"] = "positive",
+        text: str,
         with_analysis: bool = False,
-        user_prompt: str = "",
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
+        top_logprobs: int | None = None,
+        mode: Literal["positive", "negative", "hard_negative"] = "positive",
     ) -> dict[str, str]:
-        results = await self.operator.run(
-            question,
-            prompt_file="rewriter.yaml",
-            output_model=OutputModels.StrOutput,
+        return await self.operator.run(
+            # User parameters
+            text=text,
             with_analysis=with_analysis,
-            use_modes=True,
-            mode=mode,
-            resp_format="parse",
-            user_prompt=user_prompt,
             output_lang=output_lang,
+            user_prompt=user_prompt,
+            temperature=temperature,
             logprobs=logprobs,
             top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
+            # Internal parameters
+            prompt_file="rewrite.yaml",
+            output_model=OutputModels.StrOutput,
+            resp_format="parse",
+            mode=mode,
         )
-        return results
 
     async def subject_to_question(
         self,
-        subject: str,
+        text: str,
         number_of_questions: int,
-        output_lang: str | None = None,
         with_analysis: bool = False,
-        user_prompt: str = "",
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
+        top_logprobs: int | None = None,
     ) -> dict[str, list[str]]:
-        results = await self.operator.run(
-            subject,
-            prompt_file="subject_to_question.yaml",
-            output_model=OutputModels.ReasonListStrOutput,
-            with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
+        return await self.operator.run(
+            # User parameters
+            text=text,
             number_of_questions=number_of_questions,
+            with_analysis=with_analysis,
             output_lang=output_lang,
+            user_prompt=user_prompt,
+            temperature=temperature,
             logprobs=logprobs,
             top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
+            # Internal parameters
+            prompt_file="subject_to_question.yaml",
+            output_model=OutputModels.ReasonListStrOutput,
+            resp_format="parse",
+            mode=None,
         )
-        return results
 
     async def summarize(
         self,
         text: str,
-        output_lang: str | None = None,
         with_analysis: bool = False,
-        user_prompt: str = "",
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
+        top_logprobs: int | None = None,
     ) -> dict[str, str]:
-        results = await self.operator.run(
-            text,
-            prompt_file="summarizer.yaml",
-            output_model=OutputModels.StrOutput,
+        return await self.operator.run(
+            # User parameters
+            text=text,
             with_analysis=with_analysis,
-            resp_format="parse",
-            user_prompt=user_prompt,
             output_lang=output_lang,
+            user_prompt=user_prompt,
+            temperature=temperature,
             logprobs=logprobs,
             top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
+            # Internal parameters
+            prompt_file="summarize.yaml",
+            output_model=OutputModels.StrOutput,
+            resp_format="parse",
+            mode=None,
         )
-        return results
 
     async def translate(
         self,
         text: str,
         target_language: str,
         with_analysis: bool = False,
-        user_prompt: str = "",
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int = 3,
-        max_tokens: int | None = None,
+        top_logprobs: int | None = None,
     ) -> dict[str, str]:
-        results = await self.operator.run(
-            text,
-            prompt_file="translator.yaml",
-            output_model=OutputModels.StrOutput,
+        return await self.operator.run(
+            # User parameters
+            text=text,
+            target_language=target_language,
             with_analysis=with_analysis,
-            resp_format="parse",
+            output_lang=output_lang,
             user_prompt=user_prompt,
-            target_language=target_language,
+            temperature=temperature,
             logprobs=logprobs,
             top_logprobs=top_logprobs,
-            max_tokens=max_tokens,
+            # Internal parameters
+            prompt_file="translate.yaml",
+            output_model=OutputModels.StrOutput,
+            resp_format="parse",
+            mode=None,
+        )
+
+    async def run_custom(
+        self,
+        prompt: str,
+        output_model: Any,
+        output_lang: str | None = None,
+        temperature: float | None = None,
+        logprobs: bool | None = None,
+        top_logprobs: int | None = None,
+    ) -> dict[str, Any]:
+        """
+        Custom tool that can do almost anything!
+
+        Args:
+            prompt: Custom prompt.
+            output_model: Custom BaseModel output model.
+
+        Returns:
+            {"result": <Any>}
+        """
+        return await self.operator.run(
+            # User paramaeters
+            text=prompt,
+            output_model=output_model,
+            output_model_str=output_model.model_json_schema(),
+            output_lang=output_lang,
+            temperature=temperature,
+            logprobs=logprobs,
+            top_logprobs=top_logprobs,
+            # Internal parameters
+            prompt_file="run_custom.yaml",
+            resp_format="parse",
+            user_prompt=None,
+            with_analysis=False,
+            mode=None,
         )
-        return results